Zig Language Overview

Zig 0.14 — systems language | no hidden control flow | no hidden allocations | no preprocessor | compile-time execution

Paradigm

Imperative, procedural, data-oriented. Static typing with inference, structural (duck) typing via comptime. Compilation via LLVM + self-hosted backend. No operator overloading, no exceptions, no RAII, no macros.

Types

Declarations

Control Flow

Switch Features

• Exhaustiveness checked at compile time
• Multiple items per arm: 1, 2 => ...
• Range arms: 0...10 => ...
• Capture prong names: inline else => \|tag\| ...

Operators

Comptime (Metaprogramming)

fn max(comptime T: type, a: T, b: T) T {
    return if (a > b) a else b;
}

comptime {
    // Runs at compile time
    @compileLog("building for", @tagName(builtin.cpu));
}

// Generics via comptime parameters
fn ArrayList(comptime T: type) type {
    return struct {
        items: []T,
        fn init(self: *Self) void { ... }
    };
}

Comptime Features

• comptime blocks execute during compilation
• comptime function parameters are compile-time known
• inline for / inline while unroll loops at comptime
• @Type(...) construct types at comptime
• @fieldParentPtr reverse field lookup
• @hasDecl @hasField compile-time reflection
• @typeInfo get type information as a struct

Memory

Allocators

std.heap.page_allocator std.heap.arena_allocator std.heap.FixedBufferAllocator std.heap.ArenaAllocator std.heap.StackFallbackAllocator std.heap.c_allocator

Zig's allocator philosophy

• Every allocation takes an explicit allocator parameter
• No global allocator, no implicit allocations
• Allocators compose (pool → arena → page)

Error Handling

// Error union type: ReturnType!Error
fn div(a: i32, b: i32) !i32 {
    if (b == 0) return error.DivisionByZero;
    return a / b;
}

// Try operator: early return on error
const result = try div(10, 2);

// Catch: provide default
const val = div(10, 0) catch 0;

// Global error set vs specific
fn parse() ParseError!i32 { ... }

Defer & Errdefer

{
    const buf = try allocator.alloc(u8, 100);
    defer allocator.free(buf);  // always runs at scope exit
    errdefer allocator.free(buf);  // runs only if error returned

    // ... use buf
}  // defer triggers here

Standard Library (selected)

Testing

test "basic addition" {
    try std.testing.expectEqual(4, add(2, 2));
    try std.testing.expect(add(1, 1) == 2);
    try std.testing.expectError(error.DivisionByZero, div(1, 0));
}

zig test file.zig        # run tests
zig build test           # run all tests in project
zig test --name "filter" # filter test names

Cross-Compilation

zig build-exe main.zig --target x86_64-windows  # cross-compile to Windows
zig build-exe main.zig --target aarch64-linux    # cross-compile to ARM64 Linux
zig build-exe main.zig --target riscv64-linux    # cross-compile to RISC-V

Zig ships with libc headers and cross-compilation toolchains for all major targets — no separate cross-compiler needed.

C Interop

// Import C header
const c = @cImport({
    @cInclude("stdio.h");
});

// Link C library
pub fn main() void {
    _ = c.printf("hello %d\n", 42);
}

// Direct use of C ABI
extern "c" fn strlen(s: [*:0]u8) usize;

// Zig is a better C:
// - @cImport for headers
// - export fn for C-ABI exports
// - [*:0]T for null-terminated strings
// - @ptrCast for pointer conversion
// - packed struct for ABI-compatible layouts

Notable differences from C

• No preprocessor (use comptime)
• No implicit casts (explicit @intCast @floatCast)
• No UB by default (safety checks in debug, opt-in @setRuntimeSafety)
• defer replaces goto cleanup patterns
• anytype replaces void* + macro generics
• Array type includes length ([N]T vs T[N])
• undefined instead of uninitialized
• null of optional ?*T, not pointer

Compilation

zig build-exe main.zig     # compile executable
zig build-lib lib.zig       # compile library
zig build-obj obj.zig       # compile object
zig run main.zig            # compile + run
zig test file.zig           # compile + run tests
zig fmt file.zig            # format code
zig build                   # build project (build.zig)
zig translate-c foo.h       # translate C header to Zig

Build Modes