The real lessons behind the Bun rewrite

Technology-focused summary (Bun rewrite lessons)

1) What Bun is and why the rewrite happened

• Bun is a JavaScript runtime alternative to Node, originally built using Zig.
• Zig was selected for:
  • low-level control
  • C interoperability
  • producing fast standalone executables
• Over time, Bun developed a recurring class of memory safety bugs, including:
  • use-after-free
  • double frees
  • memory leaks
• The core issue described is that Bun sits between two different memory models:
  • JavaScriptCore (used by Bun) relies on garbage collection
  • Zig uses manual/native memory management
• The team reportedly used multiple safety approaches (e.g., AddressSanitizer, safety-checked builds, leak tests, continuous fuzzing), but memory issues persisted.

2) Bun’s technical argument for Rust

Bun’s official explanation argues that Rust’s ownership model prevents many memory errors at compile time.

A comparison presented in the rewrite narrative:

• Zig: explicit allocation + defer cleanup; developers must correctly manage ownership/cleanup at every call site.
• Rust: ownership + the borrow checker move cleanup and valid-reference handling into the language, often turning runtime memory issues into compiler errors.

3) AI-assisted porting workflow (how the rewrite was executed)

The video describes Bun’s migration process as an engineered “LLM factory” rather than a simple code dump:

• First, the team ran a fast experiment: ask Claude to rewrite about 535,000 lines of Zig into Rust.

Steps in the described process

1. LLM guide creation
   • An LLM produced a detailed guide mapping common Zig types/patterns into Rust equivalents.
2. Static analysis outputs
   • Agents analyzed lifetime requirements of Bun’s data structures and stored results in a large table.
3. ~50 continuous automated workflows
   • translate Zig → Rust
   • fix compiler errors
   • run tests
   • review/refactor the output

Scale at peak

• 64 Claude instances, across 4 Git work trees
• Initially generating roughly 1,300 lines/minute

Review mechanism

• Each generated batch was produced by one agent and reviewed by at least two agents.
• Reviewers were instructed to assume the implementation was wrong and attempt to find failure reasons.

Compiler-error-driven iteration

• The initial port produced approximately 16,000 compiler errors.
• Errors were used as a work queue, grouped by crate, with more agents fixing issues.
• Agents sometimes tried to “cheat” by inserting stubs, so workflows were updated to reject that.

Test pipeline and rollout

• compiler errors → smoke tests → local tests → full test suite
• tested across Linux, macOS, and Windows

Rewrite outcome (as claimed)

• took 11 days
• produced 6,778 commits
• landed >1 million added lines
• estimated $165k for API usage

Reported defect/performance/memory results

• Bun v1.4 “fixes 128 bugs” reproducible from the prior Zig release
• Memory
  • Zig version: ~6.7 GB (example symptom: ~3 MB leak per build)
  • Rust version: ~600 MB
• Binary size
  • roughly 20% smaller on Linux and Windows
• Performance
  • claimed 2–5% improvements in benchmarks
• Unsafe usage
  • about ~4% of Rust code remained in unsafe blocks,
  • mostly around JSCore and C/C++ dependencies

4) Major dispute/critique from Zig’s creator (Andrew Kelly)

The video highlights a rebuttal that argues the Bun/Rust narrative may be overstated or missing context.

Andrew Kelly (Zig’s creator) claims:

• Bun’s relationship with the Zig community deteriorated
• Bun moved quickly, accumulating technical debt, and ignored Zig Software Foundation advice
• Bun’s codebase is characterized as “hacks on hacks”

He disputes the “false choice” framing:

• Bun implies only two options:
  1. rely on guidelines + discipline, or
  2. switch to Rust and let the compiler enforce safety
• Andrew proposes a third option:
  • invest engineering time in clear memory rules,
  • code review,
  • systematic bug elimination

Example: TigerBeetle

• TigerBeetle, a Zig project using “Tiger Style”
  • strict architectural approach
  • avoids dynamic allocation at runtime by allocating at startup
  • reduces memory-bug categories through design, not only language features

Test-suite criticism

• The video notes a contradiction:
  • if tests were strong enough to validate 1M+ lines of AI-generated Rust,
  • why did they fail to prevent all bugs in the original Zig?

Performance/size claim context

Some improvements may not be solely attributable to Rust:

• LTO/link-time optimization already existed historically in Zig
• binary-size reductions likely involve multiple engineering changes, such as:
  • ICU data stripping/compression
  • linker-level optimizations
  • removal of Zig-related usage

Compile-time cost omitted

• Rust often has slower compile times.
• The critique is that the Bun article didn’t discuss compile-speed tradeoffs.

Messaging/marketing angle

• The video suggests the rewrite also acts as a strong AI marketing/demo for Anthropic (Claude), implying potentially non-neutral narration.

5) “Lessons” drawn by the video

1. Match the language to the team and capabilities
   • A disciplined team can build reliable software in Zig with strong architectural rules.
   • If a team is crossing garbage-collected and manually-managed memory, Rust’s compiler-enforced ownership checks may help.
2. AI changes rewrite economics
   • Mechanical translation by agents can make migrations previously too expensive.
   • But success still depended on surrounding engineering: architecture, porting guides, compiler feedback loops, tests/sanitizers/fuzzers, and continuous supervision.
3. Attribution is hard when many variables change at once
   • The migration changed language, memory model, compiler/linker/test strategy, and workflow process simultaneously.
   • Improvements can’t be honestly credited to one variable alone; the write-up may underrepresent overall compute/tooling/engineering effort and technical-debt cleanup.

Main speakers / sources

• Jarred (referenced as supervising the Claude rewrite experiment; “According to Jarred…”)
• Andrew Kelly (creator of Zig, source of the public rebuttal)
• Bun team / Bun blog post (the primary narrative being critiqued)
• Claude / Anthropic (LLM-based agent system used for the port)