Go vs Rust vs Zig: Three Value Systems Behind the Language Wars

The author spent months experimenting with Go, Rust, and Zig — languages not used in daily work — to understand what each language is truly optimized for, rather than comparing feature checklists. The core insight: language comparisons often reduce to "everything has trade-offs," but the useful question is why a language chooses its specific trade-offs. Each language expresses a value system that determines what it optimizes for.

Go: Minimalism

Go's trade-off: few features, slow iteration, in exchange for a language that fits entirely in your head.

Go's hallmark is minimalism. Described as a "modern C," it adds garbage collection and a real runtime but retains C's property that the entire language fits in your brain. This is possible because Go has remarkably few features. Generics were absent for 12 years until Go 1.18; tagged unions and syntactic sugar for error handling are still missing. The Go team sets a high bar for new features, resulting in boilerplate code for tasks that are concise in other languages, but also a language that stays stable and readable for years — especially for concurrent code.

Go's slice exemplifies minimalism. Rust and Zig have slice types that are merely fat pointers to contiguous memory. Go's slice is also a fat pointer but can grow, effectively combining Rust's Vec<T> and Zig's ArrayList into one type. Because memory is managed by Go, the runtime decides whether the backing array lives on the stack or heap; in Rust or Zig you must decide manually.

Go's origin: Rob Pike tired of slow C++ compiles and errors from other Google engineers writing C++. Go chooses simplicity where C++ became complex. It targets "average programmers" to cover 90% of use cases while remaining easy to understand, particularly for concurrency. The author notes Go's minimalism serves enterprise collaboration — not a criticism, but a recognition that enterprise software has its own challenges and Go addresses them directly.

Rust: Maximalism

Safety and performance are two ropes; Rust ties them together and holds both.

If Go is minimalism, Rust is maximalism. Known for "zero-cost abstractions," the author amends this to "zero-cost abstractions, and a lot of them." Rust's difficulty stems not from lifetimes alone but from the sheer number of concepts packed into the language. A GitHub comment illustrates the concept density: Pin<&LocalType> implements Deref<Target = LocalType> but not DerefMut; Pin and & are #[fundamental], enabling an impl DerefMut for Pin<&LocalType>; with LocalType == SomeLocalStruct or LocalType == dyn LocalTrait, you can coerce Pin<Pin<&SomeLocalStruct>> into Pin<Pin<&dyn LocalTrait>> — two layers of Pin — creating smart pointers that implement CoerceUnsized with strange behavior on stable Rust. Even after translation, the complexity remains opaque; each term is familiar but the combination requires running the type system in your head to verify correctness.

Rust's complexity serves a purpose: simultaneously delivering safety and performance. Safety means memory safety (no invalid dereferences, no double-free) and avoiding all undefined behavior (UB). UB is worse than a crash: a program that continues unpredictably — depending on thread scheduling or leftover memory contents — produces Heisenbugs and security vulnerabilities. Rust prevents UB by moving checks to compile time. The compiler must understand runtime behavior, so Rust provides an expressive type system and traits to make runtime behavior explicit at compile time. You cannot "just do the thing"; you must find the trait Rust named for it and implement it per Rust's rules. In return, Rust guarantees behavior that other languages cannot, making third-party libraries trustworthy and explaining why Rust dependency counts rival JavaScript's.

Zig: A Reaction

Every byte allocated by you, every class hierarchy rejected — Zig gives control back to the programmer.

Zig is the youngest and least mature (version 0.14 at writing). Its standard library lacks documentation; reading source code is the best way to learn. The author views Zig as a double reaction against Go and Rust. Go hides low-level details for simplicity; Rust makes you jump through hoops for safety. Zig wants to set you free — in Zig, you decide, no one decides for you.

In Go and Rust, heap allocation is implicit. In Zig, every byte is explicitly allocated via a specific allocator's alloc(), forcing you to choose the allocator implementation suited to the scenario — more control than C. In Rust, creating a mutable global variable is notoriously difficult; in Zig, you just create one, nothing stops you.

Undefined behavior in Zig is called "illegal behavior." Zig attempts runtime detection, crashing on occurrence. Four release modes let you trade checks for performance; the pragmatic idea: run with checks during development to build confidence, then disable checks for production.

Zig also rejects OOP. Go and Rust dropped class inheritance but still support object graphs. Zig has methods but no private struct fields and no language feature for runtime polymorphism (dynamic dispatch) — even std.mem.Allocator looks like an interface but isn't one. This is deliberate: Zig is designed for data-oriented design. Manual memory management seems tedious only if you insist on per-object allocations (RAII). Zig encourages allocating a large block at key points (e.g., each event loop iteration) and using that arena for all data, eliminating thousands of hidden malloc() / free() calls.

Why does Zig exist when Rust already proves compiler-managed memory without GC? The real difference: Zig wants you to strip away another layer of object-oriented thinking. Zig has a subversive, almost anarchic quality — a language for "paranoids" and "anarchists" that smashes enterprise class hierarchies. The author hopes it reaches 1.0, though the team's current priority appears to be rewriting all their dependencies, possibly even the Linux kernel.

Three Languages, Three Value Systems

Together, the three languages address the same questions — memory management, safety guarantees, where complexity lives — but answer with three distinct stances. Go believes most team scenarios don't need many features; less is stable. Rust believes safety and performance can coexist if you pay the cost of learning a full type system. Zig believes giving programmers total control is more honest than deciding for them.

When torn between Go, Rust, or Zig, ask which stance aligns with what you believe while coding. The answer often appears faster than any feature comparison table.

References

[1] GitHub comment: https://github.com/rust-lang/rust/issues/68015#issuecomment-835786438