C.CodeCompared.To/Zig

There is no implicit prelude — const std = @import("std"); is always the first line. The pub fn main(init: std.process.Init) !void signature receives an I/O context; the ! prefix creates an error union with void. try propagates any I/O error up to the runtime, which prints it and exits. Zig does not add a newline automatically — \n must be explicit.

zig run compiles and executes in one step, similar to a scripting language. -O ReleaseSafe keeps overflow and null-pointer checks but removes debug assertions. -O ReleaseFast maximizes speed (like -O3). There is no separate linker invocation — zig build-exe links the binary directly.

build.zig replaces Makefiles — it is itself a Zig program. builder.standardTargetOptions enables cross-compilation via -Dtarget=aarch64-linux with no extra toolchain setup. builder.standardOptimizeOption adds -Doptimize=ReleaseSafe flags automatically. There is no separate CMake or autoconf step.

In Zig const and var replace all C type keywords — the type follows the name with a colon. All local variables must be used; an unused variable is a compile error (write _ = variable; to explicitly discard it). All variables must be initialized; leaving one unset requires the explicit value undefined.

Zig infers types for const declarations from their initialiser. Integer and float literals have special compile-time types (comptime_int, comptime_float) that coerce to any compatible concrete type at use. Mutable var declarations usually need an explicit type because the compiler must know the storage size up front.

Zig integer types use a consistent naming scheme: i or u followed by the bit width. Zig also supports arbitrary-width integers up to 65535 bits — u7, i128, and even u1024 are all valid types. There is no int / long ambiguity; widths are always explicit.

Zig has f16, f32, f64, and f128. Booleans are the type bool with values true and false — there is no implicit conversion from integers to bool. Zero is not false in Zig; using 0 where a bool is expected is a compile error.

Zig allows implicit widening when the value is guaranteed to fit (e.g. i32 to i64), but never implicit lossy casts. Converting between integers and floats always requires an explicit built-in: @floatFromInt, @intFromFloat, @intCast, or @floatCast. This eliminates a whole class of C bugs caused by silent narrowing.

In Zig, leaving a variable without an initialiser is a compile error — you must write = undefined to get C-like uninitialized memory explicitly. In debug builds, undefined is filled with 0xaa bytes, making reads from uninitialised memory obvious in output. In release builds, the bits are indeterminate, same as C.

A Zig string literal has type *const [N:0]u8 — a pointer to a null-terminated array of bytes — which coerces to []const u8 (a slice). The length is known without scanning for \0: slice.len is a field, not a function. The null terminator still exists in memory for C interop, but Zig code works with the slice, not the pointer.

== on slices compares pointer identity, not content — the same footgun as pointer comparison in C. Use std.mem.eql(u8, a, b) to compare byte content. There is also std.mem.order for lexicographic ordering, replacing strcmp for sorting.

std.fmt.bufPrint writes into a caller-provided buffer and returns a slice of the bytes written — no allocation, no null terminator trick. The format string uses {d} for integers, {s} for strings, {any} for any printable type. Format specifiers are checked at compile time; a wrong type is a build error.

Zig multiline strings use the \\ prefix on each line. The leading whitespace up to the \\ is stripped; a newline is appended to each line automatically. This eliminates the need for C's adjacent-literal concatenation trick and avoids manual \n escaping.

Zig array types are written [N]T. The size is part of the type — [5]i32 and [6]i32 are different types, so out-of-bounds access is a compile error when the index is known at compile time. Use [_]i32{ ... } to let the compiler infer the size from the literal.

A Zig slice []T is a fat pointer: a data pointer plus a length. Passing a slice to a function eliminates the C pattern of passing (ptr, length) separately. Slicing syntax array[start..end] creates a slice of the given range; bounds are checked at runtime in debug mode.

C arrays silently decay to pointers when passed to functions, losing their length. In Zig, &array coerces to a slice that carries the length — the length is never lost. Passing []const i32 instead of [*]const i32 (a many-item pointer) makes the length an inseparable part of the value.

Zig string literals have type *const [N:0]u8 — the :0 means the array has a null sentinel at index N. When you coerce to a []const u8 slice, the length is encoded in the type, not read by scanning. The null byte still exists for passing to C functions via .ptr, but Zig code never needs to scan for it.

Zig single-item pointers (*T) are always non-null — the type system guarantees they point to a valid value. Dereference uses .* (postfix) instead of C's prefix *. A nullable pointer is a separate type: ?*T. This makes null pointer dereferences impossible to express accidentally.

A nullable pointer in Zig is written ?*T. The if (opt) |value| syntax unwraps it safely — the unwrapped pointer inside the block has type *T, guaranteed non-null. Forgetting to check is a compile error: you cannot dereference a ?*T directly.

Zig distinguishes *T (points to exactly one), [*]T (points to unknown count), and []T (slice: pointer + known length). A C int * maps to [*]i32. In new Zig code, prefer slices ([]T) — they carry their own length. Use [*]T mainly when interoperating with C APIs.

In Zig, if is an expression — it produces a value. The ternary operator ?: does not exist; use if (cond) a else b instead. Both branches must produce the same type, which the compiler verifies. Block expressions using { ... } can also produce values via break.

Zig while has an optional "continue expression" in : (expr) syntax after the condition. This runs after each iteration, including when continue is used — unlike putting the increment at the bottom of the loop body, which would be skipped by a continue statement.

Zig for iterates over slices and arrays directly — no index variable, no bounds arithmetic. Use for (items, 0..) |item, index| to get both the value and its index. For raw C-style counting loops, use while with a counter variable instead.

Zig switch requires every possible value to be covered — missing a case is a compile error. There is no fall-through; each arm is independent. When switching on an enum, the else branch is only needed if the enum has unknown variants (e.g. from C). switch is also an expression that can return a value.

Zig blocks can be labeled and used as expressions. break :label value exits the labeled block and produces the given value. This eliminates the C pattern of assigning to a variable inside a loop just to use the value afterward. Every code path in the block must produce a value of the same type.

Zig function parameters are always name: Type, never just a type. Parameters are immutable by default — pass a pointer to modify the caller's value. Functions are not first-class values by default; use function pointers (*const fn(i32) i32) when you need to store or pass them.

Zig functions can return an anonymous struct literal (.{ .field = value }). The return type can be written inline as struct { min: i32, max: i32 }. This is cleaner than C's output-pointer convention and avoids heap allocation unlike returning a named struct by pointer.

Zig function pointer types are written *const fn(ArgType) ReturnType. Pass a function's address with &function_name. For higher-order programming with closures that capture state, Zig uses structs with a method — there are no closures in the C sense.

Zig struct literals always use named fields (.x = value). Positional initialisation like C's { 3.0f, 4.0f } is not allowed — every field must be named, which prevents the common C bug of swapping struct members and silently getting wrong values.

Zig methods are functions defined inside a struct block whose first parameter is named self (by convention). They are called with dot syntax: value.method(). There is no hidden this — self is an ordinary parameter that can be Point, *Point, or *const Point depending on whether the method mutates.

packed struct guarantees bit-level layout with no padding and no compiler-specific attributes needed. Zig's arbitrary-width integers (u4, u12, etc.) eliminate the : N bit-field syntax. The struct size in bytes is exactly the sum of all field bit widths divided by 8.

Zig enum values are namespaced: Color.green or just .green when the type is inferred. The switch on an enum is exhaustive — omitting any variant is a compile error; no else needed when all variants are covered. Enum values are not integers by default; use @intFromEnum to convert.

union(enum) is a tagged union where the tag is the enum itself — there is no separate tag field to keep in sync. Pattern matching with switch is exhaustive and gives you the payload with |value|. Accessing the wrong union field at runtime panics in debug mode instead of silently reading garbage bytes.

?T is the optional type — it can hold a value of type T or null. The return type in the signature makes the "might be absent" contract explicit, unlike C's sentinel convention (-1, NULL, SIZE_MAX) which is documented only in comments. The caller is forced to check before using the value.

orelse is the optional default operator — opt orelse fallback returns the wrapped value if present, or evaluates fallback otherwise. It replaces the C ternary pattern ptr != NULL ? ptr : default. The right-hand side of orelse can also be a return or break, making early-exit idioms concise.

if (optional) |value| { ... } unwraps the optional — inside the block, value has type T, not ?T. The block is skipped entirely if the optional is null. You can also use while (optional) |value| to loop until null, which is useful for iterators that return null when exhausted.

An error set is a type: error{ A, B, C }. The return type PortError!u16 is an error union — the function returns either an error from PortError or a valid u16. @errorName(err) converts an error value to its name string. Error values are not integers — you cannot compare them to -1 or ignore them silently.

try expr is shorthand for expr catch |err| return err — it unwraps the success value or propagates the error up the call stack. This makes the "happy path" readable without swallowing errors. catch |err| { ... } handles specific errors inline. defer file.close() guarantees cleanup regardless of which path exits.

errdefer runs its expression only when the enclosing function returns an error — not on normal return. This eliminates the C pattern of duplicating cleanup code on every error path. defer runs unconditionally. Together, they replace C's goto cleanup pattern cleanly.

There is no global malloc in idiomatic Zig. Functions that allocate receive an std.mem.Allocator parameter — the caller decides which allocator to use. Swapping from a general-purpose allocator to an arena or a fixed-buffer allocator requires only changing the call site, not the library code.

defer executes at the end of the enclosing scope — whether the function returns normally, via try error propagation, or via an explicit return. Multiple defers execute in reverse order (LIFO). This replaces C's goto cleanup pattern and eliminates the need to duplicate cleanup on every error path.

Zig's FixedBufferAllocator is a bump allocator backed by a stack array — no heap involved. std.heap.ArenaAllocator wraps any allocator and lets you free all allocations at once with arena.deinit(). Switching strategies is a one-line change at the call site; all code using the Allocator interface works unchanged.

std.ArrayList(T) is the standard growable array. append can fail with an out-of-memory error, so it requires try. In Zig 0.16.0, the allocator is passed per-call rather than stored in the list. Access the underlying slice via .items. defer items.deinit(allocator) frees the backing storage when the scope exits.

Zig has no preprocessor — #define does not exist. Top-level const declarations are compile-time constants. Any expression that can be evaluated at compile time is valid in a const initialiser: arithmetic, @sizeOf, @typeInfo, and more. Constants are typed, so typos in type produce a useful error.

comptime T: type is a compile-time parameter that accepts a type. Zig generates a separate concrete function for each type used — like C++ templates but with no separate template syntax. The compiler catches type mismatches at the call site, unlike C's void* approach. Types are first-class values at compile time.

if (comptime condition) is evaluated at compile time — the dead branch is not compiled at all, not merely optimized away. This replaces #ifdef with type-safe, readable Zig code. The condition must be a comptime-known value; the compiler enforces this rather than relying on the preprocessor.

@TypeOf(expr) returns the type of an expression as a compile-time value. @typeInfo(T) returns a std.builtin.Type tagged union — you can inspect fields, enum members, function signatures, and more at compile time. This replaces C's _Generic and GCC's __typeof__ with a uniform, portable mechanism.

@cImport runs the C preprocessor on the listed headers and makes all their declarations available as Zig types. There is no FFI binding layer — Zig calls C functions directly with zero overhead. The Zig build system handles -lm linking automatically when math.h functions are used.

export fn makes a Zig function visible to C with its C ABI. The C-compatible integer types are c_int, c_long, c_size_t, etc. — Zig maps them to the correct width for the target platform. This lets you replace individual C files in a project with Zig implementations incrementally.

zig translate-c converts a C file to Zig source, useful as a starting point for migration. The output uses C-style idioms initially — the idea is to then refine toward idiomatic Zig. Zig can also directly compile C files: zig cc file.c works as a drop-in replacement for gcc, enabling gradual adoption.

In debug and ReleaseSafe builds, integer overflow panics at runtime. Wrapping arithmetic uses explicit operators: +%, -%, *%. Saturating arithmetic uses +|, -|, *|. This eliminates undefined behavior for signed overflow and makes intentional wrapping explicit — a reader knows you chose wrapping on purpose.

A Zig *T pointer can never be null — the type system enforces this at compile time. Nullable pointers are a different type: ?*T. Before you can dereference a ?*T, you must unwrap it with if, orelse, or .? (force-unwrap, panics if null). Accidentally dereferencing null is a category of bug that does not exist in Zig.

Zig upgrades unused-variable warnings to hard errors. To discard a value intentionally, assign it to _: _ = result;. This makes the intent visible in code review — a reader sees you chose to ignore the value rather than wondering if you forgot. The same applies to unused function parameters.

Zig's design explicitly avoids hidden control flow: no operator overloading, no exceptions, no implicit constructors or destructors, no implicit type conversions. Every function call is visible in the source. defer and errdefer are the only constructs that defer execution, and they are always written at the call site — never injected by a type.

Zig has no preprocessor. Macros are replaced by inline fn (always inlined, type-checked), comptime functions (run at compile time), and generic functions (comptime T: type). All of these are real Zig code with types, scopes, and debugger visibility — unlike C macros, which are text substitutions that the compiler never sees.

Zig's ReleaseSafe mode is a sweet spot that does not exist in C: full speed with integer overflow, out-of-bounds, and null-dereference checks still active. In C, enabling -fsanitize is a separate step that many teams skip. In Zig, safety is opt-out, not opt-in — and the build system makes the choice explicit.