Rust.CodeCompared.To/Zig

Zig uses @import("std") to pull in the standard library module. There is no macro system; println! is a Rust macro, while Zig writes to stdout directly through std.Io.File.stdout() and writeStreamingAll. The !void return type means the function can return an error — try propagates any I/O error up to the runtime.

Zig ships as a single binary that includes the compiler, build system, package manager, and formatter — no separate Cargo or rustfmt/clippy installs. zig build run is the idiomatic way to build and execute via a build.zig file. The build system is itself written in Zig, compiled on first use.

Zig has no use keyword. @import("std") returns a struct containing all standard library namespaces; assign it to const std. Alias a deep namespace with a plain const: const fmt = std.fmt. There are no use paths — access everything through the namespace hierarchy. The standard library ships with Zig; third-party packages come via the build system.

In Zig, const replaces Rust's let (immutable), and var replaces let mut. There is no separate keyword for compile-time constants versus runtime immutable bindings — both use const. All local variables must be used; an unused variable is a compile error. Write _ = variable; to explicitly discard a value.

Zig infers types for const declarations. Integer and float literals have special compile-time types — comptime_int and comptime_float — that coerce to any compatible concrete type at the point of use. This differs from Rust, where 42 defaults to i32. Mutable var declarations usually need an explicit type because the compiler must know the storage size.

Both languages use explicit integer widths. Zig goes further: any bit width is valid — u4, u7, u63, even u65535. std.math.maxInt(T) and std.math.minInt(T) replace Rust's T::MAX and T::MIN. Rust allows digit separators in literals (1_000); Zig does not support digit separators.

Zig allows implicit widening when the value is guaranteed to fit (e.g. i32 into i64), but never lossy conversions. Converting between integers and floats always requires an explicit builtin: @floatFromInt, @intFromFloat, @intCast, or @floatCast. Rust unifies all casts behind the as keyword; Zig separates safe widening from potentially-lossy casts by requiring different builtins.

Rust's variable shadowing — reusing a name to create a new binding after a type transform — is common and idiomatic. Zig forbids it: each name must be unique within its scope, and inner blocks may not shadow outer names either. Use distinct meaningful names or a var for mutation instead. This makes data flow explicit and avoids the confusion of two bindings named value referring to different things.

Zig's []const u8 is the direct equivalent of Rust's &str — a borrowed slice of bytes with a known length. In Zig, .len is a field, not a method call. String literals have type *const [N:0]u8 (null-terminated pointer) which coerces automatically to []const u8. Neither type owns its memory.

Rust's String is an owned heap-allocated byte buffer backed by the global allocator. In Zig 0.16.0, std.ArrayList(T) is the unmanaged dynamic array — it stores no allocator inside; pass one to each method and call defer message.deinit(allocator) to release. Initialize with .empty. There is no global allocator in Zig: every heap operation is explicit. message.items gives the []u8 slice of live contents.

In Rust, == on &str compares content. In Zig, == on slices compares only pointer identity — a common mistake coming from Rust. Use std.mem.eql(u8, a, b) for content comparison and std.mem.order(u8, a, b) for lexicographic ordering. The result of order is a std.math.Order enum with values .lt, .eq, and .gt.

Rust's format! macro returns a heap-allocated String. Zig's std.fmt.bufPrint writes into a caller-provided stack buffer and returns a slice — no allocation. Format specifiers differ: {s} for strings and {d} for integers in Zig; Rust uses {} for both. Format strings are validated at compile time in both languages.

Rust writes fixed arrays as [T; N]; Zig writes them as [N]T — type and size are swapped. Both have the size as part of the type, so [5]i32 and [6]i32 are different, incompatible types. Use [_]i32{ ... } to let the compiler infer the size from the literal. Zig has no .iter() method — iterate directly with for (array) |value|.

Rust's &[T] and Zig's []T are both fat pointers (pointer + length). Slicing syntax is the same: array[1..4]. In Zig, functions that write output receive io: std.Io as a parameter — there is no global stdout handle. The type []const T means the slice is immutable (the direct equivalent of Rust's &[T]).

Rust's Vec<T> is a heap-allocated dynamic array backed by the global allocator. In Zig 0.16.0, std.ArrayList(T) is an unmanaged dynamic array: you pass the allocator to each method call rather than storing it in the struct. Initialize with .empty. numbers.items gives the underlying []T slice. There is no {:?} debug formatter in Zig; print individual fields with {d}, {s}, or {any}.

Rust's iter().enumerate() gives (index, reference) pairs. Zig uses for (slice, 0..) |item, index| — the 0.. is a special open-ended range that supplies the iteration index. Zig's for always iterates over a sequence directly; for C-style counting loops, use while with a counter variable.

Both Rust and Zig treat if as an expression that produces a value. The syntax differs: Zig requires parentheses around the condition and omits the braces for single-expression branches. Unlike Rust, Zig has no ternary ?: operator — if (cond) a else b is the idiomatic form. Both branches must produce the same type.

Zig's while has an optional "continue expression" in : (expr) syntax placed after the condition. This expression runs after every iteration — including after continue — unlike an increment at the bottom of the loop body, which continue would skip. There is no Rust-style infinite loop { break value }; use a labeled block for that pattern.

Rust's for i in 0..5 is a range loop using the Iterator protocol. Zig has no equivalent — for only iterates over arrays and slices, not abstract iterators. Numeric ranges require a while loop with a counter. This is intentional: Zig eliminates implicit iterator state. The for (slice, 0..) form provides indices, but there is no range() function.

Zig's switch is the equivalent of Rust's match — both are exhaustive expressions. Syntax differences: Zig uses commas for multiple values (2, 3) where Rust uses |, and ... (three dots) for inclusive ranges where Rust uses ..=. The else branch replaces Rust's _. Zig switch arms cannot bind variables; use if (opt) |value| for that pattern.

Both Rust and Zig support labeled blocks that produce values via break. The syntax is close but mirrored: Rust uses 'label (lifetime-style prefix), while Zig uses label: (colon suffix before the block) and break :label value. In Rust, the last expression of a block is its value implicitly; in Zig every exit path must use an explicit break :label value.

Zig function syntax is fn name(param: Type) ReturnType { ... } — no -> arrow. The return type comes directly after the parameter list. Zig requires an explicit return; there are no implicit-return expressions as in Rust. All parameters are immutable by default; to mutate a caller's value, accept a pointer parameter.

Rust function pointer types are fn(i32) -> i32; Zig's are *const fn(i32) i32 — a pointer to a constant function, without the arrow. Pass a function's address with &function_name. Zig functions are not first-class values without the pointer; you cannot store a bare function in a variable directly.

Zig has no closures. When Rust code captures variables in a closure, the Zig equivalent is a struct whose fields hold the captured values and a method that does the work. This is more verbose but makes the captured state explicit and avoids hidden allocations. When no state needs to be captured, a plain function pointer (*const fn(i32) i32) is sufficient.

Rust returns multiple values as tuples, destructured with let (a, b) = .... Zig uses anonymous struct literals (.{ .min = value, .max = value }) — the return type is written inline as a struct type. Access fields with .min and .max. Zig has no tuple syntax; anonymous structs fill the same role with named fields, which are more self-documenting.

Zig struct definitions use const Name = struct { ... };. Struct literals always require named fields (.x = value) — positional initialization is not allowed, which prevents the common C/Rust mistake of swapping fields with the same type. Rust uses Point { x: 3.0 } (colon) while Zig uses Point{ .x = 3 } (leading dot, no colon). Structs are always value types in both languages.

In Rust, methods live in a separate impl block. In Zig, methods are ordinary functions defined inside the struct body — there is no separate impl block. A value receiver self: Point maps to Rust's self: Self; use self: *Point for mutation (like Rust's &mut self). Associated functions (Rust's fn new() -> Self) are just functions without a self parameter.

Both languages use pub for public visibility. In Zig, struct fields are public by default; methods are private unless marked pub. In Rust, both fields and methods are private by default and require pub. Zig files are modules — everything in a file can be accessed by other files that @import it, with pub controlling what is re-exported.

Rust's #[derive(Default)] generates a default() method based on each field's Default implementation. In Zig, default values are written inline in the struct definition (field: Type = value), and any field with a default can be omitted from the struct literal. There are no derive macros in Zig — default values, equality, and printing are always explicit.

Zig enum variants are conventionally lowercase; Rust uses PascalCase. In Zig, variants are accessed as Direction.north or just .north when the type is inferred from context. Zig enum values are not integers by default — use @intFromEnum(value) to convert. The switch is exhaustive; omitting any variant is a compile error, as with Rust's match.

Rust's enum variants that carry data are tagged unions. Zig's equivalent is union(enum) — a union whose active tag is automatically tracked as an enum. The payload is captured in switch with |value|. Construction is Shape{ .circle = 5.0 } rather than Shape::Circle { radius: 5.0 }. Accessing the wrong field at runtime panics in debug builds.

Zig enums support methods defined inside the enum body — just as struct methods live inside struct. There is no separate impl block. self: Coin is the value receiver. The switch on self is exhaustive: adding a new variant immediately breaks all switch statements that omit it, which the compiler flags as a compile error.

Rust's Option<T> becomes Zig's ?T — much more concise. Some(x) and None map to a non-null value and null. In Zig, null is only valid for optional types; assigning it to a non-optional is a compile error. The if (optional) |value| syntax is the direct equivalent of Rust's if let Some(value) = optional.

Rust's if let Some(x) = opt unwraps an optional inline. Zig's if (opt) |value| does the same — inside the block, value has type T, not ?T. Rust's while let Some(x) = opt iterates until None; Zig uses while (opt) |value| for the same pattern with iterator functions that return null when exhausted.

Rust's unwrap_or(default) maps to Zig's orelse operator: optional orelse default. The right-hand side of orelse can be a block expression, a return, or a break — making early-exit idioms concise. Rust's unwrap() (panic on None) maps to the postfix .? operator: optional.? panics if the value is null.

Rust's ? operator propagates both None from Option<T> and Err from Result<T, E>. In Zig, try propagates errors but there is no equivalent for optionals — use orelse return null to propagate absence manually. This is more verbose but explicit: the code makes clear at each step that propagation can occur.

Rust errors are typically enums that implement std::error::Error and Display. Zig error sets (error{ A, B }) are simpler: they are sets of named error values, not arbitrary structs. Zig errors carry no attached data — for detailed context, pass context alongside the error through separate channels. @errorName(err) converts an error to its name string.

Rust's Result<T, E> becomes Zig's E!T — an error union. The success type comes after the !: ParseError!u16 means "either a ParseError or a u16". The inferred form !void uses anyerror, which covers any error the function can return. The if (result) |value| ... else |err| ... pattern matches on success or error.

Rust's postfix ? and Zig's prefix try both propagate errors up the call stack. try expr is syntactic sugar for expr catch |err| return err. Unlike Rust's ?, Zig's try only works with error unions — not optionals. The compiler tracks the set of errors that can propagate so the return type is always precise.

Rust's .unwrap_or(default) on a Result maps to Zig's catch default. For more control, use catch |err| { ... } to inspect the error before handling: parseInt(...) catch |err| { log(err); return 0; }. The catch block can also re-propagate with return err. This mirrors Rust's match result { Ok(v) => v, Err(e) => ... }.

In Rust, Drop automatically frees heap memory when an owning variable goes out of scope — even on error. Zig has no Drop trait; cleanup is explicit via defer (always runs on scope exit) and errdefer (runs only when the enclosing function returns an error). errdefer eliminates the C pattern of duplicating cleanup on every error path and is Zig's answer to Drop for error cases.

Rust allows implicit heap allocation via .to_string(), vec![], and many other methods backed by the global allocator. Zig forbids hidden allocation entirely: every heap allocation requires an explicit std.mem.Allocator parameter. If a function does not accept an allocator, it cannot allocate. This makes allocation visible in the call graph and enables embedding Zig in environments with no heap (microcontrollers, kernels, game consoles).

Rust's Box<T> is a heap-allocated pointer that frees on Drop. Zig's allocator.create(T) returns a *T — a non-null pointer to a single heap-allocated value. Free it with allocator.destroy(pointer). The defer allocator.destroy(ptr) idiom provides the same safety as Box's Drop implementation, but is explicit in the source.

Rust's ownership model automatically tracks who owns heap memory and frees it at scope exit via Drop. Zig has no ownership model — memory is managed explicitly via allocator parameters. std.fmt.allocPrint allocates a heap string and the caller must call allocator.free. The defer allocator.free(result) idiom immediately after obtaining an allocation is the safe Zig pattern.

Arena allocators batch many allocations under one lifetime and free them all at once. Rust needs the external bumpalo crate; Zig ships std.heap.ArenaAllocator in the standard library. Because the allocator is an interface, you pass arena.allocator() to any function that takes std.mem.Allocator — the function has no idea it is talking to an arena. This is the allocator-as-parameter design paying off.

Rust generics use <T: Trait> bounds enforced by the trait system. Zig uses comptime T: type — a compile-time parameter that accepts any type. There are no trait bounds; if the type supports >, the function compiles for it (duck typing at compile time). The compiler generates a concrete function for each type used, same as Rust monomorphization, but without a separate trait system.

Rust requires the const fn annotation to mark a function as usable at compile time. In Zig, any function whose arguments are compile-time known is automatically evaluated at compile time — there is no separate annotation. A top-level const initializer is always evaluated at compile time. The same function can be called at compile time (when arguments are comptime) or runtime (when arguments are not).

Rust uses #[cfg(debug_assertions)] and cfg!() macros for conditional compilation. In Zig, if (comptime condition) evaluates the condition at compile time — the dead branch is never compiled at all. This is regular Zig code, not a macro or attribute system. @import("builtin").mode gives the optimization level (Debug, ReleaseSafe, etc.), equivalent to Rust's debug_assertions.

Rust's std::any::type_name gives a runtime string; deep reflection requires derive macros or proc-macros. Zig's @typeInfo(T) returns a std.builtin.Type tagged union at compile time — you can inspect bit widths, struct fields, enum variants, function signatures, and more, without any macro system. @TypeOf(expr) gives the compile-time type of an expression. Zig's compile-time reflection is a first-class language feature.