The Bun Rust rewrite is an impressive feat

Highlights

• Bun migrated its entire 535,000-line codebase from Zig to Rust over an 11-day period in May 2026.

• The porting project utilized 50 dynamic Claude Code workflows, deploying a system of adversarial review and fixer agents to automate the conversion.

• Replacing the legacy codebase required an estimated $160,000 in API tokens at current market prices.

• The resulting Rust code initially contained a high volume of unsafe blocks, partially due to necessary interoperability with existing C libraries.

• The migration was managed using a custom markdown-based instruction set developed through three hours of iterative prompting with Anthropic's models.

Timeline

1. 00:58 - 03:06

   Project Timeline and Initial Reception

   Development started after the discovery of a 'CloudFaserPort' branch on GitHub containing markdown instructions for translating Zig to Rust. The transition was not a direct file swap but a large-scale migration involving the addition of Rust code before the eventual removal of Zig components. The speed of the pull request meant the changes were reviewed primarily by AI and test suites rather than human engineers.

   • The migration project began in early May 2026 and concluded on May 14th with an official pull request.
   • The pull request involved adding over 1 million lines of code and required nearly 7,000 commits to transition the project structure.
   • Public discourse surrounding the move was highly polarized, reflecting broader industry debates over the merits of rewriting existing software in Rust.
2. 03:19 - 07:44

   Technical Challenges and Unsafe Code Usage

   The community identified that the ported code did not follow standard Rust best practices, functioning more like a direct translation. While Rust typically guarantees memory safety through ownership, interacting with C libraries requires the 'unsafe' keyword. The development team has committed to subsequent refactoring to minimize these safety-bypass areas over time.

   • Critics noted the initial Rust implementation was not idiomatic and contained excessive 'unsafe' blocks.
   • Rust's ownership model requires strict memory management, which can be bypassed using the 'unsafe' keyword.
   • Many instances of 'unsafe' were necessary to maintain compatibility with existing C libraries, though plans exist to refactor these in future updates.
3. 07:58 - 13:03

   Agentic Architecture and Economic Scope

   The developer avoided simple prompting by creating a structured agentic loop. A main agent performed the translation, while two adversarial agents reviewed the work, and a fixer agent applied corrections based on feedback. This highly automated approach enabled the migration of over 500,000 lines of code in just 11 days.

   • The port was executed using 50 dynamic workflows, leveraging a main agent supported by adversarial review agents and a dedicated fixer agent.
   • The project consumed approximately $160,000 in compute tokens at commercial API prices.
   • The process was built on an iterative foundation, where initial instructions were tested on small samples before being applied to the full codebase.
4. 13:24 - 19:03

   Industry Implications and Future Outlook

   The move to Rust has sparked friction between project leads, but the technical result appears stable, with early adopters already running the code via CLI tools. The most significant takeaway for the software industry is the viability of using agentic loops for large-scale language migrations, provided the project is supported by a comprehensive existing test suite.

   • The Bun 1.4 update promises improved memory efficiency and smaller binary sizes compared to the Zig version.
   • The migration highlights AI's capability to modernize legacy software, provided there is an existing test suite for validation.
   • The project serves as a practical proof of concept for using multi-agent systems to tackle engineering tasks previously considered cost-prohibitive.