Why zig

[diceptia]

Hey I'm a beginner here The website states that zig is low-level and no hidden control flow but why not use rust. Is bun fast because it written in zig??

[Bellisario]

Yes, Zig makes Bun faster because it has manual memory management and fantastic performance. In fact, Zig it's a modern alternative to C, so, it's very very fast.
There is also JavascriptCore that helps a little bit, but most the performance it's because of Zig.

An example of JavaScript runtime written in Rust is Deno, but seems to be less performant than Bun (I'm not saying Rust it's slower, but just exposing and comparing the technologies used there).

[turboMaCk]

lol... Zig is not making bun faster. it uses same compiler backend as the clang does. What makes programs fast is the way they are programmed not some magic language spells.

[Bellisario]

You're right on the fact that Zig alone is not making bun faster (anyway Zig is starting to ditch LLVM, see 0.16.0 release notes, section Target Support) but the manual memory management helps and the language overhead/readability ratio is good (kinda high-level syntax with low-level performance) so the language doesn't get too much on your way while doing optimizations.

Anyway it seems they are rewriting the whole runtime in Rust (see #30412) because of memory leaks (caused by the same manual memory management of Zig)... but that was only possible after all the optimizations studied and applied on Zig over 214 releases and thanks to LLMs translating and fighting (for a beneficial result of course) with the Rust compiler.

[turboMaCk]

well what matters is what language gives to users, how it's translated to machine code and how users use it. Node.js is written in C++ and even that language has manual memory management.

Many languages choose to implement their own simple x86 backend because LLVM is slow. But then if we talk about runtime performance of compiled Zig executable what makes these executable fast is the optimizations done by the LLVM, not the Zig's specific front-end implementation for the LLVM IR. And when you opt out from LLVM backend you loose these and your executable will no longer be that performant.

So no, it is not Zig what makes anything fast or slow. What makes machine code produced by zig compiler state of the art in terms of optimizations is LLVM. And the only design thing zig does is that it chooses to be low level enough so that doesn't introduce too many things that would require additional runtime overhead on top of that.

But most importantly "fastness" is not a property of language. It's property of executable. Compiler can be fast, program can be fast. Language can't be fast the same way it can't be sad.

[Bellisario]

I think this post by Mitchell Hashimoto (+ Jarred's response) could be an interesting addition for everyone interested in this thread and the Rust rewrite:

---

@turboMaCk yes I was focusing more about the "ergonomics" and developer experience (let's say "pleasure and simplicity of getting things done still having an optimized implementation") of the language, but you're right that everything that matters at the end is the final machine code and how well it's optimized.

[bsljth]

I am wondering why this hasn't caused a controversy.

[Bellisario]

I'm sorry if what I said could have caused controversy. All what I said can be found on Bun website (bun.sh):

Zig makes Bun faster because it has manual memory management and fantastic performance

On website: Zig's low-level control over memory and lack of hidden control flow makes it much simpler to write fast software.

There is also JavascriptCore that helps a little bit [...]

On website: Bun uses the JavaScriptCore engine, which tends to start and perform a little faster than more traditional choices like V8.

---

Probably this part maybe controversial for someone:

An example of JavaScript runtime written in Rust is Deno, but it's slower, and we can say because exactly of Rust, which is not so good as Zig on performance and memory management.

Here I'm just explaining Zig performance and manual memory management seems to be more effective than Rust (in this PRECISE case) taking the example of Deno, which seems to be slower (from the benchmark available on Bun website).

If you're feeling I was criticizing Rust, this is not wanted. I'm not in the Zig or Rust front, they're both awesome languages and you should be using the one you feel.

---

Anyway, to prevent any controversy on my answer, I'll change the last line from:

An example of JavaScript runtime written in Rust is Deno, but it's slower, and we can say because exactly of Rust, which is not so good as Zig on performance and memory management.

to:

An example of JavaScript runtime written in Rust is Deno, but seems to be less performant than Bun (I'm not saying Rust it's slower, but just exposing and comparing the technologies used there).

[bsljth]

Oh... I apologise @Bellisario... I was just comically wondering out loud why Rustaceans haven't attacked what you have said. It came out wrongly from my comment that you made a controversial critique of Rust. 🙂

[ghiscoding]

I think he saw it as a critique because of the number of thumbs down on his first reply 😄

[paulocoghi]

tl;dr
Because Zig can be as fast as Rust and Bun creators prefer the Zig developer experience.

Long answer:
In my humble research, Zig and Rust provide so identical performance (incredibly near) that, in the end, it depends a lot more on the developer strategy than the languages themselves.

For this reason, IMHO, the fact that Bun (made on Zig+JSC) is currently faster than Deno (Rust+V8) is much more related to the choices made from their respective creators (kudos to Jarred) and Bun's performance speaks for itself.

[NoelJacob]

Please read this developer blog post - When Zig is safer and faster than Rust https://zackoverflow.dev/writing/unsafe-rust-vs-zig/

[TeaDrinkingProgrammer]

TLDR: Rust is made to guarantee safety. One trade-off is that it is harder to write code that might be unsafe or digs into areas like manual memory management (unsafe-rust). Zig is made with manual management in mind.

In the case of Bun, pretty much the whole codebase is about making it as fast as possible and this includes a lot of manual memory management and other low level tuning. Zig is geared towards this exact use-case which means they have a better DX.

I think if you pit safe Rust against Zig that is written similarly, they should be about as fast. Manually tuned Zig would be as fast as manually tuned Rust, but the latter is harder to make if not practically impossible (from what I've read).

[Morglod]

bun is fast because:
1 its written on native language (C / C++ / Rust / Zig, all the same)
2 it uses JavascriptCore

Safe version of Rust will alway be slower that C / C++ / Zig, because of manual exception handling (unwrap) every line

There are no other technical points on this; Only algorithms and tool-knowledge

[typed-sigterm]

Rust now. Should be closed via #30412

[NullpointerW]

Why rust