News for hackers. Stuff that matters.
Re:Bun is being ported from Zig to Rust by hsaliak on Monday May 04, 2026 @10:30PM (#48017447)
The problem with vibe coded re-writes is that you basically sign off on understanding the generated codebase at that point. Any historical knowledge of the codebase is gone.
Re:Bun is being ported from Zig to Rust by noveltyaccount on Monday May 04, 2026 @10:46PM (#48017529)
This prompt defines the translation as a file for file, line for line port. Seems like historical knowledge will be fine.
Re:Bun is being ported from Zig to Rust by mr_00ff00 on Monday May 04, 2026 @10:57PM (#48017585)
Having dabbled with both Zig and Rust, they do things so fundamentally differently, it isn’t possible to do exact lines like that.
Re:Bun is being ported from Zig to Rust by mswphd on Tuesday May 05, 2026 @12:07AM (#48017933)
the rust they've written (so far) is highly unidiomatic (and with a ton of unsafe). I can't speak to the zig part, but it seems plausible to me it is line-by-line, horrendous rust.

Whether or not they can clean it up is an interesting question.

Re:Bun is being ported from Zig to Rust by vintermann on Tuesday May 05, 2026 @01:08AM (#48018290)
If anyone can do it, it's Anthropic. The question is more how long it will take and how many tokens it will burn/how much groundwater.
Re:Bun is being ported from Zig to Rust by dathinab on Tuesday May 05, 2026 @02:14AM (#48018716)
zig can do some things wrt. compiler time compute which sits somewhere in between rust const expr and proc macro usage. This isn't something rust (or most languages) have. So even if we are generous and interpret line by line as expression by expression this isn't fully doable

but also telling a LLM to do a line-by-line translation and giving it a file _is guaranteed to never truly be a line-by-line translation_ due to how LLMs work. But thats fine you don't tell it to do line-by-line to actually make it work line by line but to try to "convince" it to not do any of the things which are the opposite (like moving things largely around, completely rewriting components based on it "guessing" what it is supposed to do etc.). Or in other words it makes the result more likely to be behavior (incl. logic bug) compatible even through it doesn't do line-by-line. And that then allow you to fuzz the behavior for discrepancies in the initial step before doing any larger refactoring which may include bug fixes.

Through tbh. I would prefer if any zip -> terrible rust part where done with a deterministic, reproducible, debug-able program instead of a LLM. The LLM then can be used to support incremental refactoring. But the initial "bad" transpilation is so much code that using an LLM there seems like an horror story, wrt. subtle hallucinations and similarr.

Re:Bun is being ported from Zig to Rust by swyx on Tuesday May 05, 2026 @12:44AM (#48018133)
care to attempt a top 3 differences that someone doing this kind of rewrite should know?

(would teach me a little about Zig, about which i know 0)

Re:Bun is being ported from Zig to Rust by sufficientsoup on Tuesday May 05, 2026 @03:44AM (#48019281)
Wouldn’t call myself an expert in either, but I think 2 things stand out far more than anything else: 1. Rust is effectively as strict as can be in terms of ownership. In Zig you can just allocate some memory and then start slinging pointers (or slices) all over. If you’re doing this then you’re presumably doing it for mutability and you don’t strictly know where that pointer ends up once you’ve passed it on. 2. Rust’s metaprogramming is split among a couple different things (e.g. traits, macros), whereas Zig’s is unified (comptime). comptime is (at least advertised as) “just normal Zig code” and Rust macros are a great example of “this doesn’t work at all like the base language”.

#1 boils down to “can the LLM solve the pointer aliasing here?” and #2 is translating between metaprogramming paradigms. Could work but a line-by-line translation is a pipe dream.

Re:Bun is being ported from Zig to Rust by swyx on Tuesday May 05, 2026 @01:11PM (#48025429)
great answers! exp the recap last line
Re:Bun is being ported from Zig to Rust by IshKebab on Tuesday May 05, 2026 @03:44AM (#48019277)
Zig doesn't have a borrow checker. It's basically C, if C had been much better designed.

Line-by-line ports to idiomatic Rust are usually not possible because of the borrow checker and Rust's ownership rules. That's the reason the Typescript compiler was ported to Go instead of Rust.

Re:Bun is being ported from Zig to Rust by selfmodruntime on Tuesday May 05, 2026 @10:44AM (#48023207)
You can do this with a bunch of clones. But this will make your software slower and kind of defeats the entire purpose.
Re:Bun is being ported from Zig to Rust by jjice on Monday May 04, 2026 @10:59PM (#48017593)
It makes the git history a bit more confusing to follow if you want to see old changes, but I'm sure a simple wrapper to check for the zig equivalent files as well wouldn't be very difficult.