Hello, I'm Shrijith Venkatramana. I'm building git-lrc, an AI code reviewer that runs on every commit. Star Us to help devs discover the project. Do give it a try and share your feedback for improving the product.
Here are six small examples that reveal two completely different language philosophies.
With the recent Bun port to Rust (from Zig) with LLM assistance is setting the interwebs ablaze, I felt going a bit deeper into how Rust and Zig differ in their approaches to solving concrete problems.
Most discussions about Rust and Zig become philosophical quickly.
But the philosophy itself is just the starting point.
A deeper understanding can come from how each philosophy shapes day to day engineering tasks such as:
- allocating memory
- handling errors
- sharing state
- building binaries
- interfacing with C
- structuring dependencies
I'll walk you through a a few examples, after which, the two languages may start feeling fundamentally different.
If one were to summarize, Rust keeps asking:
“How can the compiler make this difficult to misuse?”
Zig keeps asking:
“How can the programmer see exactly what is happening?”
Let's go through a few examples.
Example 1: Creating a Dynamic Array
Let’s start with something boring.
A growable list of integers.
Rust
fn main() {
let mut numbers = Vec::new();
numbers.push(1);
numbers.push(2);
numbers.push(3);
}
Very little ceremony.
You do not think about allocation yet.
You do not think about cleanup.
You do not think about allocator strategy.
Rust intentionally compresses those concerns away unless you need them.
Zig
const std = @import("std");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
var numbers = std.ArrayList(i32).init(allocator);
defer numbers.deinit();
try numbers.append(1);
try numbers.append(2);
try numbers.append(3);
}
The first reaction many engineers have:
“Why so explicit?”
But after a while, the important thing becomes obvious:
- allocator choice is visible
- allocation lifetime is visible
- cleanup is visible
- failure is visible
The language forces resource awareness into the code itself.
That changes how systems evolve.
In Rust, memory management becomes something the compiler heavily assists with.
In Zig, memory management remains part of the engineering model.
That difference shows up everywhere later.
Example 2: Invalid References
This example makes Rust’s philosophy impossible to miss.
Rust
fn main() {
let mut values = vec![1, 2, 3];
let first = &values[0];
values.push(4);
println!("{}", first);
}
Rust rejects this.
Because push() may reallocate the vector internally, invalidating the reference.
The interesting part is not the compiler error.
The interesting part is what Rust optimizes for.
This category of bug is historically painful:
- crashes under load
- intermittent corruption
- impossible‑to‑reproduce failures
- security vulnerabilities
Rust treats these as unacceptable failure classes.
So the compiler intervenes aggressively.
Zig
Zig allows the same pattern.
const std = @import("std");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
var values = std.ArrayList(i32).init(allocator);
defer values.deinit();
try values.append(1);
try values.append(2);
try values.append(3);
const first = &values.items[0]; // reference to first element
try values.append(4); // may reallocate, invalidating 'first'
std.debug.print("{}\n", .{first.*});
}
This code compiles and runs – but the reference first may become dangling after the second append. The program can crash or read garbage.
Zig’s philosophy differs.
Zig assumes:
The programmer should understand when memory relocation is possible.
That sounds dangerous.
And sometimes it is.
But there is another side.
Rust scales correctness mechanically.
Zig scales understanding culturally.
That is a very different engineering assumption.
Example 3: Error Handling
The two languages start feeling stylistically similar while still revealing very different priorities.
Rust
use std::fs;
fn read_file() -> Result<String, std::io::Error> {
let content = fs::read_to_string("config.json")?;
Ok(content)
}
The ? operator keeps propagation concise.
Errors stay explicit.
Control flow remains visible.
This is one of Rust’s best design choices.
Zig
const std = @import("std");
fn readFile(allocator: std.mem.Allocator) ![]u8 {
const file = try std.fs.cwd().openFile("config.json", .{});
defer file.close();
return try file.readToEndAlloc(allocator, 1024 * 1024);
}
The important difference is subtle.
Zig keeps allocation visible even during convenience APIs.
That becomes surprisingly important in large systems.
Many production issues are really resource issues in disguise:
- allocation spikes
- hidden copies
- unexpected buffering
- allocator fragmentation
- ownership confusion
Zig keeps reminding you those things exist.
Rust tries harder to abstract them safely.
Example 4: Shared State Across Threads
This is where Rust becomes genuinely impressive.
Rust
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];
for _ in 0..10 {
let counter = Arc::clone(&counter);
handles.push(thread::spawn(move || {
let mut num = counter.lock().unwrap();
*num += 1;
}));
}
for handle in handles {
handle.join().unwrap();
}
}
There is ceremony here.
But Rust does something powerful:
- ownership is tracked
- mutation is controlled
- thread safety is enforced
- races become much harder accidentally
Rust’s concurrency story is restrictive because unrestricted concurrency has historically been catastrophic.
The language deeply distrusts shared mutable state.
For good reason.
Zig
Zig provides the same primitives with less ceremony.
const std = @import("std");
var counter: i32 = 0;
var mutex = std.Thread.Mutex{};
fn worker() void {
mutex.lock();
defer mutex.unlock();
counter += 1;
}
pub fn main() !void {
var threads: [10]std.Thread = undefined;
for (&threads) |*t| {
t.* = try std.Thread.spawn(.{}, worker, .{});
}
for (threads) |t| {
t.join();
}
std.debug.print("counter: {}\n", .{counter});
}
Zig’s approach feels much closer to C.
The primitives are straightforward.
The language trusts you more.
That simplicity appeals – especially when debugging.
But correctness depends more directly on engineer discipline.
Rust tries to make dangerous concurrency difficult.
Zig tries to make concurrency understandable.
Example 5: Interfacing With C
This is one of Zig’s most interesting strengths.
Zig
const c = @cImport({
@cInclude("sqlite3.h");
});
That is basically it.
Zig’s C interoperability story feels unusually direct because the language positions itself close to C semantics.
Many systems engineers notice this immediately.
Teams with large existing C codebases find incremental migration realistic.
Rust
Rust has strong FFI support.
But it usually looks more like:
use std::ffi::{c_int, c_void};
extern "C" {
fn sqlite3_open(filename: *const i8, ppDb: *mut *mut c_void) -> c_int;
}
Or it involves:
- bindgen
-
unsafeblocks - wrapper layers
- ownership translation
Rust tries to preserve safety guarantees across language boundaries.
Zig optimises for minimal friction.
Again:
- Rust prioritises correctness constraints
- Zig prioritises mechanical transparency
The same pattern keeps reappearing.
Example 6: Building a Static Binary
This example seems operationally boring until you have maintained deployment pipelines long enough.
Zig
zig build -Dtarget=x86_64-linux-musl
Done.
The first time many infra engineers try this, the reaction is:
“Wait, seriously?”
Zig’s toolchain story feels aggressively practical.
Almost as if someone tired of fighting build environments designed it.
Rust
Rust’s tooling is excellent.
Cargo is excellent.
But static cross‑compilation in Rust often introduces real‑world friction:
- linker configuration
- musl edge cases
- OpenSSL issues
- Dockerised builders
- target setup
- CI complexity
None of this is impossible.
But operationally, Zig often feels mechanically lighter.
That matters more than people think – especially for small infrastructure teams.
One Thing That Becomes Obvious After These Examples
Rust and Zig do not compete on syntax.
They compete on where engineering responsibility should live.
Rust says:
“The compiler should aggressively constrain dangerous behaviour.”
Zig says:
“The programmer should see the dangerous behaviour directly.”
That difference affects:
- APIs
- tooling
- concurrency
- debugging
- deployment
- dependency culture
- architecture style
Even the ecosystems reflect it.
Rust’s ecosystem is rich, abstracted, and ambitious.
Zig’s ecosystem is smaller, simpler, and operationally direct.
The Interesting Part Is How These Philosophies Fail
Rust failure mode:
“The system became architecturally complicated because the compiler demanded precision.”
Zig failure mode:
“The system stayed understandable, but correctness depended heavily on engineer discipline.”
Both are real costs.
Both become more visible as systems and teams grow.
What I Would Personally Optimise For
If multiple teams will maintain critical infrastructure for years:
I would strongly lean Rust.
The compile‑time guarantees compound in value organisationally.
If a small systems team deeply values operational simplicity and explicit control:
Zig becomes extremely attractive.
Especially for:
- tooling
- infrastructure utilities
- embedded systems
- lightweight services
- C migration layers
The deeper insight is this:
Rust optimises for preventing mistakes. Zig optimises for exposing reality.
Depending on the system, either property can be more valuable.
Practical Checklist
Before choosing either language, ask:
- Will many engineers touch this code?
- Is deployment simplicity a major concern?
- Is memory corruption a serious business risk?
- Is debugging or correctness the bigger pain today?
- Does the team already understand systems programming deeply?
- Will this system survive for many years?
- Is operational complexity already growing too quickly?
- Are hidden abstractions becoming a problem?
Most teams answer these emotionally.
The operational consequences arrive later.
Final Takeaway
After enough examples, the philosophical split becomes very hard to unsee.
Rust keeps moving complexity toward the compiler.
Zig keeps moving complexity toward the engineer.
Both choices carry costs.
The real question is:
“Which failure mode does this system tolerate better?”
Over to you...
If you have built serious systems in either language:
Which part became the actual long‑term cost?
What became painful once the codebase, deployment surface, and team started growing?
*AI agents write code fast. They also silently remove logic, change behavior, and introduce bugs -- without telling you. You often find out in production.
git-lrc fixes this. It hooks into git commit and reviews every diff before it lands. 60-second setup. Completely free.*
Any feedback or contributors are welcome! It's online, source-available, and ready for anyone to use.
AI agents write code fast. They also silently remove logic, change behavior, and introduce bugs -- without telling you. You often find out in production.
git-lrc fixes this. It hooks into git commit and reviews every diff before it lands. 60-second setup. Completely free.
See It In Action
See git-lrc catch serious security issues such as leaked credentials, expensive cloud operations, and sensitive material in log statements
git-lrc-intro-60s.mp4
Why
- 🤖 AI agents silently break things. Code removed. Logic changed. Edge cases gone. You won't notice until production.
- 🔍 Catch it before it ships. AI-powered inline comments show you exactly what changed and what looks wrong.
- 🔁 Build a…