Bun's experimental Rust rewrite hits 99.8% test compatibility on Linux x64 glibc

Original Article ↗ Hacker News Discussion ↗

Bun, a JavaScript/TypeScript runtime originally written in Zig, has been experimentally ported to Rust in just six days using Anthropic’s LLM tooling, reaching 99.8% compatibility with its existing Linux test suite. Commenters see this as a striking example of how AI plus strong tests can accelerate large-scale rewrites, while raising concerns about maintainability, true correctness beyond tests, and the risk of codebases that no human fully understands. The move also fuels debate over Zig’s suitability for large projects, the economic impact of AI-driven productivity on software jobs, and whether such highly marketed rewrites are primarily technical progress or hype.

Overview of the Bun Rust Rewrite

  • Bun’s Zig codebase (~950k–1M LOC) has been largely ported to Rust in ~6 days using LLM-based agents.
  • New Rust version reportedly passes ~99.8% of Bun’s existing Linux x64 glibc test suite.
  • The work is framed as both an experiment and potentially a real migration; earlier comments called it “just an experiment,” later ones sound more committed.

Role of LLMs, Tests, and Engineering Effort

  • Many note this is a “sweet spot” for LLMs: mechanical translation plus a strong, comprehensive test suite as an oracle.
  • Several commenters stress that the impressive 6‑day port rests on “hundreds of thousands of hours” that went into the original design and tests.
  • Others argue this still represents a massive speedup over a human-only rewrite and showcases where agents shine.

Cost, Tokens, and Economics

  • Rough back-of-envelope estimates for compute range widely: from ~$10–20k up to ~$0.5M, with debate over reasonable assumptions.
  • Some emphasize that even a six-figure API bill can be cheaper and vastly faster than a large team of engineers; others point out most companies would not casually burn that money without strong justification.
  • There’s concern about a “token-rich class” with access to many parallel agents and better models versus ordinary developers.

Reliability, Safety, and Code Quality

  • Bun has historically had many segfault/memory issues; Rust’s safety model is seen as a key motivation to reduce undefined behavior.
  • Skeptics highlight:
    • Passing tests ≠ real-world correctness or performance parity.
    • Prior examples (e.g., the LLM C compiler, Rust coreutils) where 100% test pass still hid serious issues.
    • Risk that huge, rapidly generated codebases are poorly understood and hard to maintain.

Impact on Zig and Language Ecosystem

  • Some see this as a blow to Zig’s reputation, since Bun was a flagship Zig project; others argue Zig remains strong in its niche (low‑level, embedded, “better C”) with other showcase projects.
  • Debate over whether Zig’s lack of borrow-checker-like guarantees makes high-reliability at Bun’s scale harder, versus claims that disciplined Zig/C++ can still produce robust systems.

Broader Implications for Software & Jobs

  • Excitement: LLMs make large rewrites and legacy ports (COBOL, ngspice, Postgres, TypeScript compilers) feasible.
  • Anxiety: job displacement, concentration of power in a few AI vendors, and the prospect of codebases largely generated and modified by machines with fewer humans understanding them.