Dev · Monday, 17 August 2026 · Issue 79 · 13 stories

ESM live bindings vs CJS copies: not the same; Rust GPU offload

Languages & Frameworks

ESM Imports Are Live Bindings; CommonJS Copies Values. They Are Not the Same

import and require look interchangeable but hide different contracts: ESM named imports are live read-only bindings, while CommonJS destructuring copies values, so equivalent-looking code produces different results. The writeup walks through live bindings, circular dependencies, separate caches, and dual-package hazards that can break code silently in Node. For teams maintaining dual-format packages, this is the sharp edge worth internalizing.

blog.gaborkoos.com ↗29 min read at source

Watch your Go heap get defragmented, Windows 98 style

gogc98 turns Go's runtime traceallocfree flights into a live heap visualizer, showing allocations landing and the GC reclaiming space in real time. One line of probe instrumentation plus one GODEBUG flag is all a target program needs, though it's an educational toy, not production tooling.

github.com ↗3 min read at source

Rust compiler gets native, safe GPU offload, no vendor DSL required

The Rust team built zero-overhead, multi-vendor GPU offload straight into rustc and LLVM, using ownership and noalias to manage GPU memory safely without vendor-locked DSLs or raw pointers. A two-pass pipeline handles host/device ABI mismatches, and early RAJAPerf results match hand-tuned CUDA and HIP C++ kernels.

arxiv.org ↗2 min read at source

C3's author admits he misbranded his own language

The C3 language's creator explains why "C replacement" was the wrong framing: today that phrase means systems work, but he was really after the raw, procedural dev speed he got from Turbo Pascal and PHP. A candid reframe of what C3 actually optimizes for and who it serves.

c3-lang.org ↗8 min read at source

A C compiler written in TypeScript that boots straight off a floppy

A handcrafted C99 multipass compiler written in TypeScript, complete with a left-recursive parser, custom IR, SSA optimizer, and backend, compiles C straight to raw x86 real-mode binaries you can load from a floppy. It even supports x87 floating point and ships an integrated assembler plus emulator. A striking demonstration of the full compiler pipeline in one bootable artifact.

github.com ↗1 min read at source

Rust's stdlib finally catches its own accidental API breakage in CI

cargo-semver-checks now scans the Rust standard library in CI, after months and 15,000+ lines of work. The post details past silent breakages (dyn-safe traits, Send/Sync, Windows failures) and how they special-cased stable vs unstable APIs. A solid model for any project with breaking-change risk.

predr.ag ↗10 min read at source

Protobuf finally gets a real LSP server, courtesy of Buf

Buf shipped the first spec-compliant Language Server Protocol server for Protobuf, bringing go-to-definition, completion, and find-references to VSCode, Neovim, and other editors for the first time. It bundles with the Buf CLI, so Protobuf devs finally get modern IDE support without bolting on skips.

buf.build ↗4 min read at source

Writing a C compiler and browser by hand for AMD's Am29000 CPU

Oscar Toledo recounts building a C compiler and a web browser for his homebrew Am29000 computer in 1998, working around 512 KB of RAM that was too small for GCC. It's a detailed, first-person look at compiler design, code generation, and retro toolchain limits. Perfect reading for anyone who loves compiler plumbing.

nanochess.org ↗44 min read at source

Tools & Platforms

Numba's JIT compiler now runs in your browser, no Python server required

The Numba JIT compiler now runs entirely in WebAssembly inside JupyterLite, a long-requested feat that required a WASM-aware llvmlite execution engine and in-browser LLVM linking. The demo shows roughly a 250x speedup over standard Python, with gains even larger relative to native. Scientific Python notebooks can now ship as static sites with no server.

notebook.link ↗7 min read at source

DuckDB v2.0 turns the in-process database into a networked server

The fall v2.0 release, "Cyanoptera", ships client/server mode via the quack extension and a new CONNECT statement, plus triggers, a VARIANT type, async I/O, a fresh SQL parser, and a new storage format. It advances the year of DuckDB as a server, with remote pushdown to Postgres and MySQL.

duckdb.org ↗15 min read at source

AI-Assisted Development

Copilot Autofix Introduced the Very Bug That Let an AI Agent Into Snowflake's Jira

Wiz's autonomous Red Agent found a GitHub Actions script-injection hole in Snowflake's connector repo, then used it to reach internal Jira data. The kicker: the vulnerable code was a Copilot Autofix commit that deleted the old sanitized pattern five days before. A concrete case for auditing AI-generated patches.

wiz.io ↗5 min read at source

Qwen 3.8 27B is great locally, if you shut off its runaway default thinking

Qwen 3.8 27B ships with reasoning effort defaulted to xhigh, so a trivial SVG prompt burned 22k tokens and 21 minutes on a laptop. Flip it off and the same output takes 2 minutes. A lively reminder that the default isn't the right one for consumer hardware.

simonwillison.net ↗10 min read at source

Engineering Practice

The obsessive byte-counting that fit RuneScape into 5KB/s dial-up

A decompiled 2004 RuneScape 2 client reveals the compression tricks behind rendering thousands of players over a 56k modem and one TCP connection. Traces a single tile-click through the 600ms server tick to show how every spared byte buys back latency.

jkm.dev ↗15 min read at source

You’re caught up.

That was all 13 stories in the 17 August issue.