Why Bun’s Founder Is Abandoning Zig for Rust—and Letting an AI Do the Rewrite

In the past two years Bun has challenged Node.js with lightning‑fast performance, largely thanks to its founder Jarred Sumner’s aggressive bet on the Zig language. Recently, a new GitHub branch named claude/phase-a-port revealed that Sumner is migrating Bun’s core from Zig to Rust, and the migration is being orchestrated by an AI Agent.

Hard Evidence: From CLAUDE.md to 28,000 Lines of Code Changes

Initial skepticism that the move was an April‑fool’s joke faded as community members like Simon Willison dug deeper. The experimental branch shows:

Massive code change: 12 files were altered, adding 28 000 lines of code in a single commit.

AI "specification": The 622‑line PORTING.md maps Zig pointers, allocators, error handling, and other core concepts to their Rust equivalents, clearly intended for an AI Agent (likely Anthropic’s Claude Code).

Founder’s direct involvement: All commits are authored by Jarred Sumner himself.

These signs indicate that Bun is seriously exploring, if not already executing, a rewrite of its Zig kernel in Rust.

Motivation Breakdown: Why Abandon “World’s Best Language”?

The community has offered several hypotheses:

Ecosystem richness vs. scarcity: Zig’s ecosystem is sparse compared to Rust’s mature crates.io repository, which offers production‑tested async runtimes, HTTP clients, and high‑performance serialization libraries.

Talent availability vs. community size: Skilled Zig developers are rare, whereas Rust enjoys a much larger pool of contributors, making hiring easier for a commercial project like Bun.

Toolchain maturity: Rust’s ecosystem provides powerful tools such as rust-analyzer, cargo, static analysis, and fuzz testing, all of which have reached a high level of stability, unlike Zig’s still‑developing tooling.

AI friendliness: Rust’s strong type system, detailed error messages, and abundant open‑source code make it highly amenable to AI‑driven code generation and repair. An AI Agent can act as an tireless intern, while Rust’s strict compiler serves as a 24‑hour code‑review mentor.

AI at the Helm: When "Code Refactoring" Becomes an Instruction Set

Sumner’s approach does not involve assembling a large rewrite team. Instead, he distilled his architectural intent into a technical specification for the AI.

A Phase: The AI translates Zig logic to Rust on a pixel‑by‑pixel basis. The generated .rs drafts need not compile. B Phase: The AI iteratively fixes compilation errors—ownership, lifetimes, and other Rust‑specific issues—until the code compiles.

This creates a pipeline where human architects define the "what" and "how," while the AI Agent handles the concrete "execution."

Reflection: Choosing a Tech Stack in the Age of AI

The Bun‑to‑Rust transition serves as a mirror for new stack‑selection rules:

Rule 1: Ecosystem pull outweighs language syntax elegance; AI accelerates reliance on mature ecosystems.

Rule 2: "AI friendliness"—clear documentation, helpful error messages, and consistent code style—has become a core competitive factor for languages.

Rule 3: No language enjoys eternal "faith"; trade‑offs dominate long‑term decisions.

In an AI‑driven world, the optimal language is the one that lets the AI Agent perform best, not necessarily the one the founder personally prefers.

Conclusion: A Silent "Core Swap" War

Whether the experimental port merges into Bun’s mainline remains uncertain, but the episode reveals how AI can reshape technology choices, erode community loyalties, and force projects to prioritize ecosystem and AI compatibility over personal preference.

When your third employee is an AI named Claude Code, picking the language it excels at may become the only rational solution.