Zig Has a Free API You've Never Heard Of

#zig #systems #programming #languages

Zig is a systems programming language designed to replace C. It has no hidden control flow, no hidden allocations, and compiles to native code. But Zig's real superpower is its compile-time execution API — comptime.

What Makes Zig Special?

No hidden control flow — what you see is what runs
comptime — run arbitrary code at compile time
Cross-compilation — build for any target from any host
C interop — import C headers directly, no bindings needed
No allocator by default — you choose your memory strategy

The Hidden API: comptime

Zig's comptime lets you execute any function at compile time:

const std = @import("std");

// Generate a lookup table at compile time
fn generateSinTable() [256]f32 {
    var table: [256]f32 = undefined;
    for (0..256) |i| {
        table[i] = @sin(@as(f32, @floatFromInt(i)) / 256.0 * 2.0 * std.math.pi);
    }
    return table;
}

// This runs at compile time — zero runtime cost
const sin_table = comptime generateSinTable();

// Type-safe printf at compile time
pub fn main() void {
    // Format string is validated at compile time
    std.debug.print("Value: {d}, Name: {s}\n", .{ 42, "hello" });
}

Generic Programming API

// Generics via comptime type parameters
fn ArrayList(comptime T: type) type {
    return struct {
        items: []T,
        capacity: usize,
        allocator: std.mem.Allocator,

        pub fn init(allocator: std.mem.Allocator) @This() {
            return .{
                .items = &.{},
                .capacity = 0,
                .allocator = allocator,
            };
        }

        pub fn append(self: *@This(), item: T) !void {
            if (self.items.len >= self.capacity) {
                try self.grow();
            }
            self.items[self.items.len] = item;
        }
    };
}

var list = ArrayList(u32).init(allocator);
try list.append(42);

C Interop API — Zero-Cost

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

pub fn main() void {
    const curl = c.curl_easy_init();
    defer c.curl_easy_cleanup(curl);
    _ = c.curl_easy_setopt(curl, c.CURLOPT_URL, "https://example.com");
    _ = c.curl_easy_perform(curl);
}

Cross-Compilation API

# Build for any target from any host
zig build-exe main.zig -target x86_64-linux-gnu
zig build-exe main.zig -target aarch64-macos
zig build-exe main.zig -target x86_64-windows
zig build-exe main.zig -target wasm32-wasi

# Zig as a C cross-compiler
zig cc -target aarch64-linux-gnu main.c -o main

Quick Start

brew install zig
echo 'const std = @import("std"); pub fn main() void { std.debug.print("Hello Zig!\n", .{}); }' > hello.zig
zig run hello.zig

Why Systems Programmers Choose Zig

An embedded developer shared: "We cross-compile from macOS to ARM Cortex-M0 with one command. No toolchain setup, no Docker, no cross-compilation nightmares. Zig just works."

Need systems-level tools? Email spinov001@gmail.com or check my developer toolkit.

Have you tried Zig? How does comptime compare to Rust macros for you?

DEV Community