go vs zig vs rust reddit

Rust vs Zig vs Go Performance - YouTube

October 11, 2024

01:46

Zig vs Rust Performance Benchmark 2026 - YouTube

January 10, 2026

Intro to Zig | Why not Rust, Go or C++? - YouTube

February 5, 2026

20:29

Rust vs Zig кто реально быстрее? Разбор ...

January 27, 2026

reddit.com

r/programming on Reddit: The worst programming language of all time

November 21, 2025

reddit.com

r/Zig on Reddit: Rust vs. Zig vs. Go

October 11, 2024

View all

reddit.com › r/learnprogramming › why modern programming language (rust, zig & go) looks different and complicated in comparison to c & javascript?

r/learnprogramming on Reddit: Why modern programming language (rust, zig & go) looks different and complicated in comparison to C & javascript?

May 8, 2025 -

Just want to pick a new language for a new project. Specially with good support for Gui toolkit and should be natively compiled

Go is a very simple language. It took most developers I know about a week to pick it up. The language itself is fairly small and not a lot of fluff. I haven't used the others.

1 of 10

147

2 of 10

124

reddit.com › r/zig › zig vs rust vs go vs java vs swift for data processing

r/Zig on Reddit: Zig vs Rust vs Go vs Java vs Swift for data processing

October 4, 2023 -

Last week, I posted this benchmark in the rust and golang subreddit and the community made suggestions that sped up the code...So I thought it'd be fair to post it here to get some feedback as zig isn't doing too well and I'm sure it can be optimized.

Repo: https://github.com/jinyus/related_post_gen

Hey there. I looked into your code, i am fairly new to zig but can easily understand what’s going on in the code you given and I compared it to Rust one as it holds the crown (ik, Go does but idk much Go). And there are various reasons why Rust code outperforms the Zig one. Firstly, the use of mimalloc which provides crazy good performance - I would say use some sort of bump allocation or arena allocator for Zig, it would give significant boost and next is Rust code is utilising parallelism through excellent rayon library which gives it a significant performance boost, idk whether there is similar threadpool library available for zig or not but parallelism can give some boost. And you’re using crazily good implementation for Hashmap in rust which gives it another performance advantage, again as Zig ecosystem is small, I don’t know of any similar library which can make things fair. A little hint: Try Bumpalo in your Rust Code, maybe it would beat Go.

Even without taking a deeper look into the benchmark, it seemes to be biased, looking at the summary table. It is highly unlikely that Zig and Odin would be 5 times slower than Go, and Java even 10 times slower.

Hacker News

news.ycombinator.com › item

Thoughts on Go vs. Rust vs. Zig | Hacker News

December 15, 2025 - Well, no, creating a mutable global variable is trivial in Rust, it just requires either `unsafe` or using a smart pointer that provides synchronization. That's because Rust programs are re-entrant by default, because Rust provides compile-time thread-safety.

Sinclairtarget

sinclairtarget.com › blog › 2025 › 08 › thoughts-on-go-vs.-rust-vs.-zig

Thoughts on Go vs. Rust vs. Zig | Sinclair Target

August 9, 2025 - I realized recently that rather than using “the right tool for the job” I’ve been using the tool at the job and that’s mostly determined the programming languages I know. So over the last couple months I’ve put a lot of time into experimenting with languages I don’t get to use at work.

Better Stack

betterstack.com › community › guides › scaling-go › rust-vs-go-vs-zig

Rust vs Go vs Zig for Systems Programming | Better Stack Community

September 15, 2025 - Zig emerges as a modern C replacement, offering manual memory control with better tooling and safety features. It aims to be simple, fast, and correct without the complexity of Rust's ownership system.

reddit.com › r/zig › why did you pick zig over rust?

r/Zig on Reddit: Why did you pick Zig over Rust?

October 21, 2024 -

Have you tried Rust before picking up Zig? What made you pick up Zig if so?

My choice for bare metal is either Rust or Zig, and I find Rust too complicated, even though I can code in pretty much any language out there.

There’s just too much of “oh, just use…” with Box, Rc, Arc, traits, types, etc. that’s being used to paper over complexity. Only Haskell is more complicated than Rust, IMO, and there I can choose OCaml instead. I’m wondering if OCaml is to Haskell what Zig is to Rust.

We wrote a blockchain in Rust once upon a time. It was rock-solid but I couldn’t fix/improve it later. Also, I’ve been reversing drone firmware C/C++ binaries for close to 3 years now. I also picked up Forth and I’m writing a disassembler CPU module for an obscure arch I never knew existed.

I have an appreciation for how things look at the lowest level and they are very straightforward. Rust, on the other hand, is almost solving a social problem, complexity be damned! Likely because you can’t enforce memory safety in decent-sized teams and someone somewhere is bound to slip up.

I’m looking to write drone firmware.

Thread here as well:

https://x.com/joelreymont/status/1848069555425530361?s=46

I like both Zig and Rust. They're both good languages, with different upsides and downsides. According to this classification , Zig is "worse is better", and Rust is "do the right thing". A very simplified version is this: Rust is a modern language that challenges C++. Zig is a modern language that challenges C. People sometimes use names like C/C++ which conflate the two languages, but I'm absolutely convinced that C and C++ are two very fundamentally different languages. Personally, I love C but I hate C++. Rust fixes many things that are wrong with C++: it gets rid of all the footguns that are required by C++'s ancestry from C, it makes move semantics the default, it adds a lifetime system which makes references safe (C++ references were already an attempt to get safer than pointers, but due to the lack of lifetimes, they don't really make as much of a difference as they should). Instead of C++'s whacky template system, Rust uses traits that are supported by actual type theory. Great. C++ and Rust are both fundamentally built upon RAII, but Rust actually makes it work. The problem that I have with Rust is that it absolutely embraces C++'s love for more and more abstractions (and the hope that it's all "zero cost" after the compiler is done with it). That makes it often really hard to figure out what's going on. This is especially apparent in the way both C++ and Rust love overloading methods. Which is odd, because Rust technically doesn't even have overloading, but they reintroduce it through the back door by adding traits that serve no other purpose than to overload methods to make code harder to understand (but perhaps "prettier"?). Zig on the other hand is just a nicer syntax for C (C type signatures are particularly insane) with the preprocessor, which is another separate language on top of C, replaced by compile time evaluation of Zig itself. And on top of that, a few careful additions to fix certain specific use cases where C falls short: namespacing, including method syntax; a lot more specific pointer types for different use cases of pointers, a sensible error handling system, the defer keyword which is directly copied from Go (another language in the spirit of C, but higher level), etc.

1 of 30

2 of 30

I can read and understand Zig code without knowing the language deeply. I can't read rust at all, the syntax is horrible for me.

Find elsewhere

Google Bing Mojeek

reddit.com › r/rust › zig or rust

Zig or Rust : r/rust

April 29, 2023 - At it's heart it's a procedural language, so it's not like you can't write similar code in other languages, but being forced to think about ownership is paradigm shifting. To my knowledge zig does some cool things but nothing as influential on the way that you think as Rust's borrow checker. ... This is a good description thanks.

reddit.com › r/golang › should one learn zig or go.

r/golang on Reddit: Should one learn Zig or Go.

January 25, 2025 -

Hi Everyone,

I am a self taught fullstack javascript developer. I wanted to deepen my knowledge and was thinking of learning one C level language (C#, Go or Zig). I was thinking of doing my DSA in one of these languages to understand low level programming.

My first preference is not Job (My JS is enough for that) but to build my own Devops/CyberSecurity Products. Which path would you suggest would be better.

I was thinking of Go but the realised that for general purpose apps NodeJS is marginally infirior to Go. I am leaning towards Zig because of no Garbage collection, which i felt provides it an exponential edge over NodeJS as compared to Golang.

I maybe wrong, as am still learning would really appriciate if fellow developers could guide me in right direction.

Thanks

do you think r/golang will be objective, or it's the best subreddit to ask that question?

Generally, my thought is if it's web-based, use go.. if it's hardware-based, use zig

DEV Community

dev.to › gohashira › i-tried-every-hot-programming-language-514f

I Tried Every Hot Programming Language - DEV Community

December 13, 2024 - In this post, I'll make an attempt to compare GoLang, Zig, and Rust. And why Rust wins this... Tagged with discuss, rust, go, learning.

reddit.com › r/rust › a "better c" benchmark (comparing zig, rust, go, c++)

r/rust on Reddit: A "Better C" Benchmark (comparing Zig, Rust, Go, C++)

March 24, 2021 - Good write-up and nice to see the comparison. There is no denying in that Rust “feels” more complex than the other three (well, C++ is questionable). Although I don’t immediately don’t have an example of what could be made more ergonomic. I also think that Rust really shines for larger applications. Zig, C, Go, all feel very productive for these small toy programs since there are few constraints and the compiler happily accepts your code.

reddit.com › r/rust › how i think about zig and rust

r/rust on Reddit: How I think about Zig and Rust

January 23, 2025 -

https://lewiscampbell.tech/blog/250117.html

Having used both in anger. I wouldn't trust Zig for anything. Their simplicity should have allowed them to get to a point where they can get a small stable subset fast, and then grow the language, but they are stuck in an endless rabbit hole of perfectionism, that makes writing production code with Zig an absolute nightmare. I hate Rusts macro system with an absolute passion, and would love for it to embrace compile-time meta-programming a la comptime. But acting as if there was a choice between these two languages is just dishonest.

1 of 6

266

2 of 6

I can not really get the idea behind Zig. Rust is "borrow checker", "explicitly over implicity", "safe and unsafe separation". Go is "as simple as possible", "garbage collection, and AOT at the same time", "goroutine". But what is "Zig", just another syntax for "C"?

reddit.com › r/zig › can someone outline the major differences between go and zig?

r/Zig on Reddit: Can someone outline the major differences between Go and Zig?

September 22, 2019 -

TL;DR is the title.

Hi, I'm a huge Gopher, Go is in my opinion, the best programming language, When I heard of Zig, I instantly got interested, After writing a few trivial programs with it, I decided to port my NES Emulator (That's written in Go) to Zig, now, my question is, What are the major differences between Go and Zig?

Some differences that come to mind: Zig has manual memory management and Go is garbage collected. Zig has compile time execution and Go does not. Go has NULL (I think), Zig has optional types. Zig has a built in build system, via compile time execution. This can also be used to compile C. Go starts with the premise that all code can run concurrently, Zig does not.

1 of 2

2 of 2

Advantages of Zig over Go: Zig's LLVM backend gives performance on par with or better than C . Go's perf is good but it's not as good as C. Zig's async/await makes it more natural to express the inherent parallelism in the logic, as opposed to threads/goroutines where one must explicitly decide where concurrency will occur. I don't have demos of this yet; I just finished a big async/await rewrite and haven't created demos yet. All the tooling that works on native binaries (gdb, MSVC, lldb, valgrind, perf, profilers) works with Zig. Error return traces try Interfacing with C is streamlined. Zig even ships with several libcs and can cross compile C libraries without any system dependencies. Generics No runtime. Zig can be used to create small & fast C libraries. Code written in Zig is extremely reusable. Most Zig functions can be used in desktop applications, games, low latency servers, OS kernels, embedded devices, real-time software, in web browsers (with webassembly), by other languages using the C ABI, at compile-time, at runtime, with async I/O, with blocking I/O, single-threaded, multi-threaded. Libraries written in Zig are extremely versatile. Advantages of Go over Zig: Significantly more mature & stable. You don't have to participate in the development of Go to use it. Better memory safety. Interfaces are easier to use than the pattern we currently use in Zig for this use case.

Medium

medium.com › @premchandak_11 › i-tried-writing-the-same-service-in-rust-go-and-zig-the-easiest-one-made-me-cry-56a86ffef053

I Tried Writing the Same Service in Rust, Go, and Zig — The Easiest One Made Me Cry. | by Prem Chandak | Medium

August 15, 2025 - It started as a harmless “What if?” experiment. I wanted to compare Rust, Go, and Zig — three modern systems languages — by writing the same service in each: a lightweight JSON API for recording transactions and returning aggregated stats.

reddit.com › r/zig › rust or zig?

r/Zig on Reddit: Rust or Zig?

March 3, 2026 -

I've been deep in Zig for the last 3 years and have loved every step. Yet, from around the corner, Rust always seems to poke its head out; and several times I have built tools and projects in Rust to try to get 'into it', yet it has never really clicked like Zig.

Rust is getting more-and-more popular. Is it worth going ten toes deep? Or should I ride the storm with Zig?

Personally I'm putting off Zig until its a bit more stable. It's perfect for a lot of my use case (direct hardware access that is unsafe Rust already), but Rust is a stable project where I don't have to worry about some breaking standard library change with more use cases even if Zig is cooler and very good at what it's for (lower level systems with fine-grained control over program resources) Although who said you have to choose? Edit: I have language design qualms with both Rust and Zig tbh. I prefer Zig's level of abstraction, but would love if they had sane defaults that didn't require manual configuration. Like "as much control as you want to have"

1 of 33

2 of 33

Just try to give Rust a real chance in a toy project. There's no point in asking strangers for permission and even if you don't end up switching, you'll have learned a few things.

reddit.com › r/zig › i'm still confused on the why's of zig

r/Zig on Reddit: I'm still confused on the why's of Zig

February 13, 2022 -

I'm a Go developer and I do like a lot the simplicity of Zig because it looks like Go. At the same time Rust has some really nice reasons to be used given it's safety. So if I'm looking for a low level language why should I use Zig and not Rust? They're equally fast, use the same backend LLVM, equally low level Rust is safer, etc...

Go is simplicity on the surface with gobs and gobs of complexity hiding under the internals, that hopefully you never, ever have to touch. If you haven't yet gotten upset @ Go for the the evil details it tries to hide, keep using Go. Rust is "saner c++" i.e. it's complicated and spews it's complications everywhere, but hopefully in a more modern, easier to understand and safer way. If you don't need the complications, I'd recommend staying away. Zig is "saner C", i.e. it's trying to get rid of the wacky complications of C that now make little to no sense anymore, but stick around because changing C is hard, complicated and miserable. If you find yourself using the C interop stuff from Go all the time and you find it frustrating, it might be time to switch to something like Zig. Zig would be a fine language to wander into from Go, if you need the complications that it brings, but if you don't, I'd recommend just staying in Go land. See the first paragraph ;)

I'm a Go developer and I do like a lot the simplicity of Zig because it looks like Go. This is probably the best argument for Zig in your case. I found Rust incredibly difficult to tame without wrapping everything in reference counters. Zig feels much more liberal, although you still have to remember to defer all your destructors. Other reasons I personally enjoy Zig: versatile compile time support, clean syntax with no hidden flows, simple error handling, small binaries, native C interop. Zig is simple and clean, like a safer, modern C, as opposed to how rust is a safer C++.

reddit.com › r/rust › rust vs zig

r/rust on Reddit: Rust vs Zig

November 14, 2024 -

I am planning on becoming fluent in a low level language, already have 5+ year programming experience.

I’ve been seeing online discussion regarding both lately, so I wanted to ask your opinions in the pros and cons of both. What do you think?

Zig is not yet a stable language. As such, it is much more of a moving target than Rust is. As such, it's sort of silly to compare Zig with Rust, as the basic facts about Zig are subject to quickly change, rendering any comparisons invalid in a short amount of time. EG In 6 months, Zig might implement a borrow checker, add functional programming concepts, and completely redo the allocator things. However, since you're asking Zig has some nifty allocator things that Rust has stalled on (allocator_api seems dead in the water) Rust has a borrow checker - new users find it annoying, experienced programmers think it's the best thing since sliced bread (which it is) Rust has some useful functional programming concepts like iterators that are implemented for all the STD collections. You have to write your own iterators in Zig (at least thats what Perplexity is telling me) Zig's comptime is much more readable than Rust macros Code which compiles on the current version of Rust will compile on future versions of Rust. Zig makes no such guarantee (because it's not yet stable)

Zig is interesting as a novelty, mostly with its comptime idea, but it has several severe drawbacks and IMO will never be mainstream. It's nowhere near stable (expect serious breaking changes every release), it lacks tooling (partly due to the way comptime works, but also other factors), massively lacks documentation and general learning aids, is mired in "great ideas" like ditching LLVM and making their own compiler backend. I'm also off-put but their community and dislike the BDFL form of governance (Andrew Kelly is notoriously trashy). It has some neat ideas, but I doubt it will ever take off, especially compared to the other C alternatives out there. For my part, I'd rather write Rust and C than Zig.

reddit.com › r/csharp › c# vs rust vs zig vs go vs java for data processing

r/csharp on Reddit: C# vs Rust vs Zig vs Go vs Java for data processing

October 5, 2023 -

Last week, I posted this benchmark in the rust and golang subreddit and the community made suggestions that sped up the code...So I thought it'd be fair to post it here to get some feedback.

I made a direct port of the go version for c# and it's not performing as expected. It's getting beat by dart, swift, f# etc. so there's obviously something wrong. Nothing sticks out to me though so I hope someone here can optimize it.

nb: This is my first time writing c#.

Repo: https://github.com/jinyus/related_post_gen

I created a PR to make the CSharp implementation use AOT (ahead of time) compilation on .NET 8. This made it significantly faster on my machine. I didn't investigate your benchmarking harness, so I don't know how to wire it into your benchmarks. You might need to modify the RuntimeIdentifier in the related.csproj to target your local platform, if you aren't on win-x64. I didn't modify the logic of your implementation at all, just converted it to use AOT. This avoids the overhead of the JIT compilation that happens on first run. This was a good excuse to figure out the System.Text.Json source generator stuff, which I'd never used before. Edit: for some shameless self-promotion I did a similar comparison of AOT recently: https://github.com/markpflug/data-convert