WebAssembly

A Senior Staff engineer at Google who works on the Perfetto tracing tool called the underlying premise "a very simplistic take" — constraints trade off against each other and rarely collapse to one answer.

Another reply described the worst codebase of their career: a team building an elaborate microservices architecture for a web app with fewer monthly users than the commenter's own hobby website.

The provocation was doing a lot of work as written, so the author stepped into the thread to narrow it: as a mathematician, he means you can't find all bugs or any particular bug — not that finding bugs never happens.

A WebAssembly co-founder wasn't buying the softened version either, calling the thesis 'self-justification for being a lazy code reviewer.' And a 90k-karma veteran landed the real finding: there is no 'the' purpose — we all thought we were reviewing for the same reasons, and we simply aren't.

An ngrok developer educator ported a slice of Kubernetes to TypeScript so a cluster runs entirely in the browser: pods, DNS, deployments, garbage collection, all client-side. LLMs wrote almost all of it, roughly 100,000 lines across 552 commits in two months.

His answer to the inevitable 'is this just slop?': read every line, plus 204 integration tests and 1,855 unit tests asserting it matches a real cluster via the official k8s client. An SRE in the thread noted the easy 80% is done; ConfigMaps, Secrets and Ingress are where the pain lives.

The trick is the second layer. WATaBoy emits WebAssembly bytecode for hot game code, and Safari's engine compiles that Wasm to native machine code on its own — so the emulator rides the browser's JIT instead of fighting it.

A systems engineer in the thread deflated the surprise with arithmetic: Wasm overhead runs near 20 percent, an interpreter's loop overhead near 1000. Beating the interpreter was never the hard part. The novelty is a Game Boy JIT runtime existing at all.

The port leans on a rendering mode called ToGLES: the Source engine emits OpenGL ES calls meant for Android, and Emscripten translates them into WebGL2. It started from a friend's Portal port, itself a fork of a Source engine codebase that traces back to the 2020 leak.

It also exposes what's missing. James Darpinian, ex-Meta and Google, counted the absent shaders: G-Man has no eyes, nobody's lips move, Breen's video screens are blank.

And it runs on hardware Valve abandoned, which is most of the appeal.

F3 is a columnar data format — a Parquet rival — that carries the WASM binaries needed to decode it inside every file. One engineer who builds data connectors called the self-describing trick genius.

The pushback came from people who archive at scale: keeping petabytes for ten years, you don't want to depend on a WASM interpreter being fast in 2051, you want a dead-simple byte spec like Parquet's. And the README, several noted, never says which Parquet shortcomings F3 fixes.

CS 6120, Adrian Sampson's Cornell graduate compilers course, is fully self-guided online: 14 lessons from SSA to dynamic compilers, real PLDI/ASPLOS papers, and tasks you implement in Bril, a teaching IL built for the course.

The top comment is a working compiler engineer rerouting the syllabus: trace compilation is 'a dead end,' he says - the concepts that matter are type feedback, speculation and deoptimization.

MicroUI emits a list of draw commands and demands input back; it draws nothing and allocates nothing beyond a fixed memory region. That's how it stays portable enough to compile to WebAssembly and run in a browser.

One longtime user called it his go-to for toy projects but flagged it as effectively abandonware, with a known draw-call bug that does a misaligned pointer access — harmless until you run it under Zig, which panics on exactly that.

Bernhardt's 2014 talk wasn't really about JavaScript dying. Its thesis: a fast bytecode-like subset (asm.js) becomes the universal compile target, the boundary between OS and browser dissolves, and JS survives as an invisible substrate you compile to but never touch.

The grades are split. WebAssembly proved him broadly right on direction. But one engineer flags the catch: Wasm still can't touch the DOM, so JavaScript glue isn't going anywhere — the prediction's timeline is slipping.

WASI 0.3, ratified June 11, replaces the old polling primitives with first-class stream<T>, future<T> and async functions, moving to completion-based scheduling like io_uring. One event loop, managed by the host, is shared by all components.

The Wasmer CEO's reality check in the thread: it runs in one server-side runtime, no browser support, and it again breaks compatibility with the original WASI — and a decade in, skeptics still ask whether WebAssembly has had its breakthrough.