zig-0-16

Zig 0.16.0 API guidance and porting notes. Use this when writing or upgrading Zig code to the 0.16.0 stable release (std.Io era, @Type removal, @cImport deprecation).

Jump to install

Repository: zigcc/skills
Last source activity: April 16, 2026 at 02:41
Detected SKILL.md language: English
Stars: 35
Forks: 3

Install options

The review-first prompt is selected by default. You can switch to a direct command or download a local copy.

Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.

A direct command skips the review prompt. Inspect the source before running it.

npx skills add https://github.com/zigcc/skills --skill zig-0-16

The command stays on one line. Scroll horizontally to inspect it before copying.

Prefer a local copy? Download the files currently available to SkillsMP.

Review the source files

Read SKILL.md and any companion files shown by SkillsMP before deciding whether to install.

File Explorer

2 files

SKILL.md

Source instructions · Read-only preview

Back to search Back to installation

zig-tiger-style

TigerStyle Zig coding guidelines — distilled from TigerBeetle's production codebase. Use this skill whenever the user is writing, reviewing, or refactoring Zig code, asking about Zig idioms, best practices, assertions, memory layout, naming conventions, or code style. Also trigger when the user asks how to structure Zig structs, handle errors, write safe loops, or design Zig APIs. Even if the user just says "write me some Zig" or pastes Zig code for review, consult this skill first.

2026-05-17

zig-0-15

This skill provides Zig 0.15.x API guidance and should be used when writing or reviewing Zig code. It ensures correct usage of Zig 0.15 APIs, preventing common mistakes from using outdated 0.11/0.12/0.13/0.14 patterns. Essential for ArrayList, std.Io.Writer/Reader (Writergate), HTTP client, Ed25519, JSON, and type introspection APIs.

2026-04-16

View all from this repository

<lib_dir>/../doc/langref.html

Old (0.15.x)	New (0.16.0)
`@Type(.Int(...))`	`@Int(.signed, bits)`
`@Type(.Struct(...))`	`@Struct(layout, BackingInt, field_names, field_types, field_defaults, field_is_comptime, field_alignments)`
`@Type(.Pointer(...))`	`@Pointer(size, attrs, Element, sentinel)`
`@Type(.Fn(...))`	`@Fn(param_types, param_attrs, ReturnType, attrs)`
`@Type(.Tuple(...))`	`@Tuple(field_types)`
`@cImport({...})`	`b.addTranslateC(...)` + `@import("c")` (deprecated)
`std.net`	`std.Io.net`
`std.ArrayList.init(allocator)`	`std.ArrayList.initCapacity(allocator, n)`
`std.crypto.random`	`std.Io.randomSecure(io, buf)`
`std.meta.intToEnum`	`std.enums.fromInt`
`std.fmt.FormatOptions`	`std.fmt.Options`
`std.fmt.bufPrintZ`	`std.fmt.bufPrintSentinel`
`std.io.fixedBufferStream`	`std.Io.Writer.fixed(buf)`
`error.RenameAcrossMountPoints`	`error.CrossDevice`
`error.NotSameFileSystem`	`error.CrossDevice`
`error.SharingViolation`	`error.FileBusy`
`error.EnvironmentVariableNotFound`	`error.EnvironmentVariableMissing`
`std.Build.Step.ConfigHeader` cmake handling	fixed leading whitespace

// Integer type
const MyInt = @Int(.signed, 32);

// Struct type
const MyStruct = @Struct(
    .auto,           // layout
    null,            // BackingInt (for packed)
    &.{"x", "y"},    // field_names
    &.{ i32, i32 },  // field_types
    &.{ null, null },// field_defaults
    &.{ false, false }, // field_is_comptime
    &.{ null, null },// field_alignments
);

// Pointer type
const MyPtr = @Pointer(.one, .{
    .alignment = 8,
    .address_space = .generic,
    .is_const = false,
    .is_volatile = false,
}, u8, null);

// Function type
const MyFn = @Fn(&.{i32, i32}, &.{.{}, .{}}, i32, .{});

// Tuple type
const MyTuple = @Tuple(&.{ i32, bool });

// Enum literal type
const EnumLitType = @EnumLiteral();

// build.zig
const translate_c = b.addTranslateC(.{
    .root_source_file = b.path("src/c.h"),
    .target = target,
    .optimize = optimize,
});
translate_c.linkSystemLibrary("glfw", .{});

const exe = b.addExecutable(.{
    .name = "myapp",
    .root_module = b.createModule(.{
        .root_source_file = b.path("src/main.zig"),
        .optimize = optimize,
        .target = target,
        .imports = &.{
            .{ .name = "c", .module = translate_c.createModule() },
        },
    }),
});

// Old -> New
error.RenameAcrossMountPoints -> error.CrossDevice
error.NotSameFileSystem       -> error.CrossDevice
error.SharingViolation        -> error.FileBusy
error.EnvironmentVariableNotFound -> error.EnvironmentVariableMissing

// 1. Bare (no args/env available)
pub fn main() !void { }

// 2. Minimal (raw argv + environ only)
pub fn main(init: std.process.Init.Minimal) !void { }

// 3. Juicy Main (recommended)
pub fn main(init: std.process.Init) !void { }

pub const Init = struct {
    minimal: Minimal,
    arena: *std.heap.ArenaAllocator,  // process-lifetime arena, threadsafe
    gpa: Allocator,                     // general-purpose allocator
    io: Io,                             // default Io implementation
    environ_map: *Environ.Map,          // env vars (not threadsafe)
    preopens: Preopens,                 // WASI-style preopened files

    pub const Minimal = struct {
        environ: Environ,
        args: Args,
    };
};

const std = @import("std");

pub fn main(init: std.process.Init) !void {
    const gpa = init.gpa;
    const io = init.io;

    try std.Io.File.stdout().writeStreamingAll(io, "Hello, world!\n");

    const args = try init.minimal.args.toSlice(init.arena.allocator());
    for (args, 0..) |arg, i| {
        std.log.info("arg[{d}] = {s}", .{ i, arg });
    }

    std.log.info("{d} env vars", .{init.environ_map.count()});
}

// Juicy Main
for (init.environ_map.keys(), init.environ_map.values()) |key, value| {
    std.log.info("env: {s}={s}", .{ key, value });
}

// Minimal main
std.log.info("HOME: {?s}", .{init.environ.getPosix("HOME")});
std.log.info("EDITOR: {s}", .{ try init.environ.getAlloc(arena, "EDITOR") });
const map = try init.environ.createMap(arena);

// Iterate lazily
var args = init.args.iterate();
while (args.next()) |arg| {
    std.log.info("arg: {s}", .{arg});
}

// To slice (needs allocator)
const args = try init.args.toSlice(arena);

// OLD (0.15)
fn doAllTheWork(pool: *std.Thread.Pool) void {
    var wg: std.Thread.WaitGroup = .{};
    pool.spawnWg(wg, doSomeWork, .{ pool, &wg, first_work_item });
    wg.wait();
}

// NEW (0.16)
fn doAllTheWork(io: std.Io) void {
    var g: std.Io.Group = .init;
    errdefer g.cancel(io);
    g.async(io, doSomeWork, .{ io, &g, first_work_item });
    g.wait(io);
}

fn doSomeWork(io: std.Io, g: *std.Io.Group, foo: Foo) void {
    foo.doTheThing();
    for (foo.new_work_items) |new| {
        g.async(io, doSomeWork, .{ io, g, new });
    }
}

// OLD
const contents = try std.fs.cwd().readFileAlloc(allocator, file_name, 1234);

// NEW
const contents = try std.Io.Dir.cwd().readFileAlloc(io, file_name, allocator, .limited(1234));
// Note: FileTooBig -> StreamTooLong when limit reached.

// OLD
const contents = try file.readToEndAlloc(allocator, 1234);

// NEW
var file_reader = file.reader(&.{});
const contents = try file_reader.interface.allocRemaining(allocator, .limited(1234));

// OLD
try atomic_file.file_writer.file.setTimestamps(io, src_stat.atime, src_stat.mtime);

// NEW
try atomic_file.file_writer.file.setTimestamps(io, .{
    .access_timestamp = .init(src_stat.atime),
    .modify_timestamp = .init(src_stat.mtime),
});

// OLD
const relative = try std.fs.path.relative(gpa, from, to);

// NEW
const cwd_path = try std.process.currentPathAlloc(io, gpa);
const relative = try std.fs.path.relative(gpa, cwd_path, environ_map, from, to);

// OLD
std.process.getCwd(buffer)
std.process.getCwdAlloc(allocator)

// NEW
std.process.currentPath(io, buffer)
std.process.currentPathAlloc(io, allocator)

// OLD (WASI)
const wasi_preopens: std.fs.wasi.Preopens = try .preopensAlloc(arena);

// NEW
const preopens: std.process.Preopens = try .init(arena);
// Or simply use init.preopens from Juicy Main.

// OLD
try std.posix.mlock();
try std.posix.mlock2(slice, std.posix.MLOCK_ONFAULT);
try std.posix.mlockall(slice, std.posix.MCL_CURRENT | std.posix.MCL_FUTURE);

// NEW
try std.process.lockMemory(slice, .{});
try std.process.lockMemory(slice, .{ .on_fault = true });
try std.process.lockMemoryAll(.{ .current = true, .future = true });

// OLD
std.posix.PROT.READ | std.posix.PROT.WRITE

// NEW
.{ .READ = true, .WRITE = true }

alignment: std.mem.Alignment,  // new field

var queue = std.PriorityQueue(u32, void, lessThan).empty;

var dq = std.PriorityDequeue(u32, void, lessThan).empty;

var set = std.EnumSet(MyEnum).empty;
var full = std.EnumSet(MyEnum).full;

Removed API	Replacement
`std.Thread.Pool`	`std.Io.Group`, `Io.async`, `Io.concurrent`
`std.heap.ThreadSafe`	`std.heap.ArenaAllocator` (now thread-safe)
`std.io.fixedBufferStream`	`std.Io.Reader.fixed(data)` / `std.Io.Writer.fixed(buf)`
`std.Io.GenericReader`	`std.Io.Reader`
`std.Io.AnyReader`	`std.Io.Reader`
`std.Io.GenericWriter`	`std.Io.Writer`
`std.Io.AnyWriter`	`std.Io.Writer`
`std.Io.null_writer`	Use `std.Io.Writer` directly
`std.Io.CountingReader`	No direct replacement; track bytes manually
`std.SegmentedList`	None
`std.meta.declList`	None
`std.fs.getAppDataDir`	None
`std.posix.getCwd*`	`std.process.currentPath*`
`std.posix.mlock*`	`std.process.lockMemory*`
`std.posix.PROT_*` bitwise flags	Struct literal flags
`std.ArrayHashMap`	`array_hash_map.Auto` / `.String` / `.Custom`

const std = @import("std");

pub fn main(init: std.process.Init) !void {
    const gpa = init.gpa;

    var list = try std.ArrayList(u8).initCapacity(gpa, 16);
    defer list.deinit(gpa);

    try list.append(gpa, 'a');
    try list.appendSlice(gpa, "hello");
    try list.ensureTotalCapacity(gpa, 100);

    const owned = try list.toOwnedSlice(gpa);
    defer gpa.free(owned);
}

var map = std.StringHashMap(u32).empty;
defer map.deinit(gpa);

try map.put(gpa, "key", 42);
const val = map.get("key") orelse 0;

pub fn main(init: std.process.Init) !void {
    const io = init.io;

    // Direct streaming write
    try std.Io.File.stdout().writeStreamingAll(io, "Hello, world!\n");

    // Or via writer interface
    var stdout_writer = std.Io.File.stdout().writer(&.{});
    try stdout_writer.interface.print("value: {d}\n", .{42});
}

// Reader from byte slice
var data = "line1\nline2\n";
var reader: std.Io.Reader = .fixed(data);

// Writer into a stack buffer
var buf: [256]u8 = undefined;
var writer: std.Io.Writer = .fixed(&buf);
try writer.interface.print("count: {d}", .{7});

// Read entire file
const contents = try std.Io.Dir.cwd().readFileAlloc(io, "input.txt", gpa, .limited(1024 * 1024));
defer gpa.free(contents);

// Write file atomically
var atomic = try std.Io.File.Atomic.init(io, gpa, "output.txt");
try atomic.file_writer.interface.print("data: {s}\n", .{"hello"});
try atomic.commit(io);

const MyStruct = struct {
    name: []const u8,
    value: u32,
};

// Parsing
const json_str =
    \\{"name": "test", "value": 42}
;
const parsed = try std.json.parseFromSlice(MyStruct, gpa, json_str, .{});
defer parsed.deinit();

// Serialization to string (via Io.Writer.Allocating)
var out: std.Io.Writer.Allocating = .init(gpa);
defer out.deinit();
var stringify: std.json.Stringify = .{
    .writer = &out.writer,
    .options = .{},
};
try stringify.write(parsed.value);
const json_output = out.written();

const info = @typeInfo(T);
if (info == .pointer) { ... }
if (info == .slice) { ... }
if (info == .@"struct") { ... }
if (info == .@"enum") { ... }
if (info == .@"union") { ... }
if (info == .optional) { ... }

test "basic arithmetic" {
    const std = @import("std");
    try std.testing.expectEqual(4, 2 + 2);
    try std.testing.expectError(error.OutOfMemory, mightFail());
}

test "no leaks" {
    const std = @import("std");
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer std.testing.expect(gpa.deinit() == .ok) catch @panic("leak");
    const allocator = gpa.allocator();

    const ptr = try allocator.create(u32);
    defer allocator.destroy(ptr);
}

// OLD: std.leb.readUleb128(reader)
// NEW:
const value = try reader.takeLeb128(u64);

Error	Cause	Fix
`no field named 'getStdOut'`	Using old `std.io.getStdOut()`	Use `std.Io.File.stdout()`
`expected 2 argument(s), found 1`	`ArrayList` method missing allocator	Add allocator as first argument
`no member named 'Pool' in 'Thread'`	`std.Thread.Pool` removed	Use `std.Io.Group` + `Io.async`
`expected type '*const process.Environ.Map'`	Function needs env map param	Pass it from `main(init)`
`no member named 'fixedBufferStream'`	Old stream API removed	Use `std.Io.Reader.fixed(...)` or `std.Io.Writer.fixed(...)`
`no field named 'getCwd' in 'process'`	Renamed	Use `std.process.currentPath*`
`fingerprint field missing`	Old `build.zig.zon`	Add `.fingerprint = 0x...` and change `.name = "x"` to `.name = .x`
`type depends on itself for alignment`	Self-referential alignment query	Remove `@alignOf(@This())` or restructure

.{
    .name = .myproject,  // enum literal, not "myproject"
    .fingerprint = 0x123456789abcdef0,
    .version = "0.1.0",
    .dependencies = .{},
}

zig build --fork=/path/to/local/fork

zig build test --test-timeout 500ms

name	zig-0.16
description	Zig 0.16.0 API guidance and porting notes. Use this when writing or upgrading Zig code to the 0.16.0 stable release (std.Io era, @Type removal, @cImport deprecation).
license	MIT
compatibility	["opencode","claude-code"]
metadata	{"version":"0.16.0","language":"zig","category":"programming-language"}

name	zig-0.16
description	Zig 0.16.0 API guidance and porting notes. Use this when writing or upgrading Zig code to the 0.16.0 stable release (std.Io era, @Type removal, @cImport deprecation).
license	MIT
compatibility	["opencode","claude-code"]
metadata	{"version":"0.16.0","language":"zig","category":"programming-language"}

zig-0-16

Source facts

Install options

Review the source files

More from this repository

Zig 0.16.0 Programming Guide

Local Documentation First

Zig 0.16.0 Programming Guide

Local Documentation First

Quick Reference: Top Breaking Changes

Language Changes

@Type Removed — Use Individual Builtins

@cImport Deprecated — Use Build System Translation

Switch Improvements

Other Language-Level Gotchas

Standard Library: std.Io

Networking

I/O Readers/Writers

Time / Random / Env / Exit

TLS Client Options

MemoryPool API Changes

Format Options

Randomness / Crypto

Enum Conversion

Fixed-Buffer Writers in Tests

Collections

Error Set Renames

Math

Threading

Compression

Dynamic Libraries

New Execution Model: Juicy Main

main signatures

std.process.Init contents

Example

Environment Variables & Process Args Are Non-Global

Environment variables

CLI arguments

Thread.Pool Removed → Use std.Io

Migration example

File I/O & fs API Changes

readFileAlloc / readToEndAlloc

setTimestamps

Directory walking

fs.path.relative is now pure

fs.path Windows changes

Current Directory API renamed

Preopens & Atomic / Temporary Files

Preopens

Atomic / Temporary Files

Memory & Allocator Changes

ArenaAllocator is now lock-free and thread-safe

ThreadSafe Allocator removed

Memory Locking / Protection moved to std.process

MemoryPool

Io.Writer.Allocating alignment field

Container & Collection Changes

Migration to "Unmanaged"

PriorityQueue

PriorityDequeue

BitSet / EnumSet

SegmentedList

Removed APIs (Quick List)

Common Idioms in Zig 0.16.0

ArrayList

HashMap (Default / Unmanaged Style)

stdout / stderr with Juicy Main

Fixed-Buffer Reader / Writer

File I/O

JSON

Type Reflection (Comptime)

Testing

Leb128 (Binary Format)

Common Error Messages and Fixes (0.16)

Build System Changes

Fingerprint Required in build.zig.zon

Local Package Overrides: --fork

Packages Fetched to zig-pkg Directory

Unit Test Timeouts

ConfigHeader

`main` signatures

`std.process.Init` contents

Memory Locking / Protection moved to `std.process`