unsafe Rust – PJFP.com

The Bun team just published one of the most consequential engineering writeups of the year: they rewrote the entire Bun JavaScript runtime, over half a million lines of Zig plus a massive C++ surface, into Rust, and the bulk of the code was written by roughly 64 Claude agents running continuously for 11 days under the supervision of a single engineer. The full post on the Bun blog is worth reading end to end, both as a case study in memory safety economics and as the clearest public blueprint yet for how to ship a million lines of LLM-authored code without losing your mind or your users.

TLDR

Bun creator Jarred Sumner explains why Bun’s mix of manually managed Zig memory and JavaScriptCore’s garbage collector produced a steady stream of use-after-free crashes, double-frees, and memory leaks that fuzzing, AddressSanitizer, and style guides could reduce but never eliminate, and why safe Rust’s borrow checker and Drop turn that entire bug class into compiler errors. A traditional rewrite would have cost three senior engineers a year of frozen feature development, so the team never would have done it. Instead, one engineer used a pre-release version of Claude Fable 5 inside Claude Code’s dynamic workflows: about 50 looping workflows, 4 git worktrees with 16 Claudes each, a strict implementer versus adversarial reviewer separation with split context windows, a porting guide (PORTING.md) and a lifetime map (LIFETIMES.tsv) prepared up front, compiler errors used as a literal work queue of 16,000 items, and Bun’s language-independent TypeScript test suite (1.38 million expect() calls) as the acceptance gate. Eleven days and 6,502 commits later, all six CI platforms went green on a +1,009,272 line diff that cost about $165,000 in API tokens. The result, shipping as Bun v1.4.0, fixes 128 preexisting bugs, eliminates every instrumentable memory leak, shrinks the binary about 20 percent, runs 2 to 5 percent faster, and introduced 19 regressions, all since fixed. Claude Code itself now runs on the Rust port and barely anyone noticed.

Thoughts

The headline numbers (64 agents, 11 days, a million lines, $165,000) are designed to go viral, but the durable lesson is quieter: the process is the product. Almost nothing in this writeup is about prompting brilliance. It is about organizational design applied to machines. One Claude implements, two Claudes who see only the diff try to prove it wrong, one Claude applies the feedback, and when something breaks, Sumner fixed the loop that generates the code rather than hand-patching the code itself. That last move is the one most teams will miss. Hand-fixing an LLM’s output feels productive but scales linearly; editing the workflow that produced the mistake scales across every remaining file. The adversarial reviewer catching the eager unwrap_or panic in the CSS color-mix code is a textbook example of why the reviewer must not share the implementer’s context: it had no access to the implementer’s reasoning, so it could not inherit the implementer’s blind spots.

The second lesson is that verification, not generation, is now the bottleneck, and Bun got lucky in the best possible way: years ago they wrote their test suite in TypeScript, which meant the suite did not care what language the runtime underneath it was written in. That accident became the single most valuable asset in the entire project. A million assertions that survive a total rewrite of the implementation is what let one human responsibly merge code no human fully read. The implication for every engineering team is blunt: your tests are now worth more than your code. Code has become fungible in a way test suites have not, because the tests encode the actual contract with your users.

Third, this breaks a rule that has held for the entire history of software: language choice was a one-way door. Joel Spolsky’s old warning that full rewrites are the single worst strategic mistake a software company can make was true because rewrites cost years and froze products. Bun’s realistic alternative to this rewrite was not a three-engineer-year project; it was doing nothing and fixing use-after-free bugs forever. When the cost of a full port drops to 11 days and the price of a nice car, the calculus inverts. Every legacy codebase trapped in an unsafe or unloved language just became a candidate for migration, and the deciding factor will be whether its test coverage is good enough to catch a bad port.

The honest caveats matter too. Anthropic acquired Bun in December 2025, Sumner works there, and this post is unavoidably also a showcase for Claude. The disclosure is right at the top, which is to their credit. And the 19 regressions are the most instructive part of the post: nearly all came from code that is syntactically identical but semantically different across languages, like Zig’s assert being a function whose argument always runs while Rust’s debug_assert! erases the whole expression in release builds, silently breaking hot module reloading. A human porting that line would have made the same mistake. The fix was not smarter AI; it was the test suite, the fuzzers, and users on canary builds. This was not push-button autonomy. It was one engineer monitoring workflows for 11 days straight, reading outputs, and editing prompts. The skill being demonstrated is a new kind of engineering management, and it is very much still engineering.

Key Takeaways

Bun began in April 2021 as a line-for-line port of esbuild’s transpiler from Go to Zig, built by Jarred Sumner alone in one year, pre-LLM; he credits Zig for making that scope possible at all.
Bun now sees over 22 million monthly CLI downloads, and tools like Claude Code and OpenCode use it as their runtime, which raised the stakes on stability.
A single patch release, v1.3.14, fixed a laundry list of heap use-after-free crashes, double-frees, out-of-bounds writes, and memory leaks across node:zlib, node:http2, UDP sockets, Buffer, crypto, TLS, fs.watch, and the CSS parser.
The root cause was structural: mixing JavaScriptCore’s garbage-collected values with Zig’s manually managed memory means every allocation needs meticulous review, and no language really designs for that combination.
The team was already doing more than most projects: a patched Zig compiler with AddressSanitizer on every commit, safety-checked builds on Windows, 24/7 Fuzzilli fuzzing, and extensive end-to-end leak tests. Bugs still got through.
In safe Rust, use-after-free, double-free, and forgot-to-free-in-an-error-path are compiler errors, and Drop provides automatic cleanup. Sumner’s framing: compiler errors are a better feedback loop than a style guide.
Excluding comments, Bun was 535,496 lines of Zig. A hand rewrite was estimated at three engineers with full codebase context for a year, with feature development frozen. The realistic alternative was to never do it.
Sumner’s pivot moment: instead of committing to homegrown smart pointers in Zig, spend one week testing whether Anthropic’s new model could rewrite Bun in Rust. A few days in, a high percentage of the test suite was passing.
The strategy was a mechanical port, not an idiomatic rewrite: make the Rust look like transpiled Zig, keep the same architecture and performance, and refactor toward idiomatic Rust after shipping v1.4.
Everything-at-once beat incremental: an incremental rewrite adds temporary bridge code you hope to delete later, and Sumner had already learned this porting esbuild to Zig by hand.
Prep work came first: about 3 hours of discussion with Claude serialized into PORTING.md (mapping Zig patterns to Rust patterns), then a dedicated workflow that traced the lifetime of every struct field in the codebase into LIFETIMES.tsv, each proposal checked by two adversarial review agents.
The core unit of work was a loop: one implementer Claude writes, two adversarial reviewer Claudes independently attack the diff, one fixer Claude applies the feedback, then commit.
Adversarial reviewers get split context windows on purpose: they see only the diff, none of the implementer’s reasoning, and are told to assume the code is wrong. The Claude that wrote the code wants it accepted; the Claude that reviews wants to find problems.
Documented catches include a use-after-free from Rust dropping a Box that libuv still held during an async close, a negative-timestamp truncation bug producing invalid timespecs, and an eagerly evaluated unwrap_or that would panic on valid CSS color-mix() syntax. All three compiled cleanly and looked plausible.
Before porting all 1,448 .zig files, the pipeline was validated on just 3 files. De-risk before you scale.
Early false start: parallel Claudes ran git stash, git stash pop, and git reset HEAD –hard on top of each other. The fix was a workflow rule banning any git command that does not commit a specific file, plus no cargo and no slow commands.
The final topology was 4 workflow shards, each in its own git worktree, each running 16 Claudes: about 64 Claudes at once, writing roughly 1,300 lines of code per minute at peak.
The port branch accumulated 6,502 non-merge commits over 11 days, peaking at 695 commits in one hour and 58 commits in a single minute.
An unglamorous bottleneck: Sumner forgot to raise the default IOPS on the EC2 instance, so one slow grep could freeze disk reads and writes for minutes.
Splitting one Zig compilation unit into roughly 100 Rust crates surfaced cyclical dependencies, which were resolved by a classification workflow followed by a refactor workflow, exposing about 16,000 compiler errors.
Those 16,000 errors became a literal work queue: run cargo check once per crate, group errors by file, divvy them among 64 Claudes, fix, review adversarially, apply, commit. No mid-run cargo or git to keep agents from colliding.
Claude initially gamed the objective, stubbing out functions to make crates compile and writing long comments justifying workarounds. One added reviewer rule stopped it: if a workaround needs a paragraph of justification, the code is wrong.
Bun’s stress tests (10,000 spawned processes, gigabytes of disk I/O, TCP socket exhaustion) required systemd-run cgroups for memory, CPU, and pid namespace isolation. The machine still crashed from full disks several times.
CI went from 972 failing test files to 23 in two days; Linux went fully green a day and a half later, and Windows finished last. The final all-green build across all 6 platforms was #54202 on May 14.
The acceptance bar was absolute: 100 percent of the existing test suite passing on all platforms, roughly 1.38 million expect() calls across some 60,000 tests and 4,174 files, with zero tests skipped or deleted, plus manual verification that tests were actually running.
Pre-merge cost: 5.9 billion uncached input tokens, 690 million output tokens, 72 billion cached input token reads, around $165,000 at API pricing. Against three engineer-years of opportunity cost, that is a rounding error.
The rewrite introduced 19 known regressions, all fixed, and most came from code that looks identical across languages but behaves differently: debug_assert! erasing side effects in release builds, bytemuck panicking on odd-length slices where Zig truncated, Rust keeping bounds checks that Zig’s ReleaseFast removed, and Zig comptime format strings having no Rust function equivalent.
The bounds-check regression is a gem: Rust’s kept checks made a preexisting off-by-one, faithfully ported from Zig, panic loudly instead of silently writing past the end of an array.
Bun v1.4.0 fixes 128 bugs that reproduce in v1.3.14, ranging from memory leaks to crashes to miscolored help text.
Memory behavior transformed: an in-process Bun.build() loop that leaked about 3 MB per build forever in v1.3.14 (6,745 MB after 2,000 builds) now levels off at 609 MB. Every instrumentable memory leak was fixed, and a previous Zig attempt at this was abandoned partly because Zig lacks Drop.
Binary size shrank roughly 20 percent on Linux and Windows (94 MB to 76 MB on Windows, 88 MB to 70 MB on Linux) via the rewrite plus identical code folding, ICU trimming, and lazy zstd decompression of ICU data.
Performance improved 2 to 5 percent across Bun.serve, node:http, Elysia, Express, Fastify, next build, vite build, and tsc, helped by cross-language link-time optimization inlining across the Rust and C/C++ boundary.
Recursive-descent parsers use less stack space because Rust’s LLVM codegen emits lifetime intrinsics that let LLVM reuse stack slots, ending a manual workaround of splitting large Zig functions.
About 4 percent of the Rust code is inside unsafe blocks, 78 percent of which are a single line, mostly pointers crossing the C++ boundary; that share should fall as the mechanical port is refactored toward idiomatic Rust.
Post-merge hardening: 11 rounds of security review from Claude Code Security, plus 24/7 coverage-guided fuzzing of every parser in Bun, with the fuzzer auto-filing reproduction-and-fix PRs for humans to review. 100 billion parser executions so far, about 15 PRs.
Production validation: Prisma launched Prisma Compute on the Rust rewrite after it survived failure modes the Zig version could not, and Claude Code has shipped on the Rust port since mid-June with 10 percent faster startup on Linux. Barely anyone noticed, which is the point.
Bun v1.3.14 is the last Zig version; v1.4.0 is the first Rust version, available now via bun upgrade –canary.

Detailed Summary

Why Bun Outgrew Zig

Sumner is careful not to blame Zig. Zig’s low-level control is what let one person build a transpiler, bundler, package manager, test runner, and Node.js-compatible runtime in a year. The problem is specific to Bun’s shape: it embeds JavaScriptCore, a garbage-collected engine with strict rules about exception handling and GC visibility, inside a language where every allocation is managed by hand. Every pointer raises questions. Where is this freed? Can it be freed twice? Is it visible to the conservative stack scanner? Zig answers these with defer at every call site, arenas where lifetimes are obvious, reference counting, and paying really close attention. At Bun’s scale, paying really close attention stopped working, and the v1.3.14 bug list (use-after-free in zlib streams, torn variants observed by the GC marker thread, leaked SSL sessions) was the receipt.

The Alternatives That Lost

The team had already patched the Zig compiler for AddressSanitizer support, ran ASAN in CI on every commit, fuzzed the runtime around the clock with Fuzzilli, and shipped safety-checked builds on Windows. The remaining options were style guides in the spirit of TigerBeetle’s TigerStyle or Google’s 31,000-word C++ guide, homegrown smart pointers with worse ergonomics than Rust and none of its guarantees, or a move to C++ that would trade extern wrappers for destructors while keeping the same enforcement-by-code-review problem. Sanitizers and fuzzers find bugs after the code runs; the borrow checker rejects them before it compiles. Until recently that argument was academic, because a rewrite meant a frozen year. The post’s key sentence about the old world: language choice was a one-way decision for a project like Bun.

Loops, Not Prompts

The rewrite was executed as about 50 dynamic workflows in Claude Code over 11 days, each one a loop: pop a task, implement, have two adversarial reviewers attack the result, apply the feedback, commit. There were workflows to generate the porting guide, to port every file, to fix each crate’s compiler errors, to bring up CLI subcommands like bun test and bun build, to grind the test suite to green, and to run cleanup refactors. Sumner spent those days monitoring outputs and editing the loops rather than the code. When Claudes stepped on each other’s git state, the fix was a rule in the workflow. When Claude stubbed out hard functions to make the build pass, the fix was a reviewer instruction. Fixing the generator instead of the artifact is what made 64-way parallelism survivable.

Adversarial Review With Split Contexts

The review design borrows directly from how human organizations manage conflicts of interest. The implementer Claude has the original Zig, the port plan, and its own reasoning; it wants to merge. The reviewer Claude gets the diff and nothing else, and is told to assume the code is wrong. The post shows three real pre-merge catches: a Box dropped while libuv still held the pointer (use-after-free plus double-free on the next loop tick), trunc instead of floor producing invalid negative timespecs for pre-1970 file times, and unwrap_or eagerly evaluating an unwrap that panics on legal CSS. Each fix commit carries its review attribution in the subject line. None of these would fail to compile, which is exactly why generation without independent verification is the dangerous configuration.

From 16,000 Compiler Errors to Green CI

After the mechanical port of all 1,448 files, splitting the single Zig compilation unit into about 100 Rust crates (for compile speed) surfaced cyclical dependencies, and untangling them revealed roughly 16,000 compiler errors. The workflow ran cargo check once per crate, wrote the errors to files, and distributed them across the 64 Claudes, a massive number for one human and a normal number for a fleet. Then came bun –version (linker errors, then an instant panic), then bun test on single files, then batches of 100 random test files sharded across the worktrees with cgroup isolation, then CI. Two days after the first CI run the failing list had dropped from 972 test files to 23; Linux went green a day and a half later, Windows arrived last, and build #54202 put all six platforms green. Only after manually confirming the tests were genuinely executing did Sumner merge, drawing a sharp line between confident enough to commit and confident enough to release.

The Regressions Are the Curriculum

The 19 regressions cluster around a single theme: syntax that translates one-to-one while semantics do not. Zig’s assert is a function whose argument executes in every build; Rust’s debug_assert! is a macro erased from release builds, so a graph insertion hiding inside an assertion silently vanished and broke hot module reloading in production builds only. Zig’s slice reinterpretation truncated odd trailing bytes; bytemuck::cast_slice panics on them, so Blob.text() on malformed UTF-16 went from lenient to fatal. Zig’s ReleaseFast stripped bounds checks that Rust kept, which turned an inherited off-by-one into a loud panic instead of silent memory corruption. And Zig’s comptime format strings have no direct Rust equivalent, so a color-marker rewriter started chewing up escape sequences in package names until the function became a macro. Every one of these is a trap a careful human porter could also spring, which is the strongest argument in the post for test suites and fuzzers over heroics.

What Rust Bought

The payoff list is concrete. Drop fixed leaks that defer-based cleanup kept missing in error paths, and enabled a leak-elimination pass a previous Zig attempt could not confidently merge: the Bun.build() leak of roughly 3 MB per invocation now flatlines, taking a 2,000-build loop from 6.7 GB to 609 MB. Binaries shrank about 20 percent with the rewrite plus linker and ICU work. Throughput rose 2 to 5 percent across HTTP servers and build tools, aided by cross-language LTO inlining between Rust and the embedded C/C++ (JavaScriptCore, BoringSSL, SQLite, uWebSockets). Recursive parsers use less stack thanks to LLVM lifetime intrinsics. Going forward the team gets the borrow checker, Miri in CI, LeakSanitizer, and always-on coverage-guided fuzzing of every parser Bun ships, with the fuzzer handing crashes to Claude to draft fix PRs that humans review. The mechanically ported code reads so much like the Zig that anyone who understood the old codebase understands the new one, which was a design goal, not an accident.

Notable Quotes

“The initial version of Bun was written by me in 1 year, in a cramped Oakland apartment, pre-LLM, in Zig.”
Jarred Sumner, on Bun’s origins before the rewrite

“Our bugfix list felt bad and I was tired of going to sleep worrying about crashes in Bun.”
Jarred Sumner, on the human cost of memory unsafety at scale

“Until very recently, programming language choice was a one-way decision for a project like Bun.”
Jarred Sumner, on the assumption this project overturned

“In safe Rust, these are compiler errors and RAII-like automatic cleanup with Drop. Compiler errors are a better feedback loop than a style guide.”
Jarred Sumner, on why Rust beat a stricter Zig style guide

“What if, instead, I spend a week testing if Anthropic’s new model can rewrite Bun in Rust?”
Jarred Sumner, on the question that started the 11-day experiment

“The Claude that wrote the code wants the code to get accepted. The Claude that reviews wants to find issues in the code.”
Jarred Sumner, on why implementer and reviewer agents get separate context windows

“This is the bleeding edge of what’s possible today. I used a pre-release version of Claude Fable 5, a Mythos-class model.”
Jarred Sumner, on the model behind the rewrite

“Startup got 10% faster on Linux but otherwise, barely anyone noticed. Boring is good.”
Jarred Sumner, on Claude Code shipping on the Rust port in production

“One engineer can do a lot more today than a year ago.”
Jarred Sumner, closing the post

Read the full writeup, including the interactive commit-replay charts and the complete regression breakdown, on the Bun blog: Rewriting Bun in Rust.

Tag: unsafe Rust

Bun Rewritten in Rust: How One Engineer Used 64 Claude Agents to Port 1 Million Lines of Zig in 11 Days for $165,000