๐๐๐ป ๐ฅ๐ฒ๐๐ฟ๐ผ๐๐ฒ ๐๐๐๐ฒ๐น๐ณ ๐ช๐ถ๐๐ต ๐๐ ๐๐ป ๐ต ๐๐ฎ๐๐
Bun just translated its entire codebase from Zig to Rust.
An LLM wrote most of it. The process took nine days. The resulting pull request has over one million lines of Rust code.
This is not a normal rewrite. Rewriting software requires humans to rethink architecture and fix old mistakes. Translation is different. You push code through a machine and hope the output works.
This creates several massive risks for you and your business:
- LLMs match patterns instead of reasoning. They might translate Zig idioms into Rust that compile but break Rust's ownership rules.
- Edge cases disappear in translation. An LLM does not know about the subtle concurrency bugs that took months to find in the original code.
- Speed kills quality. Nine days of work means nine days of testing. A runtime needs years of testing to be safe for production.
I call this tech debt laundering.
You start with a Zig codebase with known debt and known contributors. You end with a Rust codebase with unknown debt and zero institutional knowledge. The debt did not go away. It just moved to a new language.
The old code was battle-tested. The new code is battle-translated.
Many companies depend on Bun for their infrastructure. They are now running code that is almost generated rather than engineered.
I use LLMs every day. I use them to write small utility functions. I do not use them to translate entire runtimes that thousands of developers rely on.
Nine days is enough time to see if code compiles. It is not enough time to see if we understand what we ship.
Would you run LLM-translated code in your production environment? What would it take for you to trust it?