Appendix D. Important Standard Library APIs

Zig’s standard library is imported with:

const std = @import("std");

Most useful standard library APIs live under std.

This appendix is a beginner map. It does not cover every function. It shows the parts you will use most often.

D.1 Printing

Use std.debug.print for simple output while learning.

const std = @import("std");

pub fn main() void {
    std.debug.print("Hello\n", .{});
}

With values:

std.debug.print("x = {}\n", .{x});

With strings:

std.debug.print("name = {s}\n", .{name});

Common format patterns:

D.2 Testing

Use std.testing for unit tests.

const std = @import("std");

fn add(a: i32, b: i32) i32 {
    return a + b;
}

test "add works" {
    try std.testing.expect(add(2, 3) == 5);
}

Run:

zig test main.zig

Useful testing APIs:

D.3 Memory Allocation

Zig does not hide heap allocation. Many APIs ask for an allocator.

Common allocator type:

std.mem.Allocator

Page allocator:

const allocator = std.heap.page_allocator;

General-purpose allocator pattern:

var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();

const allocator = gpa.allocator();

Arena allocator pattern:

var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();

const allocator = arena.allocator();

Allocate bytes:

const buf = try allocator.alloc(u8, 1024);
defer allocator.free(buf);

Important APIs:

D.4 Memory Utilities

std.mem contains functions for working with slices, bytes, and memory.

Compare slices:

if (std.mem.eql(u8, a, b)) {
    // same bytes
}

Copy bytes:

@memcpy(dest, source);

Fill bytes:

@memset(buffer, 0);

Find value:

const index = std.mem.indexOf(u8, text, "needle");

Useful APIs:

D.5 ArrayList

std.ArrayList is a growable array.

var list = std.ArrayList(i32).init(allocator);
defer list.deinit();

try list.append(10);
try list.append(20);

Access items:

for (list.items) |item| {
    std.debug.print("{}\n", .{item});
}

Useful APIs:

D.6 Hash Maps

String keys:

var map = std.StringHashMap(i32).init(allocator);
defer map.deinit();

try map.put("one", 1);
try map.put("two", 2);

Get a value:

if (map.get("one")) |value| {
    std.debug.print("{}\n", .{value});
}

Generic hash map:

std.AutoHashMap(K, V)

Useful APIs:

D.7 Files

Open a file:

const file = try std.fs.cwd().openFile("data.txt", .{});
defer file.close();

Create a file:

const file = try std.fs.cwd().createFile("out.txt", .{});
defer file.close();

Read and write APIs vary by Zig version. In Zig 0.16, newer I/O APIs use the std.Io model. The main idea remains the same: open files through std.fs, then read or write through the appropriate reader or writer API.

Directory APIs:

D.8 Paths

Use std.fs.path for path operations.

const base = std.fs.path.basename("/tmp/file.txt");

Useful APIs:

Path handling is platform-sensitive. Avoid manual string concatenation for paths.

D.9 Formatting

Use std.fmt for converting values to text.

Format into a buffer:

var buf: [64]u8 = undefined;

const text = try std.fmt.bufPrint(&buf, "x = {}", .{x});

Parse integer:

const n = try std.fmt.parseInt(i32, "123", 10);

Parse float:

const f = try std.fmt.parseFloat(f64, "3.14");

Useful APIs:

D.10 Math

Use std.math.

const x = std.math.sqrt(16.0);

Common APIs:

Some operations may return errors or require specific types. Read the function signature.

D.11 Random Numbers

Use std.Random.

A common pattern:

var prng = std.Random.DefaultPrng.init(12345);
const random = prng.random();

const n = random.int(u32);

For serious security-sensitive randomness, use a cryptographic random source, not a deterministic PRNG.

Useful APIs:

D.12 Time

Use std.time.

const start = std.time.nanoTimestamp();

// work

const end = std.time.nanoTimestamp();
const elapsed = end - start;

Useful APIs:

D.13 Process

Use std.process for process-level data and child processes.

Common needs:

In Zig 0.16, process arguments and environment handling are less global and fit better with explicit I/O design. Expect examples to pass context more explicitly than older Zig code.

D.14 Sorting

Use std.sort.

Example idea:

std.sort.heap(i32, items, {}, lessThan);

Comparator:

fn lessThan(_: void, a: i32, b: i32) bool {
    return a < b;
}

Sorting APIs may vary by version, so check the exact signature for your Zig release.

D.15 JSON

Use std.json.

Common operations:

Example type:

const User = struct {
    name: []const u8,
    age: u32,
};

JSON APIs often need an allocator because parsed data may allocate memory.

D.16 HTTP

Zig’s standard library includes HTTP support, but HTTP APIs have changed across releases.

For beginner projects, learn these ideas first:

When using Zig 0.16, prefer examples written for Zig 0.16 because older HTTP examples may not compile unchanged.

D.17 Logging

Use std.log.

std.log.info("server started on port {}", .{port});

Levels:

D.18 Threading

Use std.Thread.

Example shape:

const thread = try std.Thread.spawn(.{}, worker, .{});
thread.join();

Worker:

fn worker() void {
    // work here
}

Related APIs:

D.19 Networking

Use std.net for networking.

Common concepts:

Networking code usually involves I/O, errors, buffers, and careful resource cleanup.

D.20 Build System

The build system uses build.zig.

Common names:

A small build script creates an executable, sets its root source file, and installs it.

D.21 C Interop

Zig can import C headers:

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

Then call C functions:

_ = c.printf("hello\n");

Zig can also compile C code through:

zig cc

This is one of Zig’s practical strengths.

D.22 Common Import Map

D.23 How to Read Standard Library Code

The standard library is ordinary Zig code.

When documentation is unclear, open the source.

Look for:

A useful habit is to read signatures before reading implementation.

Example:

pub fn parseInt(comptime T: type, buf: []const u8, radix: u8) !T

This tells you a lot:

T is known at compile time.

buf is the input text.

radix is the base, such as 10 or 16.

The function may fail.

The successful result has type T.

D.24 What to Memorize First

For beginners, memorize these first:

Do not try to memorize the whole standard library. Learn it by solving small problems.