Zig

Zig is still before 1.0, so the language and standard library can change between releases. Code written for one Zig version may not compile on another version without edits.

Appendix A. Zig 1.16 New Features

Zig has not reached 1.0 yet. The current release line discussed in this book is Zig 0.16, not Zig 1.16.

Appendix A. Zig 1.16 New Features

As of the current public Zig release line, the version is Zig 0.16, not Zig 1.16. Zig has not reached 1.0 yet. In this appendix, read “Zig 1.16” as “Zig 0.16” unless...

Editors, LSP, and Debuggers

You can write Zig code in any text editor.

Comments and Documentation

Comments are notes for humans who read the code.

Compile Errors as Safety Checks

A compile error means Zig refused to build your program.

What “Exported” Means

An exported function is a function made visible outside the current Zig program.

Panic and Crash Behavior

Errors are for expected failures.

Dangling Pointers

A dangling pointer is a pointer that refers to memory that is no longer valid.

Efficient Text Processing

Efficient text processing means working with text without doing unnecessary allocation, copying, or decoding.

Data-Oriented Design

Data-oriented design means you organize a program around the data it processes.

When Not to Use `comptime`

comptime is one of Zig’s strongest features, but it should not be used everywhere.

`@intCast`

@intCast converts one integer value to another integer type.

Building Allocation-Friendly APIs

An allocation-friendly API makes memory behavior clear to the caller.

Appendix I. Zig Coding Style Guide

Zig code should be explicit, simple, and easy to inspect. The goal is not cleverness. The goal is code that another programmer can read, verify, and maintain.

Start with the Operations

A data structure is never just a container.

Process Management

A process is a running program.

Packaging Applications

Packaging means preparing your program so another person can download it, install it, and run it.

Benchmarking Code

Benchmarking measures how fast code runs.

Wrapping Existing Libraries

Wrapping a C library means building a Zig layer around it.

Writing a Small Shell

A shell is a program that reads commands and runs other programs.

High Performance Concurrent Design

High performance concurrent design means using several threads or tasks without making the program slower, more fragile, or harder to reason about.

Case Study 1: Reusing a Temporary Buffer

Performance ideas become clearer when you see them inside real code.

Following Zig Development

Zig changes quickly because it is still moving toward 1.0.

Understanding Zig IR

IR means intermediate representation.

Build a Mini Git Clone

Git stores snapshots of files.

Appendix A. Zig Syntax Summary

This appendix summarizes the core syntax of Zig 0.16. It is a compact reference, not a tutorial.

Project Structure

So far, we have used single-file programs.

Strings and UTF-8

A string is text.

Unreachable Code

Some parts of a program should never run.

A Mental Model

A calling convention defines how functions communicate at the machine level.

Custom Error Types

Most Zig programs start with small error sets:

Stack vs Heap

Zig programs use memory in different places. The two most important places are the stack and the heap.

Building Dynamic Strings

A dynamic string is text whose length is not fixed ahead of time.

Modeling State Machines

A state machine is a simple way to describe a program that moves between fixed states.

Type Reflection Basics

Type reflection means asking questions about a type while Zig is compiling the program.

Metaprogramming Patterns

Metaprogramming means writing code that helps create, inspect, or specialize other code.

`@memcpy`

@memcpy copies bytes from one memory region to another.

Lifetime Management

Memory lifetime means:

Appendix H. Useful Open Source Zig Projects

This appendix lists useful Zig projects to read after you know the basics.

Memory Debugging

Memory debugging means finding mistakes in how a program uses memory.

Contributing to Zig

Contributing to Zig means helping the language, compiler, standard library, documentation, tests, or tooling improve.

Start with the Rule

A collection is a type that stores many values.

Exercises

This chapter introduced the basic forms of values and declarations: names, constants, variables, integer types, floating-point types, booleans, bytes, inferred types, and...

Environment Variables

An environment variable is a named value provided to a program by the operating system.

Installing Binaries

A build does not only compile files. It can also install the results into a predictable output directory.

Working with Headers

C headers are the bridge between Zig and C.

Writing a CLI Tool

A CLI tool is a command-line program.

The Basic Idea

An abstraction is a way to hide detail behind a simpler interface.

Self-Hosted Zig Compiler

A self-hosted compiler is a compiler written in the language it compiles.

Packaging Cross-Platform Apps

Packaging means preparing your program so other people can download it, install it, run it, and trust what they are running.

Data Races

A data race happens when two threads access the same memory at the same time, at least one access writes, and there is no proper synchronization.

Build a Simple Game Engine

A game engine is a program structure for running interactive simulations.

Exercises

This section collects the exercises for Chapter 14.

Exercises

These exercises use the material from Chapters 15.1 through 15.8. Most are small. The goal is to practice reading and writing build.zig files until the structure becomes familiar.

A Parallel File Scanner

This section combines the ideas from the previous sections into one program structure.

Where to Go From Here

The programs in this chapter are small, but they have the shape of larger Zig programs.

Zig Compiler as a Toolchain

When beginners hear the word “compiler,” they often think of one job:

Zero Values and Initialization

Initialization means giving a value to something when it is created.

Defer and Cleanup

Many programs need to clean something up after using it.

A Simple Function

An inline function is a function where the compiler may place the function’s code directly at the call site instead of performing a normal function call.

Designing Error APIs

An error API is the part of your function signature that tells callers how failure works.

Sentinel-Terminated Arrays

A sentinel-terminated array is an array with a special value at the end.

UTF-8 Processing

Zig string data is usually stored as UTF-8 bytes.

Union Safety

A union stores one active field at a time.

Type Coercion

Type coercion means Zig converts a value from one type to another when the conversion is safe and well-defined.

Static Dispatch

Static dispatch means the compiler decides which code to call before the program runs.

`@bitCast`

@bitCast reinterprets the bits of one value as another type.

Memory Leak Detection

A memory leak happens when a program allocates memory and then loses the ability to free it.

Appendix G. C Interop Reference

Zig is designed to work closely with C. You can call C from Zig, call Zig from C, compile C code with Zig, and link Zig programs against existing C libraries.

Why Trees Matter

A tree is a collection made of nodes.

Using GDB and LLDB

GDB and LLDB are debuggers.

Open Issues and RFCs

A programming language is never only its syntax.

Running Tests

Zig has built-in support for tests.

ABI Compatibility

ABI means Application Binary Interface.

Writing a TCP Server

A TCP server is a program that waits for clients to connect.

Benchmark the Right Thing

Benchmarking means measuring how fast code runs.

Writing a Compiler in Zig

A compiler translates one form of code into another form.

Handling Platform Differences

A cross-platform Zig program should not pretend that every operating system behaves the same way. Windows, Linux, macOS, WebAssembly, and embedded targets have different...

Explicit Casts

Zig does not perform most numeric conversions automatically.

Random Number Generation

Random numbers are used when a program needs variation.

Exercises

This section collects the exercises for the chapter. They are meant to be small programs. Each one should compile and run.

Exercises

1. Write a function increment that takes i32 and adds 1 to the pointed-to value.

Channels and Queues

A queue is a data structure for passing work from one part of a program to another.

Build a Bytecode VM

A bytecode VM is a small machine inside your program.

Exercises

These exercises close the chapter on structs, enums, and unions. They are meant to make the data model concrete.

Exercises

1. Write a function parseUpper that accepts a byte and returns the uppercase letter value. Return error.InvalidUppercase if the byte is not between 'A' and 'Z'.

Exercises

The exercises in this section are meant to make allocation habits precise. Each one should be written as a complete program unless stated otherwise.

Exercises

This section collects the exercises for the chapter.

Testing Utilities

Zig has built-in support for tests.

Cross Builds

Zig can build for a different target than the machine running the compiler.

Designing Concurrent Programs

Threads are a mechanism, not a design.

Exercises

Exercise 19-1. Write a program that overflows a u8 using +=. Run it in Debug mode and observe the panic.

demo

A program is finished only when another machine can build and run it reliably.

Understanding `zig build-exe`

In the previous section, we used this command:

Undefined Values

In Zig, undefined means “this value has not been initialized.”

Inline Loops

Zig has normal loops that run when the program runs.

What Anonymous Functions Usually Mean

An anonymous function is a function without a permanent name.

Propagating Errors

Propagating an error means passing it to the caller instead of handling it immediately.

Alignment

Alignment is a rule about where a value may be placed in memory.

Mutable Strings

Zig does not have a separate built-in mutable String type.

Tagged Unions

A tagged union is a type that can store one value from several possible shapes.

Error Union Internals

An error union is a value that can contain either:

Building Generic Data Structures

A generic data structure is a data structure that works with more than one element type.

`@ptrCast`

@ptrCast converts one pointer type into another pointer type.

Allocation Failure Handling

Allocation can fail.

Appendix F. Build Modes Reference

When Zig compiles a program, it can build the program in different modes.

The Core Idea

A ring buffer is a fixed-size queue that reuses its storage.

Assertions

An assertion is a check that must be true while the program runs.

LLVM Integration

LLVM is a compiler infrastructure project.

Release Modes

Zig can build the same program in different optimization modes.

Exporting Zig to C

Zig can call C, but C can also call Zig.

Network Protocols

A network protocol is a rulebook for how programs talk over a network.

Why Branch Prediction Exists

Branch prediction is a CPU optimization.

Writing a Virtual Machine

A virtual machine is a program that runs another program.

Portable APIs

A portable API is an interface that works across more than one platform.

Time and Timers

Programs often need to work with time.

Event Loops

An event loop is code that waits for events, then runs the right piece of work for each event.

Build a Programming Language Lexer

A lexer is the first stage of many programming language tools.

Type Inference

A declaration may name its type explicitly.

`defer`

defer runs a statement when control leaves the current block.

Exercises

1. Write a function max3 that returns the largest of three integers.

Lifetimes

A pointer is useful only while the value it points to still exists.

Exercises

This section closes the chapter. The exercises are small programs. Write them by hand. Compile them. Change them. Run them again.

Data Layout

A struct is not only a list of fields. It also has a layout in memory.

Designing Error Boundaries

Most functions should not decide what an error means.

Exercises

1. Write a program that computes several Fibonacci numbers with comptime. Print the results at runtime.

Ownership Rules

Allocation creates a responsibility.

Zig 0.16 I/O Changes

Zig 0.16 changes how I/O code is written in the standard library.

Process APIs

The standard library gives access to process information through std.process.

Dependencies

A Zig package may depend on another package.

Exercises

Exercise 16-1. Write a C file containing this function:

Exercises

This section collects the chapter exercises into one working set.

Semaphores

A semaphore is a counter used for synchronization.

FFI Safety

FFI means foreign function interface. It is the boundary where Zig calls code written in another language, or where another language calls Zig.

Benchmarking

A benchmark measures the cost of a program or operation. The result is useful only if the measurement is repeatable and the work being measured is clearly defined.

Your First Zig Program

Now we will write and run a complete Zig program.

Type Inference

Type inference means Zig can figure out a type from the value you write.

`break` and `continue`

Loops repeat code. But sometimes you do not want a loop to finish in the normal way.

A First Example

Functions are values.

`errdefer`

errdefer is a cleanup tool.

Pointer Arithmetic

Pointer arithmetic means moving a pointer forward or backward through memory.

String Literals

A string literal is text written directly in your source code.

Enums

An enum is a type whose value must be one item from a fixed list.

`anytype`

anytype means the function parameter can accept many different types.

Reflection with `@typeInfo`

Reflection means inspecting a type as data.

`@typeInfo`

@typeInfo asks the compiler for structured information about a type.

Custom Allocators

A custom allocator is an allocator you design for a specific memory policy.

Appendix E. Memory Safety Checklist

Zig gives you direct control over memory. That control is useful, but it also means you must follow clear rules.

Why Bit Sets Matter

A bit set is a compact collection of yes-or-no values.

Stack Traces

A stack trace shows how your program reached a failure.

Code Generation

Code generation is the compiler stage that turns analyzed program meaning into target code.

Static and Dynamic Linking

Linking is the step where the compiler connects your program with the code it depends on.

Building Mixed Zig and C Projects

A mixed Zig and C project contains source files from both languages.

Endianness

Endianness means the order used to store the bytes of a multi-byte value.

Small Values Are Fine to Copy

Copying data is sometimes necessary, but unnecessary copying is one of the easiest ways to waste time and memory.

Writing a Parser

A parser reads text and turns it into structure.

Cross-Target Debugging

Cross-target debugging means debugging a program built for a different machine, operating system, or CPU architecture than the one you are sitting at.

Parsing Numbers and Text

Parsing means turning text into data.

Await and Suspension

await means: wait until an asynchronous operation has finished, then continue with its result.

Build a Small Database

A database stores data so it can be saved, searched, updated, and loaded again later.

Characters and Bytes

Zig does not have a separate character type for ordinary strings.

`break`, `continue`, and Labels

break leaves a loop.

Organizing a Small Program

A program grows gradually.

Alignment

Memory has addresses. Types also have alignment.

UTF-8 Handling

Zig strings are bytes. UTF-8 is one way to interpret those bytes as text.

Packed Structs

A normal struct is laid out for ordinary program use. The compiler may add padding between fields so that each field has a suitable address.

`defer` and `errdefer`

A program that opens a file must close it. A program that allocates memory must free it. A program that locks a mutex must unlock it.

Exercises

Exercise 9-17. Declare an optional integer.

Generating Declarations

A Zig function can return a type.

Exercises

Exercise 11-1. Write a generic min function for values that support <.

Fixed-Buffer Allocator

A fixed-buffer allocator uses memory that already exists.

Error Handling in I/O

Input and output can fail.

Filesystem APIs

The standard library gives access to files and directories through std.fs.

Examples

Examples are small programs kept inside the project.

ABI and Layout

A C program and a Zig program can share data only when both sides agree on layout.

Release Modes

Zig can build the same source code in different optimization modes.

Thread Pools

Creating a thread is expensive.

Packed Memory

A normal struct is laid out for efficient access.

Testing Strategy

Tests should be close to the code they check. Zig makes this easy with test blocks.

Zig Release Channels and Versioning

Before writing larger Zig programs, you need to understand an important fact:

Booleans and Comparisons

A boolean is a value that can be only one of two things:

Labels and Block Expressions

Zig has blocks.

A First Example

Recursion is a technique where a function calls itself.

`catch`

catch handles an error at the place where it happens.

Slice Lifetimes

A slice is a view into memory.

Optional Pointers

An optional pointer is a pointer that may have no value.

Anonymous Structs

An anonymous struct is a struct type without a name.

Opaque Types

An opaque type is a type whose internal structure is hidden.

Generating Code at Compile Time

Generating code at compile time means using Zig code to create specialized program behavior before the final executable is built.

`@Type`

@Type builds a type from compile-time type information.

Page Allocator

The page allocator asks the operating system for memory directly.

The Basic Difference

Queues and stacks are two simple ways to organize a collection of items.

Appendix D. Important Standard Library APIs

Zig’s standard library is imported with:

Debug Builds

A debug build is a build made for finding mistakes.

Semantic Analysis

Semantic analysis is the compiler stage that checks what a program means.

Cross Compilation

Cross compilation means building a program for a different machine than the one you are using.

Linking C Libraries

Importing a C header lets Zig understand a C API. Linking gives the final program the actual compiled code.

Binary File Formats

A binary file format stores data as bytes with a specific structure.

Why Allocations Cost Time

Allocations are one of the most common causes of slow programs.

Writing a Game Engine Core

A game engine core is the small central layer that runs the game.

ARM and Embedded Targets

ARM is a CPU architecture family used in phones, tablets, laptops, routers, Raspberry Pi boards, microcontrollers, servers, and many embedded devices. When you write Zig for...

Formatting and Printing

Formatting means turning values into text.

Async Functions

Async code lets a program start an operation now and receive the result later.

Build a Memory Allocator

A memory allocator is code that gives memory to the rest of a program.

Booleans

A boolean value is either true or false.

`for` Loops

A for loop visits the elements of an array, slice, or range.

Importing Files

Large programs are divided into smaller files. Zig uses @import to include declarations from another file.

Pointer Arithmetic

Pointer arithmetic means forming a new pointer by moving from one element to another.

Strings Are Bytes

A Zig string is a sequence of bytes.

Tagged Unions

A union is a value that may hold one of several types.

`catch`

catch handles an error union.

Optionals Versus Errors

Optionals and errors both describe a value that may not be produced.

Reflection

Reflection means inspecting a type from inside the program.

Compile-Time Dispatch

Generic functions in Zig are specialized at compile time.

Arena Allocator

An arena allocator is used when many allocations have the same lifetime.

Standard Input and Output

A program usually has three standard streams:

Formatting

Zig uses format strings to turn values into text.

Tests

Zig has tests in the language.

Calling Zig from C

C can call Zig when the Zig function is exported with a C-compatible ABI.

Static and Dynamic Linking

A program is made from object code.

Async Status in Zig 0.16

Zig once had async functions as a language feature.

Volatile Memory

Most memory in a program behaves normally.

A Static Library

A library is code meant to be used by another program. In Zig, a library can be built from the same kind of source files as an executable. The difference is in how the build...

Installing Zig

Before we write more Zig code, we need the Zig compiler.

Floating Point Numbers

Floating point numbers are numbers with fractional parts.

`for` Loops

A while loop repeats while a condition is true.

Returning a Struct

Many functions need to produce more than one piece of information.

`try`

try is the most common way to handle errors in Zig.

Slices in Detail

A slice is a view into a sequence of values.

Slices

A slice is a view into a sequence of values.

Packed Structs

A normal Zig struct is designed for ordinary data modeling.

Vectors

A vector is a fixed-size group of values of the same type.

How Parsing Works

Parsing is the part of the compiler that reads source code and turns it into structure.

Compile-Time Loops

A compile-time loop is a loop that runs while Zig is compiling your program.

`@alignOf`

@alignOf asks the Zig compiler for the required memory alignment of a type.

Fixed Buffer Allocator

A fixed buffer allocator gives memory from a buffer you already own.

Fuzz Testing

Fuzz testing means testing a program with many generated inputs.

Using C Structs

A C struct groups several fields into one value.

Why Linked Lists Exist

A linked list is a collection where each item points to the next item.

Appendix C. Common Compiler Errors

One of Zig’s strengths is compiler diagnostics. Zig tries to explain problems precisely instead of silently accepting dangerous behavior.

Terminal Programming

Terminal programming means writing programs that interact with the command line as more than simple text output.

Build Options

A build option is a value passed from the command line into build.zig.

Embedded Development

Embedded development means writing software for small computers inside devices.

Why SIMD Matters

SIMD means Single Instruction, Multiple Data.

WebAssembly

WebAssembly, often shortened to Wasm, is a portable binary instruction format. It lets you compile code once and run it inside different hosts, such as web browsers, servers,...

Directories and Paths

A file lives inside a directory.

Condition Variables

A condition variable lets one thread sleep until another thread says that something has changed.

Build a Thread Pool

A thread pool is a group of worker threads that wait for jobs.

Floating-Point Types

Zig has floating-point types for numbers with fractional parts.

`while` Loops

A while loop repeats while a condition is true.

Public Declarations

A Zig program may be split across many files. Declarations can be made visible outside a file with pub.

Slices

A slice is a pointer and a length.

Sentinel Arrays

Some arrays have a special value after the last ordinary element. This value is called a sentinel.

Enums

An enum is a type whose values come from a fixed set of names.

`try`

try is a shortcut for a common operation:

Optional Pointers

Pointers are often optional.

Inline Loops

A normal loop runs while the program runs.

Interfaces by Convention

Zig has no built-in interface keyword.

General-Purpose Allocator

The general-purpose allocator is used for ordinary heap allocation.

Buffered I/O

Reading or writing one byte at a time is expensive.

Hash Maps

A hash map stores key-value pairs.

Build Options

A build option is a value passed to build.zig from the command line.

Linking Libraries

Calling a C function is only half the job. The linker must also find the code for that function.

libc and Freestanding Builds

A Zig target may use a C library, or it may use none.

Condition Variables

A mutex protects shared data.

A Tiny HTTP Client

An HTTP client opens a network connection, sends a request, receives a response, and writes the response body.

Integer Overflow

An integer type can store only a fixed range of values.

Why Zig Exists

Zig exists because low-level programming is still important, but the old tools have painful tradeoffs.

Integer Types and Overflow

Integers are whole numbers.

`while` Loops

Programs often need to repeat work.

The `return` Keyword

Functions often need to produce results.

Error Union Types

An error union type means:

Many Item Pointers

A many item pointer is a pointer that can move across several values of the same type.

Multidimensional Arrays

A multidimensional array is an array whose elements are also arrays.

Default Field Values

A struct field can have a default value.

Understanding Stage2

When people talk about Zig compiler internals, they often mention stage2.

Nullable Pointers

A pointer stores the address of a value in memory.

Inline Branching

Inline branching means Zig chooses a branch during compilation, not during runtime.

`@sizeOf`

@sizeOf asks the Zig compiler how many bytes a type needs in memory.

Table-Driven Tests

A table-driven test checks many input cases with one test loop.

Why StringHashMap Exists

A StringHashMap is a hash map where the key is a string.

Arena Allocator

An arena allocator is an allocator that frees many allocations at once.

Calling C Functions

Calling a C function from Zig has three parts.

Appendix B. Zig Cheat Sheet

const std = @import"std";

Working with the OS

Systems programming means working directly with the operating system.

The Basic Idea

Modern CPUs are fast, but memory is much slower.

Plugin Architectures

A plugin architecture lets a program be extended without rewriting the whole program.

Atomics

An atomic operation is a small operation that can safely happen while several threads are running.

Writing Files

Writing a file means sending bytes from your program to the operating system so they can be stored on disk.

macOS Support

macOS is one of Zig’s main desktop targets. You can use Zig on macOS to write command-line tools, development utilities, servers, libraries, and cross-platform applications.

Adding Dependencies

A Zig project can depend on other Zig packages.

Build a Static File Server

A static file server is a program that reads files from a directory and sends them to a browser over HTTP.

Integer Types

Zig has signed and unsigned integer types.

`switch` Expressions

A switch chooses one branch from several alternatives.

Passing Values

When a function is called, values are passed from the caller to the function parameters.

Many-Item Pointers

A many-item pointer points to the first item in a sequence.

Slicing Arrays

A slice is a view into an array.

Methods as Functions

Zig has no class syntax.

Returning Errors

A function returns an error the same way it returns a normal value: with return.

Unwrapping Optionals

An optional value cannot be used as the payload type until it is unwrapped.

Types as Values

In Zig, a type is a value.

Type Constraints by Use

Zig does not have a formal trait or interface system.

Page Allocator

The page allocator gets memory from the operating system.

Writing Bytes

Writing bytes is the opposite of reading them.

`std.ArrayList`

std.ArrayList is a growable array.

Build Steps

A build file describes steps.

Header Translation

@cImport does two jobs.

CPU Architectures

The architecture part of a target tells Zig what kind of processor the program will run on.

Atomics

A mutex makes one thread wait while another thread uses shared data.

Pointer Casts

A pointer has a type.

A Line Filter

A line filter reads text, changes or selects some lines, and writes the result. Many Unix programs have this shape.

What Is Zig

Zig is a programming language for writing programs that are fast, clear, and close to the machine.

Primitive Types

Every value in a Zig program has a type.

`switch`

An if statement is good for general conditions:

Parameter Syntax

Function parameters are the inputs of a function.

Error Sets

An error set is a group of possible error names.

Single Item Pointers

A pointer is a value that stores the address of another value.

Array Literals

An array literal is the syntax you use to write array values directly in source code.

Struct Methods

A struct method is a function that belongs to a struct.

Appendix A. Zig 0.16 New Features

Zig 0.16.0 was released on April 14, 2026. The release contains 8 months of work, with changes from 244 contributors across 1,183 commits. The largest themes are the new I/O...

Optional Unwrapping

Optional unwrapping means taking the value out of an optional.

Compile-Time Variables

In the previous section, you learned that Zig can execute code during compilation.

`@import`

One of the first Zig builtins you will learn is @import.

General Purpose Allocator

The general purpose allocator is Zig’s standard allocator for ordinary heap allocation.

The Basic Idea

A HashMap is a data structure for storing values by key.

Creating Build Steps

A Zig build is made from steps.

Writing Unit Tests

A unit test checks one small piece of code in isolation.

Reading Files

Reading a file means asking the operating system for bytes stored on disk.

`@cImport`

@cImport is Zig’s built-in way to import C declarations from header files.

Mutexes

A mutex is a lock for shared data.

System Calls

A system call is a request from your program to the operating system.

Why Profiling Matters

When a program feels slow, your first job is not optimization.

Reflection Systems

Reflection means a program can inspect information about types while the program is being compiled or running.

Linux Support

Linux is one of the most natural platforms for Zig. Many Zig programs are built, tested, and deployed on Linux because Linux is common in servers, containers, embedded...

Zig Source Tree

When you first open the Zig source code repository, it can feel overwhelming.

Build a JSON Parser

A JSON parser reads JSON text and turns it into data your program can use.

`const` and `var`

Zig has two kinds of variable declarations:

`if` Expressions

In Zig, if is an expression. It can produce a value.

Parameters and Return Values

Functions communicate through parameters and return values.

Single-Item Pointers

A single-item pointer points to one value.

Array Literals

An array literal creates an array value.

Field Access

Fields are selected with the dot operator.

Error Unions

An error union combines a normal value with an error set.

Null

null is the value used when an optional has no payload.

Compile-Time Parameters

A function parameter can be marked comptime.

Generic Structs

A generic struct is a function that returns a type.

The Allocator Interface

An allocator is a value that knows how to allocate and free memory.

Reading Bytes

A file is read as bytes.

`std.mem`

The std.mem module contains operations on memory, slices, bytes, and basic data movement. Much of Zig programming eventually passes through std.mem.

`build.zig`

The file build.zig is a Zig program.

`@cImport`

Writing every C declaration by hand is tedious. Zig can read C headers directly.

Operating Systems

The operating system part of a target tells Zig what kind of system the program will run on.

Mutexes

A mutex is a lock for shared data.

Safety Checks

Zig inserts safety checks for operations that are valid only under certain conditions. These checks are present in safe build modes. They catch mistakes at the point where the...

A File Copier

A file copier is a useful small program. It opens one file for reading, opens another file for writing, then copies bytes from the first to the second.

What Is Zig

Zig is a programming language for writing fast, small, reliable programs.

What Is Zig

Zig is a programming language for writing fast, small, reliable programs.

Variables and Constants

A program stores values so it can use them later. In Zig, you store values with two main keywords:

`if` Expressions

Programs need to make choices.

The Structure of a Function

Functions are reusable blocks of code.

Why Zig Has No Exceptions

Most programming languages need a way to handle failure.

Memory Model Basics

Memory is where a program keeps its data while it runs.

Fixed Arrays

An array is a group of values stored next to each other.

Struct Definitions

A struct is a type that groups several values together.

Optional Types

An optional type is a type that can hold either a value or no value.

What Is `comptime`

comptime means “compile time.”

Understanding `@` Builtins

Zig has special built-in functions whose names start with @.

Why Zig Uses Allocators

Memory is one of the most important ideas in Zig.

Importing ArrayList

An ArrayList is one of the most important data structures in Zig.

Tour of `std`

std is Zig’s standard library.

Introduction to `build.zig`

Zig has a built-in build system.

Zig Test Framework

Zig has a built-in test system. You do not need a separate testing library to start writing tests.

Why Zig Works Well with C

Zig works unusually well with C because it treats C as a first-class part of systems programming.

Threads in Zig

A thread is a separate path of execution inside one program.

Memory Mapped Files

A memory mapped file is a file that the operating system places into your program's address space.

What Actually Makes Programs Slow?

Performance is one of the main reasons people choose Zig.

Custom Formatting

Zig has a formatting system built into the standard library. You have already used it many times through std.debug.print.

Windows Support

Windows is one of Zig’s main supported platforms. You can write Zig programs on Windows, build Windows executables, call Windows system APIs, link with C libraries, and...

Build a CLI Calculator

In this project, we will build a small command-line calculator.

Zig Compiler Architecture

The Zig compiler is not only a compiler for the Zig language. It is also the center of the Zig toolchain.

Names and Declarations

A Zig program is made from declarations.

Blocks are Expressions

A block is a sequence of statements inside braces.

Defining Functions

A function groups statements into a single operation. Functions are the basic unit of organization in a Zig program.

Addresses and Pointer Types

A variable has a value. In Zig, a variable may also have an address.

Fixed-Size Arrays

An array is a sequence of values of the same type.

Struct Declarations

A struct is a type made from named fields.

Error Sets

Programs fail for many reasons. A file may not exist. Memory allocation may fail. Input may be malformed. A network connection may close unexpectedly.

The Optional Type

Sometimes a value may or may not exist.

What `comptime` Means

A Zig program runs in two stages.

Generic Functions

A function in Zig can take types as parameters.

Why Allocation Is Explicit

A program uses memory to store values.

Files

Most programs spend their time moving bytes.

`std.debug`

The std.debug module contains utilities for debugging programs. The most commonly used function is print, which writes formatted output to standard error.

`zig build`

Large programs are rarely built with a single compiler command.

Calling C

One of Zig's design goals is direct interoperability with C.

Target Triples

One of Zig's main design goals is cross compilation.

Threads

A thread is an independent flow of execution.

Undefined Behavior

Zig gives the programmer direct access to memory, integers, pointers, and machine operations. This makes many programs simple and efficient. It also makes some operations...

A Command-Line Parser

Many programs begin the same way: they read command-line arguments, decide what the user requested, then execute an operation.

Learn Zig

Learn Zig book notes, organized into 20 chapters.

Appendix

The first program in Zig is small.

Chapter 20. A Command-Line Parser

Many programs begin the same way: they read command-line arguments, decide what the user requested, then execute an operation.

Chapter 19. Undefined Behavior

Zig gives the programmer direct access to memory, integers, pointers, and machine operations. This makes many programs simple and efficient. It also makes some operations...

Chapter 18. Threads

A thread is an independent flow of execution.

Chapter 17. Target Triples

One of Zig's main design goals is cross compilation.

Chapter 16. Calling C

One of Zig's design goals is direct interoperability with C.

Chapter 15. `zig build`

Large programs are rarely built with a single compiler command.

Chapter 14. `std.debug`

The std.debug module contains utilities for debugging programs. The most commonly used function is print, which writes formatted output to standard error.

Chapter 13. Files

Most programs spend their time moving bytes.

Colophon

This book describes the Zig programming language as of Zig 0.16.

Chapter 12. Why Allocation Is Explicit

A program uses memory to store values.

Appendix J. Index

A

Chapter 11. Generic Functions

A function in Zig can take types as parameters.

Appendix I. Exercise Answers

These are short answers or sketches for selected exercises from the book. Many exercises have several reasonable solutions. The important part is clarity and correctness.

Chapter 10. What `comptime` Means

A Zig program runs in two stages.

Appendix H. Zig 0.16 Migration Notes

This appendix records the kinds of changes that matter when moving older Zig code to Zig 0.16. It is a practical checklist, not a full release history.

Chapter 9. The Optional Type

Sometimes a value may or may not exist.

Exercises

The programs in this chapter are small. They are meant to be changed, broken, rebuilt, and studied.

Appendix G. Common Compiler Errors

Zig tries to report errors at the point where the program becomes invalid. Many messages are direct: a value has the wrong type, a variable is unused, an error was ignored, or...

Chapter 8. Error Sets

Programs fail for many reasons. A file may not exist. Memory allocation may fail. Input may be malformed. A network connection may close unexpectedly.

A Word-Count Program

A useful program reads text and counts something.

Appendix F. C Interop Reference

One of Zig's central goals is direct interoperability with C. Zig can call C code, compile C code, link system libraries, export functions to C, and translate C headers.

Chapter 7. Struct Declarations

A struct is a type made from named fields.

Reading Command-Line Arguments

Programs often need input.

Appendix E. Build System Reference

Zig builds programs with Zig code. The build script is named:

Chapter 6. Fixed-Size Arrays

An array is a sequence of values of the same type.

A Small Calculator

A program can compute a value before it prints it.

Appendix D. Standard Library Map

The Zig standard library is imported as:

Chapter 5. Addresses and Pointer Types

A variable has a value. In Zig, a variable may also have an address.

Printing Values

The function std.debug.print writes text.

Appendix C. Builtin Functions

Builtin functions are part of the language. Their names begin with @.

Chapter 4. Defining Functions

A function groups statements into a single operation. Functions are the basic unit of organization in a Zig program.

Variables and Constants

A program works with values. In Zig, values are usually stored in constants or variables.

Appendix B. Operators and Precedence

This appendix lists the common operators by use. When an expression is not obvious, use parentheses.

Chapter 3. Blocks are Expressions

A block is a sequence of statements inside braces.

Build and Run

There are two common ways to run a small Zig program.

Appendix A. Zig Syntax Summary

This appendix is a quick map of Zig syntax. It is not a grammar. The full Zig grammar is part of the official language reference. Zig 0.16 also keeps the language small enough...

Chapter 2. Names and Declarations

A Zig program is made from declarations.

Hello, Zig

The first program in Zig is small.

Hello, Zig

The first program in Zig is small.

Chapter 1. Hello, Zig

The first program in Zig is small.

Appendix

Zig is a programming language for writing fast, small, reliable programs.

Part 24. Reading and Contributing to Zig

The Zig compiler is not only a compiler for the Zig language. It is also the center of the Zig toolchain.

Part 23. Real Projects

In this project, we will build a small command-line calculator.

Part 22. Cross-Platform Development

Windows is one of Zig’s main supported platforms. You can write Zig programs on Windows, build Windows executables, call Windows system APIs, link with C libraries, and...