Hey Community,

We look at Eve, Vercel's framework for structuring AI agents as regular folders. We also dive into Pake, a Tauri-backed CLI tool that packages web apps into native desktop apps under 5MB.

Plus, Software Mansion introduces react-native-morph-view to melt shapes and images together using real GPU shaders instead of standard crossfades.

And this week we're also raffling one free ticket to Chain React 2026 in Portland, Oregon 🎟️

If we made you nod, smile, or think "oh… that's actually cool" — a share or reply genuinely helps ❤️

I got tired of CSV exports breaking in production, so I built this. It reads and writes CSV from one small zero-dependency package, streams both directions at flat memory, and the same code runs on Node, browsers, Deno, Bun, and edge.

A few things that make it nice to use: - Encode and parse are mirror images, so a round-trip keeps its shape. - It hands back a Web ReadableStream, so a CSV download streams straight to the client without buffering. - A sanitizeFormulas flag neutralizes spreadsheet formula injection in exports. - On TypeScript, the column list is checked against your data, so a mistyped column is a compile error.

It also came out the fastest of the common parsers in my benchmark: roughly 3x to 13x faster than papaparse, csv-parse, and fast-csv on a 50k-row dataset. The benchmark and a conformance suite (a curated edge-case corpus, csv-spectrum, and fast-check property tests) run in CI, so the numbers and the correctness are reproducible, not claims.

To be clear about what is not unique: zero dependencies, a formula-injection guard, and browser support are shared with papaparse and csv-parse/csv-stringify. fast-csv is the one that lags there.

Repo: https://github.com/martsinlabs/csv-pipe Docs: https://martsinlabs.github.io/csv-pipe/ Playground: https://martsinlabs.github.io/csv-pipe/playground

I'm making a quick and dirty way to make dictionaries where many keys map to the same item, and instead of using a single hashable item as the key, it makes use of an array of hashable items to build the map. I don't like using tuples, but I don't think it would be valid to have an array as the key of a dictionary. I would love it if I could do that however. Is there a way to make a hashable array?

let map = MapFactory(
    [
        [[1,2,3], () => "1-3"],
        [[4,5,6], () => "4-6"],
        [[7,8,9], () => "7-9"]
    ]
);
console.log(map.get(1)()); // "1-3"
console.log(map.get(6)()); // "4-6"


function MapFactory(mapItems) {
    const map = new Map();
    for (let [keys, value] in mapItems) {
        for(let key in keys) {
        map.set(key, value);
        }
    }
    return map;
}

I got tired of rewriting my upload code every time a project switched buckets (or added "let users connect their Google Drive"). So I built a project: five portable ops that behave identically everywhere, swap providers by config.

import { createStorage } from "@rocketbean/genera";
import { S3Driver } from "@rocketbean/genera-s3";

const storage = createStorage(new S3Driver({ bucket, region, credentials }));
await storage.put("users/42/avatar.png", bytes);

// swap S3Driver → GoogleDriveDriver and the rest of your code is unchanged

What I think makes it worth a look:
- Isomorphic — core uses only web standards, so it runs in the browser too
- Escape hatch — .native gives you the raw provider SDK any time; the abstraction never blocks you
- Typed capabilities — signed URLs / streaming / copy are advertised per-driver, no silent surprises
- Conformance-tested — every driver passes one shared suite (Node, real browser, live accounts)
- Dependency-light core; cloud SDKs are peer deps so you only install what you use

It's v1.0.0 and solo-maintained, so eyes/feedback very welcome.
this project is on it's early stage, feedback would really be appreciated

Recently I've developed a code-golfed signal implementation with the following features/constraints:

1. subscribes functions returning nullish values.
2. fires all pending subscribers and resets.
3. requires no arguments to be passed to the factory and either null/undefined or a function to the signal. (as noted by u/azhder)

As it turns out, you can go as short as 33 bytes using function compositon, nullish coalescing and default parameters:

F=>(f,G=F)=>F=f?_=>f(G?.()):F?.()

Monday, June 15 - Sunday, June 21, 2026

Top Posts

Most Commented Posts

Top Ask JS

Top Showoffs

Top Comments

Factories.ts is a lightweight DSL for generating markup directly in JavaScript/TypeScript. Elements are ordinary functions you nest together, so the full structure is built with regular JS/TS, including loops, conditionals, and type checking, instead of a separate template language:

import { ul, li } from "@ts-series/factories"

const items = [
    { name: "Coffee", inStock: true },
    { name: "Tea", inStock: false },
];

const list = ul(
    ...items.map(item =>
        li(item.name, item.inStock ? null : " (sold out)")
            .class(item.inStock ? "available" : "unavailable")
    )
);

console.log(list.expand());

The functions, referred to here as "factories", return element objects that store their content as plain arrays. This makes the approach highly efficient and, unlike JSX, requires no separate build process.

Works in Deno and Node.

Did you find or create something cool this week in javascript?

Show us here!

• Modern AsyncIterator API
• Integrates with Standard Schema
• Allows you to navigate to any parts of JSON, without considering order of appearance in a stream
• Structural (e.g. {}[]) position bitmap construction, caching and navigation, written in Rust

Benchmarks are in the README.md.

Hey folks. wrote this library to satisfy an itch for me: To make an ergonomic streaming JSON library whilst still being incredibly fast.

I took lessons from simdjson and JSONSki and applied it to a low-memory environment niche. Inspired from a situation at work where we didn't have control over the data and we're parsing a 10MB JSON in order to aggregate some data to the frontend (ugh). Existing streaming JSON libraries in node were too slow, outdated or you weren't able to control how much memory you want to balance.

Disclaimer: I had AI help but not vibe coded. I wrote the JS part but since I was new to Rust, I needed some hand-holding. Was a labour of love for 6 months, was always on the wheel, made a lot of effort to verify the quality of the Rust code and dogfooded it but I wanted to be transparent regardless.

If this is useful to anyone or if there's anything wrong to my claim, let me know and I'm happy to chat!

Been running Node processes in production and you know that thing where a process just dies and leaves nothing in the logs? Yeah. I tried sending PRs to Vite and E2B to add a crash hook. They rejected it, which honestly fair enough — why would they add an env var for something most people don't need. So I made a tiny wrapper instead. You just do FATAL_HANDLER=/usr/bin/logger npx @misaka-net/fatal-guard -- node app.js and when it crashes it writes a small JSON to syslog with the reason and pid. Zero deps, MIT, works with any Node CLI. Why a wrapper instead of normal process events? When Node.js crashes catastrophically under high load, the V8 event loop often terminates so instantly that upstream logging libraries don't get enough event loop ticks to flush remaining write-buffers to disk. By running as a parent observer, fatal-guard completely bypasses this race condition, ensuring the telemetry tombstone always flies out.

Open source browser interfaces for hacked POS terminals used as live instrument