Zig Comptime Cheat Sheet

Covers Zig's comptime keyword, compile-time function execution, generic types via comptime parameters, and comptime reflection with @TypeOf/@typeInfo.

2 PagesAdvancedMar 28, 2026

`comptime` Values & Blocks

`comptime` forces an expression to be evaluated at compile time, with a normal Zig block/expression syntax.

zig

const std = @import("std");fn fibonacci(n: u32) u32 {    if (n < 2) return n;    return fibonacci(n - 1) + fibonacci(n - 2);}pub fn main() void {    // computed entirely at compile time, baked into the binary    const result = comptime fibonacci(10);    std.debug.print("fib(10) = {}\n", .{result});    comptime {        // arbitrary compile-time logic block        var sum: u32 = 0;        var i: u32 = 0;        while (i < 5) : (i += 1) sum += i;    }}

Generics via `comptime` Parameters

Zig has no separate generics syntax — types are just comptime-known values passed as parameters.

zig

fn max(comptime T: type, a: T, b: T) T {    return if (a > b) a else b;}const m = max(i32, 3, 7);       // T = i32const f = max(f64, 1.5, 2.25);  // T = f64// Generic container: a function returning a typefn Stack(comptime T: type) type {    return struct {        items: std.ArrayList(T),        pub fn init(allocator: std.mem.Allocator) @This() {            return .{ .items = std.ArrayList(T).init(allocator) };        }        pub fn push(self: *@This(), value: T) !void {            try self.items.append(value);        }    };}const IntStack = Stack(i32);

Compile-Time Reflection

`@TypeOf`, `@typeInfo`, and `@field` let you inspect and generate code based on types.

zig

const std = @import("std");fn printFields(value: anytype) void {    const T = @TypeOf(value);    const info = @typeInfo(T);    inline for (info.Struct.fields) |field| {        std.debug.print("{s}: {any}\n", .{ field.name, @field(value, field.name) });    }}const Point = struct { x: i32, y: i32 };pub fn main() void {    printFields(Point{ .x = 1, .y = 2 });    // x: 1    // y: 2}

Comptime-Known Arrays & `inline for`

Build lookup tables and unroll loops entirely at compile time.

zig

fn buildSquares(comptime n: usize) [n]u32 {    var table: [n]u32 = undefined;    for (&table, 0..) |*slot, i| {        slot.* = @as(u32, @intCast(i * i));    }    return table;}const squares = comptime buildSquares(10); // computed at compile timepub fn main() void {    // inline for unrolls the loop at compile time (n must be comptime-known)    inline for (squares) |sq| {        @import("std").debug.print("{} ", .{sq});    }}

Comptime-Related Builtins & Keywords

Reference for the core compile-time toolbox.

comptime- forces an expression, parameter, or var to be known/evaluated at compile time
@TypeOf(x)- returns the type of an expression, itself a comptime value
@typeInfo(T)- returns a struct describing T's fields/kind for reflection
@field(obj, name)- accesses a field by comptime-known string name
inline for / inline while- unrolls loops at compile time; bounds must be comptime-known
anytype- parameter type inferred per call site, resolved at compile time
@compileError(msg)- aborts compilation with a custom message, used for comptime validation

Pro Tip

Use comptime parameters plus @compileError to validate generic type constraints at the top of a function (e.g. "T must be an integer type") — you get a clear, custom compiler error instead of a confusing failure deep inside the function body.

Was this cheat sheet helpful?

Clojure Macros Cheat Sheet

Domain-Driven Design (DDD) Cheat Sheet

Explore Topics

#ZigComptime#ZigComptimeCheatSheet#Programming#Advanced#ComptimeValuesBlocks#GenericsViaComptimeParameters#CompileTimeReflection#Comptime#Functions#CheatSheet#SkillVeris

Sri Hayavadhana Info-Tech

Professional Web Designing Services