zig

Writes › Book › Learn › Learn Zig › Appendix ›

Colophon

Colophon This book describes the Zig programming language as of Zig 0.16. The examples were written to stay small. Most fit on one screen. The intent was not to demonstrate every feature at once, but to show one idea clearly before introducing the next. Zig encourages direct programs: values have visible ownership allocation is explicit errors are explicit mutation is explicit control flow is explicit The language avoids hidden allocation,...

Writes › Book › Learn › Learn Zig › Appendix ›

Appendix J. Index

Appendix J. Index A addCSourceFile, 327 addExecutable, 318 addImport, 321 alignment, 78 allocators, 182 ArrayList, 252 arrays, 90 assembly, 364 atomics, 356 B blocks, 145 boolean operators, 286 build system, 311 build.zig, 311 builtins, 289 byte strings, 96 C @cImport, 346 casts, 294 catch, 132 C ABI, 344 C interop, 343 comments, 271 compile errors, 371 compile-time execution, 156 comptime, 156 const, 31 containers, 305 copyForwards, 251 cross compilation, 238...

Writes › Book › Learn › Learn Zig › Appendix ›

Appendix I. Exercise Answers

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. I.1 Hello, Zig Exercise 1-1. Run the first program. zig run main.zig Exercise 1-2. Change the message. const std = @import("std"); pub fn main() void { std.debug.print("goodbye\n", .{}); } Exercise 1-3. Print two lines. const std = @import("std"); pub fn main()...

Writes › Book › Learn › Learn Zig › Appendix ›

Appendix H. Zig 0.16 Migration Notes

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. H.1 Start With the Compiler Run the new compiler first. zig version zig build zig test src/main.zig Fix errors in this order: build script errors import and module errors standard library API errors type and builtin errors...

Writes › Book › Learn › Learn Zig › Appendix ›

Appendix G. Common Compiler Errors

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 memory rules were violated. This appendix lists common errors and the usual fix. G.1 Unused Local Constant error: unused local constant Example: const x = 10; Zig does not allow unused local declarations....

Writes › Book › Learn › Learn Zig › Appendix ›

Appendix F. C Interop Reference

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. This appendix gives the common forms. F.1 Calling a C Function A C function declaration uses extern . extern fn puts(s: [*:0]const u8) c_int; Use it like an ordinary Zig function. pub fn main() void {...

Writes › Book › Learn › Learn Zig › Appendix ›

Appendix E. Build System Reference

Appendix E. Build System Reference Zig builds programs with Zig code. The build script is named: build.zig Run it with: zig build A build script defines steps. A step may compile an executable, run tests, install an artifact, run a program, or perform another build action. E.1 Minimal Build Script const std = @import("std"); pub fn build(b: *std.Build) void { const exe = b.addExecutable(.{ .name = "hello", .root_source_file = b.path("src/main.zig"),...

Writes › Book › Learn › Learn Zig › Appendix ›

Appendix D. Standard Library Map

Appendix D. Standard Library Map The Zig standard library is imported as: const std = @import("std"); The library is organized as a tree of namespaces. Most programs use only a small part of it. This appendix lists the major areas and the names most commonly used in ordinary programs. D.1 Debug and Printing std.debug Printing: std.debug.print("{d}\n", .{123}); Assertions: std.debug.assert(x > 0); Panic: std.debug.panic("bad state", .{}); Useful names: std.debug.print std.debug.assert std.debug.panic...

Writes › Book › Learn › Learn Zig › Appendix ›

Appendix C. Builtin Functions

Appendix C. Builtin Functions Builtin functions are part of the language. Their names begin with @ . This appendix gives the common builtins by purpose. It is not a complete replacement for the language reference. C.1 Import and Type Information @import("std") @This() @TypeOf(x) @import loads a package or source file. const std = @import("std"); const math = @import("math.zig"); @This gives the current container type. const Node = struct { const...

Writes › Book › Learn › Learn Zig › Appendix ›

Appendix B. Operators and Precedence

Appendix B. Operators and Precedence This appendix lists the common operators by use. When an expression is not obvious, use parentheses. B.1 Field, Index, Call These bind tightly. x.y a[i] f(x) p.* Examples: const x = point.x; const first = items[0]; const n = len(items); const value = ptr.*; B.2 Address and Unary Operators &x !ok -x ~bits & takes an address. var x: i32 = 10; const p =...

Writes › Book › Learn › Learn Zig › Chapter 20. A Command-Line Parser ›

Appendix A. Zig Syntax Summary

Appendix A. Zig Syntax Summary This appendix summarizes the core syntax of Zig 0.16. It is a compact reference, not a tutorial. A.1 Comments Single-line comments begin with // . // this is a comment Documentation comments begin with /// . /// add two integers fn add(a: i32, b: i32) i32 { return a + b; } Container-level documentation comments begin with //! . //! small utility library A.2 Declarations...

Writes › Book › Learn › Learn Zig › Appendix ›

Appendix A. Zig Syntax Summary

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 that the grammar remains practical to read directly. A.1 Source Files A Zig source file is a container. It contains declarations. const std = @import("std"); const max_count = 100; fn add(a: i32,...

Writes › Book › Learn › Learn Zig › Chapter 20. A Command-Line Parser ›

Where to Go From Here

Where to Go From Here The programs in this chapter are small, but they have the shape of larger Zig programs. A command-line tool reads arguments, validates them, and calls ordinary functions. A file program opens resources, copies bytes, and closes everything with defer . A filter reads input in pieces and writes selected output. A network client treats the socket as a byte stream. A library exposes public declarations...

Writes › Book › Learn › Learn Zig › Chapter 18. Threads ›

A Parallel File Scanner

A Parallel File Scanner This section combines the ideas from the previous sections into one program structure. The program scans files in parallel. Several worker threads receive file paths from a queue. Each worker opens a file, reads it, and updates shared statistics. The design has four parts: Component Purpose job queue stores file paths worker threads process files shared state stores totals synchronization coordinates access The shared state is...

Writes › Book › Learn › Learn Zig › Chapter 20. A Command-Line Parser ›

demo

Packaging the Result A program is finished only when another machine can build and run it reliably. Packaging means organizing source code, build logic, tests, dependencies, documentation, and release artifacts into a form that others can use. A small Zig project usually begins like this: project/ build.zig build.zig.zon src/ main.zig build.zig describes how to build the project. build.zig.zon describes package metadata and dependencies. src/main.zig contains the program entry point. A...

Writes › Book › Learn › Learn Zig › Chapter 19. Undefined Behavior ›

Exercises

Exercises Exercise 19-1. Write a program that overflows a u8 using += . Run it in Debug mode and observe the panic. Exercise 19-2. Rewrite Exercise 19-1 using +%= . Verify that the value wraps to zero. Exercise 19-3. Declare an array with three elements and intentionally access index 3 . Observe the runtime behavior in Debug mode. Exercise 19-4. Declare a variable with undefined , assign a value later,...

Writes › Book › Learn › Learn Zig › Chapter 18. Threads ›

Designing Concurrent Programs

Designing Concurrent Programs Threads are a mechanism, not a design. A program should not begin with the question, “How many threads do I need?” It should begin with the data. Ask first: What data exists? Who owns it? Which thread may change it? Which thread may read it? How does one thread notify another? Most concurrency bugs come from unclear ownership. A simple rule is useful: one thread should own...

Writes › Book › Learn › Learn Zig › Chapter 20. A Command-Line Parser ›

Benchmarking

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. Small changes in allocation, copying, parsing, or cache behavior can change performance significantly. Zig keeps these operations visible, which makes benchmarking straightforward. Suppose we want to measure two ways of summing integers in an array. The first version uses indexing. fn...

Writes › Book › Learn › Learn Zig › Chapter 19. Undefined Behavior ›

FFI Safety

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. Most often, this means C. Zig can call C functions directly. const c = @cImport({ @cInclude("stdio.h"); }); pub fn main() void { _ = c.puts("hello from C"); } @cImport asks Zig to import C declarations. @cInclude includes a C header. The call: c.puts("hello from C");...

Writes › Book › Learn › Learn Zig › Chapter 18. Threads ›

Semaphores

Semaphores A semaphore is a counter used for synchronization. Threads may increase the counter or wait until the counter becomes positive. A semaphore is useful when: a limited number of resources exist threads must wait for available work access should be restricted to a fixed capacity Unlike a mutex, a semaphore does not protect one critical section owned by one thread. A mutex is either locked or unlocked. A semaphore...

Writes › Book › Learn › Learn Zig › Chapter 17. Target Triples ›

Exercises

Exercises This section collects the chapter exercises into one working set. Exercise 17-1. Run: zig targets Find five architectures and five operating systems in the output. Exercise 17-2. Compile the same program for your native target and for Linux x86-64: zig build-exe main.zig zig build-exe main.zig -target x86_64-linux-gnu Exercise 17-3. Print the architecture and operating system: const std = @import("std"); const builtin = @import("builtin"); pub fn main() void { std.debug.print("arch...

Writes › Book › Learn › Learn Zig › Chapter 16. Calling C ›

Exercises

Exercises Exercise 16-1. Write a C file containing this function: int add(int a, int b) { return a + b; } Write a Zig program that declares it with extern fn , calls it, and prints the result. Exercise 16-2. Rewrite Exercise 16-1 using a header file and @cImport . Exercise 16-3. Write a C function: void greet(const char *name); Call it from Zig. Use the correct Zig type for...

Writes › Book › Learn › Learn Zig › Chapter 20. A Command-Line Parser ›

Testing Strategy

Testing Strategy Tests should be close to the code they check. Zig makes this easy with test blocks. const std = @import("std"); fn add(a: i32, b: i32) i32 { return a + b; } test "add positive numbers" { try std.testing.expectEqual(@as(i32, 30), add(10, 20)); } Run it: zig test main.zig A test block has a name and a body. test "add positive numbers" { ... } The body is ordinary...

Writes › Book › Learn › Learn Zig › Chapter 19. Undefined Behavior ›

Packed Memory

Packed Memory A normal struct is laid out for efficient access. const Point = struct { x: u8, y: u32, }; The compiler may place padding between fields. Padding is unused space inserted to satisfy alignment. A u32 is usually aligned more strictly than a u8 . Therefore this struct may occupy more than five bytes. Packed memory uses an exact bit layout. const Point = packed struct { x:...

Writes › Book › Learn › Learn Zig › Chapter 18. Threads ›

Thread Pools

Thread Pools Creating a thread is expensive. A thread needs: operating system resources stack memory scheduler state Programs that create thousands of short-lived threads often spend more time managing threads than doing useful work. A thread pool solves this problem. A thread pool creates a fixed set of worker threads once. Work items are placed into a queue. Workers repeatedly take work from the queue and execute it. The model...

Writes › Book › Learn › Learn Zig › Chapter 17. Target Triples ›

Release Modes

Release Modes Zig can build the same source code in different optimization modes. The mode controls speed, size, safety checks, and debug information. The four common modes are: Mode Main purpose Debug Fast compilation, safety checks, useful debug info ReleaseSafe Optimized code with safety checks ReleaseFast Optimized code for speed ReleaseSmall Optimized code for small size With zig build-exe , the default is Debug . zig build-exe main.zig To select...

Writes › Book › Learn › Learn Zig › Chapter 16. Calling C ›

ABI and Layout

ABI and Layout A C program and a Zig program can share data only when both sides agree on layout. Layout means the exact order, size, alignment, and padding of values in memory. C code does not see Zig types. It sees bytes at addresses. If the bytes do not have the shape C expects, the program is wrong. For simple integer and floating-point values, use C-compatible types: c_char c_short...

Writes › Book › Learn › Learn Zig › Chapter 15. `zig build` ›

Exercises

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. Exercise 15-33 Create this project layout: project/ ├── build.zig ├── build.zig.zon ├── src/ │ └── main.zig └── examples/ └── hello.zig Build the executable with: zig build Run the example with: zig build run-example Exercise 15-34 Add these build steps: check run...

Writes › Book › Learn › Learn Zig › Chapter 15. `zig build` ›

Cross Builds

Cross Builds Zig can build for a different target than the machine running the compiler. The target is chosen with -Dtarget when the build file uses the standard target option: const target = b.standardTargetOptions(.{}); An executable should receive that target through its root module: const exe = b.addExecutable(.{ .name = "demo", .root_module = b.createModule(.{ .root_source_file = b.path("src/main.zig"), .target = target, .optimize = optimize, }), }); Now the same project can...

Writes › Book › Learn › Learn Zig › Chapter 15. `zig build` ›

Dependencies

Dependencies A Zig package may depend on another package. Dependencies are declared in build.zig.zon . The build script then imports them by name. A small build.zig.zon file looks like this: .{ .name = .demo, .version = "0.1.0", .dependencies = .{}, .paths = .{ "build.zig", "build.zig.zon", "src", }, } The .paths field says which files belong to the package. Keep it narrow. Do not publish temporary files, build output, editor state,...

Writes › Book › Learn › Learn Zig › Chapter 15. `zig build` ›

Examples

Examples Examples are small programs kept inside the project. They show how the code is meant to be used. They also check that public APIs still compile. A common layout is: project/ ├── build.zig ├── src/ │ └── root.zig └── examples/ ├── hello.zig └── copy.zig An example is an ordinary Zig program: const std = @import("std"); const mylib = @import("mylib"); pub fn main() !void { std.debug.print("{s}\n", .{mylib.message()}); } The build...

Writes › Book › Learn › Learn Zig › Chapter 14. `std.debug` ›

Exercises

Exercises This section collects the exercises for Chapter 14. Exercise 14-1. Print the integer 255 in decimal, hexadecimal, and binary. Exercise 14-2. Define a struct named Point with fields x and y . Print a value of this type with {any} . Exercise 14-3. Write a program that uses std.debug.assert to check that a value is greater than zero. Exercise 14-4. Write normal output to standard output and diagnostic output...

Writes › Book › Learn › Learn Zig › Chapter 14. `std.debug` ›

Testing Utilities

Testing Utilities Zig has built-in support for tests. A test is declared with the test keyword. const std = @import("std"); test "addition" { try std.testing.expect(1 + 1 == 2); } Run the file with: zig test main.zig If the condition is true, the test passes. If the condition is false, the test fails. std.testing.expect checks a boolean expression. try std.testing.expect(x == y); It returns an error when the expression is...

Writes › Book › Learn › Learn Zig › Chapter 14. `std.debug` ›

Process APIs

Process APIs The standard library gives access to process information through std.process . A process can inspect its command-line arguments. const std = @import("std"); pub fn main() !void { var args = try std.process.argsWithAllocator(std.heap.page_allocator); defer args.deinit(); while (args.next()) |arg| { std.debug.print("{s}\n", .{arg}); } } Run it: zig run main.zig -- one two three The output is similar to: /path/to/main one two three The first argument is the program name. The...

Writes › Book › Learn › Learn Zig › Chapter 13. Files ›

Exercises

Exercises This section collects the exercises for the chapter. They are small on purpose. Each one should test one rule about files, streams, buffers, or errors. Exercise 13-1. Open a file named message.txt and print its contents. Exercise 13-2. Change the program so the filename comes from the command line. Exercise 13-3. If the file cannot be opened, print an error message to standard error. Exercise 13-4. Count the number...

Writes › Book › Learn › Learn Zig › Chapter 13. Files ›

Zig 0.16 I/O Changes

Zig 0.16 I/O Changes Zig 0.16 changes how I/O code is written in the standard library. Older Zig examples often use this form: const stdout = std.io.getStdOut(); try stdout.writer().print( "hello, {s}\n", .{"zig"}, ); In Zig 0.16, much of this code moves through the newer std.Io API. The names are shorter, and the model is more explicit about readers, writers, and buffers. A simple program still has the same purpose: const...

Writes › Book › Learn › Learn Zig › Chapter 14. `std.debug` ›

Filesystem APIs

Filesystem APIs The standard library gives access to files and directories through std.fs . A small program can open a file and read its contents. const std = @import("std"); pub fn main() !void { const file = try std.fs.cwd().openFile("notes.txt", .{}); defer file.close(); var buffer: [1024]u8 = undefined; const n = try file.readAll(buffer[0..]); std.debug.print("{s}", .{buffer[0..n]}); } std.fs.cwd() returns a handle to the current working directory. std.fs.cwd() A directory handle is used...

Writes › Book › Learn › Learn Zig › Chapter 13. Files ›

Error Handling in I/O

Error Handling in I/O Input and output can fail. A file may not exist. A disk may be full. A directory may be missing. A program may not have permission to read or write. A pipe may be closed by the program on the other end. Zig makes these cases part of the type. pub fn main() !void { const cwd = std.fs.cwd(); const file = try cwd.openFile("input.txt", .{}); defer...

Writes › Book › Learn › Learn Zig › Chapter 20. A Command-Line Parser ›

A Static Library

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 script exposes it. We will make a small library named mathx . It has one source file: src/mathx.zig pub fn add(a: i32, b: i32) i32 { return a + b; } pub...

Writes › Book › Learn › Learn Zig › Chapter 19. Undefined Behavior ›

Volatile Memory

Volatile Memory Most memory in a program behaves normally. If a value is written: x = 10; and then immediately overwritten: x = 20; the compiler may remove the first write because it has no observable effect. This is an important optimization. But some memory locations are special. A write to a hardware register may start a device. A read from a status register may clear a flag. A memory...

Writes › Book › Learn › Learn Zig › Chapter 18. Threads ›

Async Status in Zig 0.16

Async Status in Zig 0.16 Zig once had async functions as a language feature. In Zig 0.16, async function syntax is not part of the stable language model. Code should not be built around old examples that use: async await suspend resume For ordinary programs, use one of these instead: Need Use Run work in parallel std.Thread Protect shared state std.Thread.Mutex Wait for state changes std.Thread.Condition Count or signal resources...

Writes › Book › Learn › Learn Zig › Chapter 17. Target Triples ›

Static and Dynamic Linking

Static and Dynamic Linking A program is made from object code. Some object code comes from your Zig files. Some may come from the standard library. Some may come from C libraries, system libraries, or other compiled files. Linking combines those pieces into one result. There are two common forms: static linking dynamic linking With static linking, library code is copied into the final executable. With dynamic linking, the executable...

Writes › Book › Learn › Learn Zig › Chapter 16. Calling C ›

Calling Zig from C

Calling Zig from C C can call Zig when the Zig function is exported with a C-compatible ABI. The Zig function: export fn add(a: c_int, b: c_int) c_int { return a + b; } export makes the symbol visible outside the Zig object file. The parameter and return types use C-compatible integer types, so C can call the function safely. Put this in math.zig : export fn add(a: c_int, b:...

Writes › Book › Learn › Learn Zig › Chapter 15. `zig build` ›

Tests

Tests Zig has tests in the language. A test is written with the test keyword: const std = @import("std"); fn add(a: i32, b: i32) i32 { return a + b; } test "add two numbers" { try std.testing.expect(add(2, 3) == 5); } Run it directly: zig test src/main.zig In a project, tests are usually run through zig build . A test step looks like this: const tests = b.addTest(.{ .root_module...

Writes › Book › Learn › Learn Zig › Chapter 14. `std.debug` ›

Formatting

Formatting Zig uses format strings to turn values into text. The simplest form is std.debug.print . const std = @import("std"); pub fn main() void { std.debug.print("{s} {d}\n", .{ "zig", 16 }); } The output is: zig 16 The first argument is the format string. "{s} {d}\n" The second argument is a tuple of values. .{ "zig", 16 } Each placeholder in the format string consumes one value. {s} prints string...

Writes › Book › Learn › Learn Zig › Chapter 13. Files ›

Standard Input and Output

Standard Input and Output A program usually has three standard streams: standard input standard output standard error Standard input is where the program reads ordinary input. Standard output is where it writes ordinary output. Standard error is where it writes diagnostics. In Zig: const stdin = std.io.getStdIn(); const stdout = std.io.getStdOut(); const stderr = std.io.getStdErr(); These values are file-like handles. A small program can read from standard input and write...

Writes › Book › Learn › Learn Zig › Chapter 12. Why Allocation Is Explicit ›

Exercises

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. Exercise 12-25. Allocate a slice of 16 u8 values with std.heap.page_allocator . Fill it with zeroes. Print its length. Free it before the program exits. Exercise 12-26. Allocate a slice of 8 i32 values. Store the values 0 through 7 in it. Print the slice...

Writes › Book › Learn › Learn Zig › Chapter 12. Why Allocation Is Explicit ›

Ownership Rules

Ownership Rules Allocation creates a responsibility. The program that owns allocated memory must release it. Zig does not guess who owns memory. Ownership must be visible from the code. A common rule is simple: The function that allocates memory frees it in the same scope. const std = @import("std"); pub fn main() !void { const allocator = std.heap.page_allocator; const bytes = try allocator.alloc(u8, 128); defer allocator.free(bytes); @memset(bytes, 0); std.debug.print("{d}\n", .{bytes.len});...

Writes › Book › Learn › Learn Zig › Chapter 12. Why Allocation Is Explicit ›

Fixed-Buffer Allocator

Fixed-Buffer Allocator A fixed-buffer allocator uses memory that already exists. It does not request memory from the operating system. Instead, allocations come from a fixed block supplied by the program. This is useful in embedded systems, kernels, bootloaders, games, temporary workspaces, and programs that must avoid heap allocation. A fixed-buffer allocator begins with a buffer: var buffer: [1024]u8 = undefined; The allocator uses this memory for future allocations. A complete...

Writes › Book › Learn › Learn Zig › Chapter 12. Why Allocation Is Explicit ›

Arena Allocator

Arena Allocator An arena allocator is used when many allocations have the same lifetime. Instead of freeing each object one by one, the program frees the whole arena at once. This is useful for parsers, compilers, request handlers, temporary buffers, and short-lived workspaces. A small arena example: const std = @import("std"); pub fn main() !void { var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator); defer arena.deinit(); const allocator = arena.allocator(); const a = try...

Writes › Book › Learn › Learn Zig › Chapter 19. Undefined Behavior ›

Integer Overflow

Integer Overflow An integer type can store only a fixed range of values. For example: Type Range u8 0 to 255 i8 -128 to 127 u16 0 to 65535 When a calculation produces a value outside the range of the type, overflow occurs. In Zig, ordinary arithmetic checks for overflow in safe build modes. const std = @import("std"); pub fn main() void { var x: u8 = 255; x +=...

Writes › Book › Learn › Learn Zig › Chapter 20. A Command-Line Parser ›

A Tiny HTTP Client

A Tiny HTTP Client An HTTP client opens a network connection, sends a request, receives a response, and writes the response body. We will build a small program named get . get example.com / It will send this HTTP request: GET / HTTP/1.1 Host: example.com Connection: close Here is the first version. const std = @import("std"); pub fn main() !void { var args = std.process.args(); _ = args.next(); const host...

Writes › Book › Learn › Learn Zig › Chapter 18. Threads ›

Condition Variables

Condition Variables A mutex protects shared data. A condition variable allows threads to wait for a change in that data. The usual pattern is: lock a mutex check a condition sleep until the condition changes wake up and check again A producer and consumer example shows the idea. const std = @import("std"); const State = struct { mutex: std.Thread.Mutex = .{}, condition: std.Thread.Condition = .{}, ready: bool = false, value:...

Writes › Book › Learn › Learn Zig › Chapter 17. Target Triples ›

libc and Freestanding Builds

libc and Freestanding Builds A Zig target may use a C library, or it may use none. These two targets are both Linux: x86_64-linux-gnu x86_64-linux-musl The difference is the ABI. gnu means the program is built for glibc. musl means the program is built for musl libc. A third target has no C library: x86_64-linux-none Here the ABI is none . The C library matters when the program calls C...

Writes › Book › Learn › Learn Zig › Chapter 16. Calling C ›

Linking Libraries

Linking Libraries Calling a C function is only half the job. The linker must also find the code for that function. A C declaration tells Zig what exists: extern fn add(a: c_int, b: c_int) c_int; But the declaration does not contain the function body. The body must come from a C source file, an object file, a static library, a shared library, or the system C library. The smallest case...

Writes › Book › Learn › Learn Zig › Chapter 15. `zig build` ›

Build Options

Build Options A build option is a value passed to build.zig from the command line. Build options let one build file describe several related builds. The user chooses the variant without editing source code. The usual form is: zig build -Dname=value For example: zig build -Dtrace=true Inside build.zig , the option is read with b.option : const trace = b.option(bool, "trace", "Enable trace output") orelse false; The first argument is...

Writes › Book › Learn › Learn Zig › Chapter 14. `std.debug` ›

Hash Maps

Hash Maps A hash map stores key-value pairs. Given a key, the map quickly finds the associated value. The standard library provides several hash map types. The most commonly used is std.HashMap . A simple example counts words. const std = @import("std"); pub fn main() !void { var gpa = std.heap.GeneralPurposeAllocator(.{}){}; defer _ = gpa.deinit(); const allocator = gpa.allocator(); var map = std.StringHashMap(u32).init(allocator); defer map.deinit(); try map.put("red", 1); try map.put("green",...

Writes › Book › Learn › Learn Zig › Chapter 13. Files ›

Buffered I/O

Buffered I/O Reading or writing one byte at a time is expensive. Each filesystem operation may require a system call. System calls are much slower than ordinary memory access. Programs that read or write small pieces of data usually collect bytes in memory first. This technique is called buffering. A buffered reader fetches a large block of bytes from the operating system, then serves smaller reads from memory. A buffered...

Writes › Book › Learn › Learn Zig › Chapter 12. Why Allocation Is Explicit ›

General-Purpose Allocator

General-Purpose Allocator The general-purpose allocator is used for ordinary heap allocation. It is designed for programs that allocate and free many objects of different sizes. A typical program sets it up near main : const std = @import("std"); pub fn main() !void { var gpa = std.heap.GeneralPurposeAllocator(.{}){}; defer _ = gpa.deinit(); const allocator = gpa.allocator(); const bytes = try allocator.alloc(u8, 128); defer allocator.free(bytes); @memset(bytes, 0); std.debug.print("allocated {d} bytes\n", .{bytes.len}); }...

Writes › Book › Learn › Learn Zig › Chapter 11. Generic Functions ›

Exercises

Exercises Exercise 11-1. Write a generic min function for values that support < . fn min(a: anytype, b: @TypeOf(a)) @TypeOf(a) Return the smaller value. Test it with: i32 u64 f64 Exercise 11-2. Write a generic swap function. The function should exchange two values using pointers. fn swap(a: anytype, b: anytype) void Test it with integers and floating-point values. Exercise 11-3. Write a generic max3 function. fn max3(a: anytype, b: @TypeOf(a),...

Writes › Book › Learn › Learn Zig › Chapter 11. Generic Functions ›

Compile-Time Dispatch

Compile-Time Dispatch Generic functions in Zig are specialized at compile time. When a generic function is called with concrete types, the compiler generates a version of the function for those types. The selection happens during compilation, not at runtime. Consider this function: const std = @import("std"); fn square(x: anytype) @TypeOf(x) { return x * x; } pub fn main() void { const a = square(4); const b = square(2.5); std.debug.print("{d}\n",...

Writes › Book › Learn › Learn Zig › Chapter 11. Generic Functions ›

Interfaces by Convention

Interfaces by Convention Zig has no built-in interface keyword. Instead, interfaces are formed by agreement between code that calls operations and code that provides them. A type satisfies an interface if it contains the expected declarations with compatible behavior. This is sometimes called structural typing, but Zig implements it through ordinary compile-time checking. Consider a simple example. const std = @import("std"); const ConsoleWriter = struct { pub fn write(self: *ConsoleWriter,...

Writes › Book › Learn › Learn Zig › Chapter 20. A Command-Line Parser ›

A Line Filter

A Line Filter A line filter reads text, changes or selects some lines, and writes the result. Many Unix programs have this shape. This program prints only the lines that contain a given word. filter needle input.txt Here is a first version. const std = @import("std"); pub fn main() !void { var args = std.process.args(); _ = args.next(); const needle = args.next() orelse { std.debug.print("missing search text\n", .{}); return; };...

Writes › Book › Learn › Learn Zig › Chapter 19. Undefined Behavior ›

Pointer Casts

Pointer Casts A pointer has a type. var x: i32 = 10; const p: *i32 = &x; Here p points to an i32 . The type *i32 says three things: It points to memory. That memory is treated as an i32 . The address must be valid for an i32 , including alignment. Most pointer conversions should be avoided. They make the program depend on memory layout. Sometimes they are...

Writes › Book › Learn › Learn Zig › Chapter 18. Threads ›

Atomics

Atomics A mutex makes one thread wait while another thread uses shared data. An atomic operation is different. It performs one small memory operation as a single indivisible step. A counter is the usual example. const std = @import("std"); var counter = std.atomic.Value(u32).init(0); fn increment() void { var i: u32 = 0; while (i < 100000) : (i += 1) { _ = counter.fetchAdd(1, .monotonic); } } pub fn main()...

Writes › Book › Learn › Learn Zig › Chapter 17. Target Triples ›

CPU Architectures

CPU Architectures The architecture part of a target tells Zig what kind of processor the program will run on. In this target: x86_64-linux-gnu the architecture is: x86_64 In this target: aarch64-linux-musl the architecture is: aarch64 In this target: wasm32-freestanding-none the architecture is: wasm32 The architecture affects instruction encoding, register names, calling convention, pointer size, alignment, atomic operations, and available CPU features. A program can inspect its architecture at compile time:...

Writes › Book › Learn › Learn Zig › Chapter 16. Calling C ›

Header Translation

Header Translation @cImport does two jobs. It asks the C compiler front end to read a header, and it asks Zig to translate the visible C declarations into Zig declarations. For this C header: #ifndef MATHLIB_H #define MATHLIB_H int add(int a, int b); double mean(double a, double b); #endif Zig can import it: const c = @cImport({ @cInclude("mathlib.h"); }); The declarations are then used through c : const std =...

Writes › Book › Learn › Learn Zig › Chapter 15. `zig build` ›

Build Steps

Build Steps A build file describes steps. A step is one action in the build graph. It may compile a program, install a file, run a command, generate source, or group other steps under a name. The default build has an install step. This is why a simple project can be built with: zig build The command runs the default step, and that step depends on the artifacts that must...

Writes › Book › Learn › Learn Zig › Chapter 14. `std.debug` ›

`std.ArrayList`

std.ArrayList std.ArrayList is a growable array. Use it when the number of elements is not known at compile time. const std = @import("std"); pub fn main() !void { var gpa = std.heap.GeneralPurposeAllocator(.{}){}; defer _ = gpa.deinit(); const allocator = gpa.allocator(); var list = std.ArrayList(u8).init(allocator); defer list.deinit(); try list.append(10); try list.append(20); try list.append(30); std.debug.print("{any}\n", .{list.items}); } The output is: { 10, 20, 30 } An ArrayList(T) stores values of type T...

Writes › Book › Learn › Learn Zig › Chapter 13. Files ›

Writing Bytes

Writing Bytes Writing bytes is the opposite of reading them. The simplest write operation takes a slice and sends its contents to a file or stream. try file.writeAll(bytes); writeAll continues writing until every byte has been written or an error occurs. A complete example: const std = @import("std"); pub fn main() !void { const cwd = std.fs.cwd(); const file = try cwd.createFile( "output.txt", .{}, ); defer file.close(); const message =...

Writes › Book › Learn › Learn Zig › Chapter 12. Why Allocation Is Explicit ›

Page Allocator

Page Allocator The page allocator gets memory from the operating system. It is available as: std.heap.page_allocator A page is a block of memory managed by the operating system. The exact size depends on the target. Common systems use pages of 4096 bytes, but a program should not depend on that unless it has checked the target. The page allocator is simple to use: const std = @import("std"); pub fn main()...

Writes › Book › Learn › Learn Zig › Chapter 11. Generic Functions ›

Type Constraints by Use

Type Constraints by Use Zig does not have a formal trait or interface system. Instead, generic code is constrained by the operations it performs. A type is valid if the required operations exist for that type. Consider this function: fn add(a: anytype, b: @TypeOf(a)) @TypeOf(a) { return a + b; } This function does not explicitly require numeric types. Instead, it assumes the + operator is valid. These calls work:...

Writes › Book › Learn › Learn Zig › Chapter 10. What `comptime` Means ›

Exercises

Exercises Write a program that computes several Fibonacci numbers with comptime . Print the results at runtime. Rewrite this declaration so the value is computed during compilation: const x = 10 * 20; Explain why this code is invalid: var n: usize = 4; const a = comptime n * 2; Write a function: fn square(x: i32) i32 Call it both at runtime and with comptime . Write a generic...

Writes › Book › Learn › Learn Zig › Chapter 20. A Command-Line Parser ›

A File Copier

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. The command will look like this: copy source.txt output.txt Here is a complete first version. const std = @import("std"); pub fn main() !void { var args = std.process.args(); _ = args.next(); const src_path = args.next() orelse { std.debug.print("missing source...

Writes › Book › Learn › Learn Zig › Chapter 19. Undefined Behavior ›

Safety Checks

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 mistake happens. Array indexing is checked. const std = @import("std"); pub fn main() void { const a = [_]u8{ 1, 2, 3 }; std.debug.print("{d}\n", .{a[3]}); } The array has indexes 0 , 1 , and 2 . Index 3...

Writes › Book › Learn › Learn Zig › Chapter 18. Threads ›

Mutexes

Mutexes A mutex is a lock for shared data. Only one thread may hold a mutex at a time. If another thread tries to lock it, that thread waits. A mutex is used when several threads must read or change the same value. const std = @import("std"); var counter: u32 = 0; var mutex = std.Thread.Mutex{}; fn increment() void { var i: u32 = 0; while (i < 100000) :...

Writes › Book › Learn › Learn Zig › Chapter 17. Target Triples ›

Operating Systems

Operating Systems The operating system part of a target tells Zig what kind of system the program will run on. In this target: x86_64-linux-gnu the operating system is: linux In this target: aarch64-macos-none the operating system is: macos In this target: wasm32-freestanding-none the operating system is: freestanding The operating system affects many things: executable format, system calls, file paths, dynamic libraries, threads, environment variables, and process startup. A program can...

Writes › Book › Learn › Learn Zig › Chapter 16. Calling C ›

`@cImport`

@cImport Writing every C declaration by hand is tedious. Zig can read C headers directly. The usual form is: const c = @cImport({ @cInclude("stdio.h"); }); This creates a namespace named c . Declarations from the C header are available through that namespace. A complete program: const c = @cImport({ @cInclude("stdio.h"); }); pub fn main() void { _ = c.puts("hello from C"); } Run it: zig run main.zig -lc The call:...

Writes › Book › Learn › Learn Zig › Chapter 15. `zig build` ›

`build.zig`

build.zig The file build.zig is a Zig program. It is not a configuration file. It is not a list of compiler flags. It is code that constructs a build graph. A minimal file has one public function: const std = @import("std"); pub fn build(b: *std.Build) void { _ = b; } The build system looks for this function: pub fn build(b: *std.Build) void The name must be build . The...

Writes › Book › Learn › Learn Zig › Chapter 14. `std.debug` ›

`std.mem`

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 . A simple example copies bytes from one array into another. const std = @import("std"); pub fn main() void { var source = [_]u8{ 1, 2, 3, 4 }; var dest = [_]u8{ 0, 0, 0, 0 }; @memcpy(dest[0..], source[0..]); std.debug.print("{any}\n", .{dest}); } The output is: { 1,...

Writes › Book › Learn › Learn Zig › Chapter 13. Files ›

Reading Bytes

Reading Bytes A file is read as bytes. The simplest read call takes a buffer and returns the number of bytes placed in it. const n = try file.read(&buffer); The buffer may be larger than the data that was read. The value n tells which part is valid. const bytes = buffer[0..n]; A complete program: const std = @import("std"); pub fn main() !void { const cwd = std.fs.cwd(); const file...

Writes › Book › Learn › Learn Zig › Chapter 12. Why Allocation Is Explicit ›

The Allocator Interface

The Allocator Interface An allocator is a value that knows how to allocate and free memory. In Zig, allocator-using code normally receives an allocator as an argument: fn readFile(allocator: std.mem.Allocator, path: []const u8) ![]u8 This function does not choose the allocation policy. The caller chooses it. That makes the function more general. It can be used with a page allocator, an arena allocator, a fixed-buffer allocator, or a testing allocator....

Writes › Book › Learn › Learn Zig › Chapter 11. Generic Functions ›

Generic Structs

Generic Structs A generic struct is a function that returns a type. This is one of the most important ideas in Zig. Types are values known at compile time, so a function can construct and return new types. Here is a small stack implementation: const std = @import("std"); fn Stack(comptime T: type) type { return struct { const Self = @This(); items: []T, len: usize, pub fn push(self: *Self, value:...

Writes › Book › Learn › Learn Zig › Chapter 10. What `comptime` Means ›

Generating Declarations

Generating Declarations A Zig function can return a type. That type can contain fields, constants, and functions. This is how Zig writes many generic containers. fn Box(comptime T: type) type { return struct { value: T, }; } Use it like this: const IntBox = Box(i32); var b = IntBox{ .value = 123, }; Box(i32) returns a struct type. The returned type has one field: value: i32 Calling the same...

Writes › Book › Learn › Learn Zig › Chapter 20. A Command-Line Parser ›

A Command-Line Parser

A Command-Line Parser Many programs begin the same way: they read command-line arguments, decide what the user requested, then execute an operation. A command-line parser converts raw argument strings into structured program state. Suppose we want a small utility named calc . It accepts two subcommands: calc add 10 20 calc mul 4 5 The first version can be written directly. const std = @import("std"); pub fn main() !void {...

Writes › Book › Learn › Learn Zig › Chapter 19. Undefined Behavior ›

Undefined Behavior

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 dangerous. An operation whose result is not defined by the language is called undefined behavior. Undefined behavior means the compiler is allowed to assume the operation never happens. If it does happen, the result is unpredictable. The program may crash. It may appear...

Writes › Book › Learn › Learn Zig › Chapter 10. What `comptime` Means ›

Reflection

Reflection Reflection means inspecting a type from inside the program. In Zig, reflection happens at compile time. The main builtin is: @typeInfo(T) T must be a type known at compile time. A small example: const std = @import("std"); fn describe(comptime T: type) void { switch (@typeInfo(T)) { .int => std.debug.print("integer\n", .{}), .float => std.debug.print("float\n", .{}), .bool => std.debug.print("boolean\n", .{}), .pointer => std.debug.print("pointer\n", .{}), .@"struct" => std.debug.print("struct\n", .{}), else => std.debug.print("other\n",...

Writes › Book › Learn › Learn Zig › Chapter 18. Threads ›

Threads

Threads A thread is an independent flow of execution. A Zig program begins with one thread: the main thread. Additional threads may be created to perform work in parallel. A thread runs a function. Here is the smallest useful example: const std = @import("std"); fn worker() void { std.debug.print("worker thread\n", .{}); } pub fn main() !void { const thread = try std.Thread.spawn(.{}, worker, .{}); thread.join(); } Run it: zig run...

Writes › Book › Learn › Learn Zig › Chapter 17. Target Triples ›

Target Triples

Target Triples One of Zig's main design goals is cross compilation. A Zig compiler running on one machine can produce programs for many other operating systems and processors without installing a separate toolchain. You can build a Linux executable on macOS. You can build for ARM on x86-64. You can build freestanding binaries for systems with no operating system at all. The target is selected with a target triple. A...

Writes › Book › Learn › Learn Zig › Chapter 10. What `comptime` Means ›

Inline Loops

Inline Loops A normal loop runs while the program runs. An inline loop is expanded while the program is compiled. inline for (.{ 1, 2, 3 }) |n| { std.debug.print("{d}\n", .{n}); } This is close to writing: std.debug.print("{d}\n", .{1}); std.debug.print("{d}\n", .{2}); std.debug.print("{d}\n", .{3}); The loop itself does not exist at runtime in the same way. The compiler uses the loop to generate repeated code. Inline loops are most useful when...

Writes › Book › Learn › Learn Zig › Chapter 16. Calling C ›

Calling C

Calling C One of Zig's design goals is direct interoperability with C. A Zig program can call C functions without wrapper generators, external build tools, or foreign function interfaces layered on top of the language. Zig understands C calling conventions, C data layout, and C header files directly. A small example is enough to begin. Suppose we have this C source file: #include <stdio.h> void greet(const char *name) { printf("hello,...

Writes › Book › Learn › Learn Zig › Chapter 15. `zig build` ›

`zig build`

zig build Large programs are rarely built with a single compiler command. A program may contain many source files. It may need tests, examples, generated files, libraries, or platform-specific options. Typing long command lines by hand quickly becomes tedious. Zig solves this with a build system written in Zig itself. Most Zig projects contain a file named build.zig . The zig build command reads this file and executes the build...

Writes › Book › Learn › Learn Zig › Chapter 10. What `comptime` Means ›

Types as Values

Types as Values In Zig, a type is a value. This is one of the most important ideas behind compile-time programming. A type can be passed to a function, stored in a constant, compared, and returned from a function. The special type named type represents all types. const T: type = i32; Here T is a value known at compile time. Its value is the type i32 . A function...

Writes › Book › Learn › Learn Zig › Chapter 9. The Optional Type ›

Exercises

Exercises Exercise 9-17. Declare an optional integer. const x: ?i32 = 10; Change it to null . const x: ?i32 = null; Print both forms with {any} . Exercise 9-18. Write a function firstPositive that returns the first positive number in a slice. fn firstPositive(values: []const i32) ?i32 { for (values) |v| { if (v > 0) { return v; } } return null; } Test it with: const a...

Writes › Book › Learn › Learn Zig › Chapter 14. `std.debug` ›

`std.debug`

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. A small example: const std = @import("std"); pub fn main() void { std.debug.print("hello, zig\n", .{}); } std.debug.print takes two arguments: std.debug.print(format, values); The first argument is a format string. The second is a tuple containing values to insert into the format string. For example: const std...

Writes › Book › Learn › Learn Zig › Chapter 9. The Optional Type ›

Optionals Versus Errors

Optionals Versus Errors Optionals and errors both describe a value that may not be produced. They mean different things. An optional means absence. ?usize This says: there may be a usize , or there may be no value An error union means failure. error{Invalid}!usize This says: there may be a usize , or the operation may fail with Invalid Use an optional when no value is a normal result. Use...

Writes › Book › Learn › Learn Zig › Chapter 13. Files ›

Files

Files Most programs spend their time moving bytes. They read files, transform data, and write results somewhere else. Zig exposes these operations directly. There is no hidden runtime. A file is an operating system resource, and Zig's standard library provides functions that work close to the system interface. This chapter begins with the simplest possible file operation: opening a file and reading its contents. const std = @import("std"); pub fn...

Writes › Book › Learn › Learn Zig › Chapter 10. What `comptime` Means ›

Compile-Time Parameters

Compile-Time Parameters A function parameter can be marked comptime . fn repeat(comptime n: usize, value: u8) [n]u8 { var out: [n]u8 = undefined; for (&out) |*item| { item.* = value; } return out; } Here n is not an ordinary parameter. It must be known while the program is being compiled. This call is valid: const a = repeat(4, 'x'); The compiler sees n == 4 , so the return...

Writes › Book › Learn › Learn Zig › Chapter 9. The Optional Type ›

Optional Pointers

Optional Pointers Pointers are often optional. A search may not find an object. A tree node may not have a parent. A linked list node may not have a next node. In Zig, this is written explicitly: ?*i32 This means: either a pointer to i32 , or null A normal pointer: *i32 cannot be null. This difference matters. Here is a simple example: const std = @import("std"); pub fn main()...

Writes › Book › Learn › Learn Zig › Chapter 12. Why Allocation Is Explicit ›

Why Allocation Is Explicit

Why Allocation Is Explicit A program uses memory to store values. Some values live for the entire execution of the program. Others exist only while a function runs. Some must grow while the program is running. Some must be shared between different parts of the program. Zig does not hide memory allocation behind the language. Allocation is explicit. This is one of the central design choices of Zig. In some...

Writes › Book › Learn › Learn Zig › Chapter 11. Generic Functions ›

Generic Functions

Generic Functions A function in Zig can take types as parameters. This is the basis of generic programming in the language. Instead of writing separate functions for integers, floating-point values, or user-defined types, a single function can operate on many kinds of values. Here is a simple example: const std = @import("std"); fn add(comptime T: type, a: T, b: T) T { return a + b; } pub fn main()...

Writes › Book › Learn › Learn Zig › Chapter 9. The Optional Type ›

Unwrapping Optionals

Unwrapping Optionals An optional value cannot be used as the payload type until it is unwrapped. This is wrong: const x: ?i32 = 10; const y: i32 = x; // error x is not an i32 . It is a ?i32 . To get the integer out, test the optional: const std = @import("std"); pub fn main() void { const x: ?i32 = 10; if (x) |value| { std.debug.print("{d}\n", .{value});...

Writes › Book › Learn › Learn Zig › Chapter 10. What `comptime` Means ›

What `comptime` Means

What comptime Means A Zig program runs in two stages. First, the compiler runs. Then the program runs. Most languages keep these stages mostly separate. Zig does not. Zig allows parts of a program to execute while the compiler is still compiling the program. This is called compile-time execution. The keyword is: comptime Compile-time execution is one of the central ideas in Zig. It replaces much of what other languages...

Writes › Book › Learn › Learn Zig › Chapter 9. The Optional Type ›

Null

Null null is the value used when an optional has no payload. const x: ?i32 = null; The type of x is not i32 . It is ?i32 . This distinction is important. An integer and an optional integer are different types. const a: i32 = 10; const b: ?i32 = 10; const c: ?i32 = null; a is always an integer. b may hold an integer. c holds no...

Writes › Book › Learn › Learn Zig › Chapter 8. Error Sets ›

Exercises

Exercises 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' . fn parseUpper(c: u8) !u8 { // ... } Write a function safeDivide that divides two integers. Return error.DivisionByZero when the divisor is zero. fn safeDivide(a: u32, b: u32) !u32 { // ... } Write a function first that returns the first byte of...

Writes › Book › Learn › Learn Zig › Chapter 9. The Optional Type ›

The Optional Type

The Optional Type Sometimes a value may or may not exist. A search may fail. A pointer may be empty. A function may have nothing useful to return. Zig represents this with an optional type. An optional type is written with ? before another type: ?i32 This means: either an i32 value, or null Here is a small example: const std = @import("std"); pub fn main() void { const a:...

Writes › Book › Learn › Learn Zig › Chapter 8. Error Sets ›

Designing Error Boundaries

Designing Error Boundaries Most functions should not decide what an error means. A parser should report error.InvalidDigit . A file function should report error.FileNotFound . An allocator should report error.OutOfMemory . The outer layer of the program decides what to print, whether to retry, and whether to stop. Consider a small program that reads a number from a file. const std = @import("std"); fn readText(allocator: std.mem.Allocator, path: []const u8) ![]u8...

Writes › Book › Learn › Learn Zig › Chapter 8. Error Sets ›

`defer` and `errdefer`

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. Zig uses defer for this kind of cleanup. const file = try std.fs.cwd().openFile("data.txt", .{}); defer file.close(); The defer statement runs when the current scope exits. This matters because a scope may exit in more than one way. It may reach the...

Writes › Book › Learn › Learn Zig › Chapter 8. Error Sets ›

`catch`

catch catch handles an error union. Where try passes an error to the caller, catch deals with it in the current expression. const n = parseDigit('x') catch 0; If parseDigit('x') succeeds, n receives the digit. If it fails, n receives 0 . A complete example: const std = @import("std"); fn parseDigit(c: u8) !u8 { if (c < '0' or c > '9') { return error.InvalidDigit; } return c - '0';...

Writes › Book › Zig › Part 23. Real Projects ›

Appendix A. Zig 1.16 New Features

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 you are using a future release. This appendix is a migration and review chapter. It is not meant to teach every feature from scratch. It collects the areas you should check when...

Writes › Book › Learn › Learn Zig › Chapter 8. Error Sets ›

`try`

try try is a shortcut for a common operation: Call a function that may fail. If it succeeds, use the value. If it fails, return the error from the current function. This function may fail: fn parseDigit(c: u8) !u8 { if (c < '0' or c > '9') { return error.InvalidDigit; } return c - '0'; } The caller can use try : fn parseTwoDigits(a: u8, b: u8) !u8 {...

Writes › Book › Zig › Appendix ›

Conclusion

You now know the core ideas behind Zig. You have seen: variables and types arrays and slices pointers and memory structs, enums, and unions errors and optionals allocators compile-time programming the standard library build modes testing C interop concurrency systems programming patterns More importantly, you have seen how Zig thinks. The Main Idea of Zig Zig tries to make important behavior visible. If a function can fail, the type shows...

Writes › Book › Zig › Part 24. Reading and Contributing to Zig ›

Appendix A. Zig 1.16 New Features

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. So this appendix uses the practical name: Zig 0.16 feature notes This matters because Zig versions before 1.0 can still make breaking changes. When you upgrade from one Zig release to another, you should expect some code to need edits. Why Version Notes Matter...

Writes › Book › Zig › Part 23. Real Projects ›

Build a Mini Git Clone

Build a Mini Git Clone Git stores snapshots of files. A small Git-like tool needs only a few core ideas: repository objects hashes commits branches checkout In this project, we will build a tiny version of Git. It will not be compatible with real Git. The goal is to understand the storage model. Our tool will support: init add commit log checkout The Repository Directory A real Git repository stores...

Writes › Book › Zig › Part 21. Advanced Zig ›

Understanding Zig IR

Understanding Zig IR IR means intermediate representation. An intermediate representation is the compiler’s internal form of a program. It sits between source code and final machine code. A compiler does not usually translate source text directly into CPU instructions in one step. It lowers the program through several forms. source code tokens AST semantic analysis IR machine code Each form has a different job. Source code is for humans. The...

Writes › Book › Learn › Learn Zig › Chapter 8. Error Sets ›

Returning Errors

Returning Errors A function returns an error the same way it returns a normal value: with return . fn fail() !void { return error.Failed; } The return type is !void , so the function may return either void or an error. A more useful example: const std = @import("std"); fn checkName(name: []const u8) !void { if (name.len == 0) { return error.EmptyName; } if (name.len > 32) { return error.NameTooLong;...

Writes › Book › Zig › Part 24. Reading and Contributing to Zig ›

Following Zig Development

Following Zig Development Zig changes quickly because it is still moving toward 1.0. This means learning Zig is not only reading the language reference. You also need a way to follow changes without getting lost. The goal is not to track every commit. The goal is to know which changes affect the code you write. Start with Release Notes Release notes are the best first source. They tell you what...

Writes › Book › Zig › Appendix ›

Appendix J. Migrating Between Zig Versions

Appendix J. Migrating Between Zig Versions 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. This appendix explains how to migrate carefully. J.1 Know Your Current Version Check your Zig version first. zig version Example output: 0.16.0 Do not guess. Migration starts with the exact source version and target version....

Writes › Book › Zig › Part 23. Real Projects ›

Build a Simple Game Engine

Build a Simple Game Engine A game engine is a program structure for running interactive simulations. A game usually repeats the same cycle: read input update world draw frame repeat That cycle is called the game loop. In this project, we will build a very small terminal game engine. It will not use graphics, windows, audio, or GPU APIs. It will run in the terminal so the core ideas stay...

Writes › Book › Learn › Learn Zig › Chapter 8. Error Sets ›

Error Unions

Error Unions An error union combines a normal value with an error set. The type: ReadError!u32 means: either a u32 , or an error from ReadError . This is the fundamental error-handling type in Zig. A function that cannot fail returns a normal type: fn square(x: u32) u32 { return x * x; } A function that may fail returns an error union: fn parseDigit(c: u8) !u8 { if (c...

Writes › Book › Learn › Learn Zig › Chapter 8. Error Sets ›

Error Sets

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. Zig treats errors as values. An error in Zig is not an exception. Control does not jump through hidden runtime machinery. A function that may fail says so directly in its type. Here is a small example: const std = @import("std"); fn openFile() !void...

Writes › Book › Learn › Learn Zig › Chapter 7. Struct Declarations ›

Exercises

Exercises These exercises close the chapter on structs, enums, and unions. They are meant to make the data model concrete. Exercise 7-29 Define a struct named Point with two fields: x: i32 y: i32 Create a value with x = 3 and y = 4 , then print both fields. Exercise 7-30 Add a method named move to Point . It should take a pointer to Point and two numbers,...

Writes › Book › Zig › Part 20. Performance and Optimization ›

Case Study 1: Reusing a Temporary Buffer

Performance Case Studies Performance ideas become clearer when you see them inside real code. This section walks through several small case studies. Each one starts with simple code, finds the likely cost, and improves the design. Case Study 1: Reusing a Temporary Buffer A common slow pattern is allocating temporary memory inside a loop. fn processAll(allocator: std.mem.Allocator, items: []const Item) !void { for (items) |item| { const scratch = try...

Writes › Book › Zig › Part 18. Concurrency and Async ›

High Performance Concurrent Design

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. Concurrency does not automatically make a program fast. A bad concurrent program can be slower than a simple single-threaded program. It can waste time on locks, memory allocation, thread scheduling, cache misses, and communication between threads. The goal is not to use many threads....

Writes › Book › Learn › Learn Zig › Chapter 7. Struct Declarations ›

Data Layout

Data Layout A struct is not only a list of fields. It also has a layout in memory. For a normal struct, Zig chooses a layout suitable for the target machine. const Point = struct { x: i32, y: i32, }; This type contains two i32 fields. On most targets, each i32 uses 4 bytes, so the struct uses 8 bytes. const std = @import("std"); const Point = struct {...

Writes › Book › Zig › Part 19. Systems Programming ›

Writing a Small Shell

Writing a Small Shell A shell is a program that reads commands and runs other programs. When you type this: ls the shell starts the ls program. When you type this: echo hello the shell starts the echo program and passes hello as an argument. A small shell has this shape: print prompt read one line split line into arguments run the command repeat The Simplest Shell Loop A shell...

Writes › Book › Zig › Part 18. Concurrency and Async ›

Data Races

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. That means this combination is dangerous: shared memory multiple threads at least one writer no mutex, atomic, or other synchronization Data races are one of the main reasons concurrent programs become unreliable. A Small Race This program has a race: const std...

Writes › Book › Zig › Part 17. Interfacing with C ›

Wrapping Existing Libraries

Wrapping Existing Libraries Wrapping a C library means building a Zig layer around it. The C library remains underneath. Zig calls it. But most of your Zig program does not call the C API directly. Instead, your program calls a cleaner Zig API. This is the usual shape: Application Zig code | v Zig wrapper | v C library The wrapper is the boundary. It translates C habits into Zig...

Writes › Book › Learn › Learn Zig › Chapter 7. Struct Declarations ›

Packed Structs

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. A packed struct is different. Its fields are placed at exact bit positions. const Flags = packed struct { read: bool, write: bool, execute: bool, }; This declares a packed type with three one-bit fields. Each bool field takes one bit. A value...

Writes › Book › Learn › Learn Zig › Chapter 7. Struct Declarations ›

Tagged Unions

Tagged Unions A union is a value that may hold one of several types. A tagged union combines a union with an enum tag. The tag says which field is active. const Value = union(enum) { integer: i32, boolean: bool, }; A Value may contain either an i32 or a bool . Create values with union literals: const a = Value{ .integer = 123 }; const b = Value{ .boolean...

Writes › Book › Learn › Learn Zig › Chapter 7. Struct Declarations ›

Enums

Enums An enum is a type whose values come from a fixed set of names. const Color = enum { red, green, blue, }; This declares a type named Color . It has three possible values: red , green , and blue . A value is written with the type name: const c = Color.red; When the expected type is known, the type name may be omitted: const c: Color...

Writes › Book › Learn › Learn Zig › Chapter 7. Struct Declarations ›

Methods as Functions

Methods as Functions Zig has no class syntax. A function that belongs with a type is written inside the type. const Point = struct { x: i32, y: i32, pub fn moveRight(p: *Point, n: i32) void { p.x += n; } }; The struct has two fields and one function. The function is part of the namespace of Point . It is called with the type name: Point.moveRight(&point, 5); A...

Writes › Book › Learn › Learn Zig › Chapter 7. Struct Declarations ›

Field Access

Field Access Fields are selected with the dot operator. point.x point.y The expression on the left must be a struct, union, enum, or pointer to one of those types. The name on the right selects a field or declaration. Begin with a small example. const std = @import("std"); const Point = struct { x: i32, y: i32, }; pub fn main() void { const point = Point{ .x = 4,...

Writes › Book › Learn › Learn Zig › Chapter 7. Struct Declarations ›

Struct Declarations

Struct Declarations A struct is a type made from named fields. const Point = struct { x: i32, y: i32, }; This declares a type named Point . It has two fields, x and y . Both fields have type i32 . A value of this type is written with a struct literal: const p = Point{ .x = 10, .y = 20, }; The field names are part of...

Writes › Book › Learn › Learn Zig › Chapter 6. Fixed-Size Arrays ›

Exercises

Exercises This section closes the chapter. The exercises are small programs. Write them by hand. Compile them. Change them. Run them again. Exercise 6-1. Declare an array of 10 integers and print the elements in order. Exercise 6-2. Print the same array in reverse order. Exercise 6-3. Write a function named zero5 that takes *[5]i32 and sets all five elements to zero. Exercise 6-4. Copy one array to another. Change...

Writes › Book › Learn › Learn Zig › Chapter 6. Fixed-Size Arrays ›

UTF-8 Handling

UTF-8 Handling Zig strings are bytes. UTF-8 is one way to interpret those bytes as text. The string "hello" is simple. Each character uses one byte. const s = "hello"; The byte length is five. const std = @import("std"); pub fn main() void { const s = "hello"; std.debug.print("{d}\n", .{s.len}); } The output is: 5 A non-ASCII character may use more than one byte. const std = @import("std"); pub fn...

Writes › Book › Learn › Learn Zig › Chapter 6. Fixed-Size Arrays ›

Strings Are Bytes

Strings Are Bytes A Zig string is a sequence of bytes. This is a string literal: const s = "hello"; It has five visible characters: h e l l o It also has a zero sentinel after the last byte, so the literal can be used where sentinel-terminated data is required. The bytes can be printed one by one: const std = @import("std"); pub fn main() void { const s...

Writes › Book › Learn › Learn Zig › Chapter 6. Fixed-Size Arrays ›

Sentinel Arrays

Sentinel Arrays Some arrays have a special value after the last ordinary element. This value is called a sentinel. A sentinel array type writes the sentinel between the length and the element type: [3:0]u8 This means: an array of 3 u8 values, followed by a 0 sentinel The sentinel is not counted in the array length. const std = @import("std"); pub fn main() void { const name: [3:0]u8 = .{...

Writes › Book › Zig › Part 23. Real Projects ›

Build a Bytecode VM

Build a Bytecode VM A bytecode VM is a small machine inside your program. It does not run source code directly. It runs simple instructions called bytecode. For example, instead of running this text: 1 + 2 A VM might run these instructions: push 1 push 2 add print The VM reads one instruction at a time and changes its internal state. The Goal We will build a tiny stack-based...

Writes › Book › Zig › Part 22. Cross-Platform Development ›

Packaging Cross-Platform Apps

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. For Zig programs, packaging often starts with one simple advantage: Zig can build small native binaries for many targets. A cross-platform release may include files like this: mytool-linux-x86_64 mytool-linux-aarch64 mytool-macos-x86_64 mytool-macos-aarch64 mytool-windows-x86_64.exe Each file is built for a different target. Start with Clear Targets Do not...

Writes › Book › Zig › Part 21. Advanced Zig ›

Self-Hosted Zig Compiler

Self-Hosted Zig Compiler A self-hosted compiler is a compiler written in the language it compiles. For Zig, this means the Zig compiler is written largely in Zig and can compile Zig programs, including parts of itself. This matters because a compiler is not only a tool for users. It is also one of the largest tests of the language. If Zig can implement its own compiler, then Zig is strong...

Writes › Book › Zig › Part 20. Performance and Optimization ›

The Basic Idea

Writing Zero-Cost Abstractions An abstraction is a way to hide detail behind a simpler interface. A function is an abstraction. A struct is an abstraction. A generic container is an abstraction. An iterator is an abstraction. A parser API is an abstraction. Abstractions are necessary because large programs cannot be written as one giant block of code. Good abstractions make code easier to read, test, change, and reuse. But abstractions...

Writes › Book › Zig › Part 19. Systems Programming ›

Writing a CLI Tool

Writing a CLI Tool A CLI tool is a command-line program. You run it from a shell: mytool input.txt or: mytool --help Many important programs are CLI tools: git curl grep ls gcc zig python docker ffmpeg CLI tools are one of the best ways to learn systems programming because they combine: file handling argument parsing process control text processing error handling streaming I/O terminal interaction operating system APIs A...

Writes › Book › Zig › Part 18. Concurrency and Async ›

Channels and Queues

Channels and Queues A queue is a data structure for passing work from one part of a program to another. One thread puts work into the queue. Another thread takes work out. producer -> queue -> consumer This pattern is common in concurrent programs. A channel is usually a queue with synchronization built in. Zig’s standard library gives you low-level synchronization tools, such as mutexes, condition variables, atomics, and threads....

Writes › Book › Zig › Part 17. Interfacing with C ›

Working with Headers

Working with Headers C headers are the bridge between Zig and C. A header file describes functions, structs, constants, enums, macros, and type declarations. Zig reads those declarations through @cImport . For example: // mathlib.h #ifndef MATHLIB_H #define MATHLIB_H int add(int a, int b); #endif Zig imports it like this: const c = @cImport({ @cInclude("mathlib.h"); }); Then Zig can call: const result = c.add(10, 20); The header is not compiled...

Writes › Book › Zig › Part 16. Testing and Debugging ›

Benchmarking Code

Benchmarking Code Benchmarking measures how fast code runs. When you benchmark a function, you are trying to answer questions like: How long does this operation take? How many allocations happen? Which version is faster? Did this optimization actually help? Without measurement, performance discussions are mostly guesses. Correctness First Before benchmarking, make sure the code is correct. This order matters: 1. make it correct 2. write tests 3. measure performance 4....

Writes › Book › Learn › Learn Zig › Chapter 6. Fixed-Size Arrays ›

Slicing Arrays

Slicing Arrays A slice is a view into an array. An array owns its storage. A slice refers to existing storage. Given an array: const a = [_]i32{ 10, 20, 30, 40, 50 }; A slice is created with the slicing operator: const s = a[1..4]; The slice contains: 20 30 40 The lower bound is included. The upper bound is excluded. So: a[1..4] means elements: a[1] a[2] a[3] The...

Writes › Book › Learn › Learn Zig › Chapter 6. Fixed-Size Arrays ›

Array Literals

Array Literals An array literal creates an array value. The simplest form gives the length, the element type, and the elements: const a = [4]i32{ 1, 2, 3, 4 }; This creates an array of four i32 values. The number of elements must match the declared length. This is an error: const a = [4]i32{ 1, 2, 3 }; The array says it has length 4, but only 3 elements...

Writes › Book › Learn › Learn Zig › Chapter 6. Fixed-Size Arrays ›

Fixed-Size Arrays

Fixed-Size Arrays An array is a sequence of values of the same type. A fixed-size array has its length as part of its type. This array has five u8 values: const a = [5]u8{ 10, 20, 30, 40, 50 }; The type of a is: [5]u8 This means: an array of 5 values, each of type u8 . Array elements are numbered from zero. const std = @import("std"); pub fn...

Writes › Book › Learn › Learn Zig › Chapter 5. Addresses and Pointer Types ›

Exercises

Exercises Write a function increment that takes *i32 and adds 1 to the pointed-to value. fn increment(n: *i32) void { // ... } Write a function swap that exchanges two integers through pointers. fn swap(a: *i32, b: *i32) void { // ... } Declare a constant integer, take its address, and observe the type of the pointer. const x: i32 = 10; const p = &x; Try to modify a...

Writes › Book › Learn › Learn Zig › Chapter 5. Addresses and Pointer Types ›

Lifetimes

Lifetimes A pointer is useful only while the value it points to still exists. This is the lifetime of the value: the part of the program during which its storage is valid. const std = @import("std"); pub fn main() void { var x: i32 = 10; const p = &x; std.debug.print("{d}\n", .{p.*}); } Here x exists until the end of main . The pointer p is valid during that time....

Writes › Book › Learn › Learn Zig › Chapter 5. Addresses and Pointer Types ›

Alignment

Alignment Memory has addresses. Types also have alignment. The alignment of a type is the address boundary where values of that type are expected to live. An i32 , for example, is usually stored at an address divisible by 4. A u64 is usually stored at an address divisible by 8. Zig exposes alignment as part of the type system. const std = @import("std"); pub fn main() void { std.debug.print("{d}\n",...

Writes › Book › Zig › Part 15. Build System and Tooling ›

Build System Changes in Zig 0.16

Build System Changes in Zig 0.16 Zig changes quickly before 1.0. That includes the build system. This matters because old examples may stop compiling. A build.zig file written for Zig 0.11, 0.12, or 0.13 may need edits before it works on Zig 0.16. The official current release is Zig 0.16.0, not Zig 1.16. The examples in this chapter use the Zig 0.16 build style. Zig 0.16.0 also deprecates @cImport ;...

Writes › Book › Learn › Learn Zig › Chapter 5. Addresses and Pointer Types ›

Pointer Arithmetic

Pointer Arithmetic Pointer arithmetic means forming a new pointer by moving from one element to another. In Zig, ordinary single-item pointers do not support pointer arithmetic. var x: i32 = 10; const p: *i32 = &x; // p + 1 is not the right operation here The type *i32 means one i32 . There is no second item promised by the type. Many-item pointers do support pointer arithmetic. var items...

Writes › Book › Zig › Part 15. Build System and Tooling ›

Packaging Applications

Packaging Applications Packaging means preparing your program so another person can download it, install it, and run it. Building creates the program. Packaging prepares the program for distribution. For a small Zig command-line tool, packaging may be as simple as: zig build -Doptimize=ReleaseFast --prefix dist This creates an output directory such as: dist/ bin/ myapp You can then compress dist/ and publish it. What Should Go Into a Package A...

Writes › Book › Zig › Part 15. Build System and Tooling ›

Installing Binaries

Installing Binaries A build does not only compile files. It can also install the results into a predictable output directory. In Zig projects, the default install directory is usually: zig-out/ For an executable, the installed binary usually goes here: zig-out/bin/ So a project named hello may produce: zig-out/bin/hello On Windows, the executable usually has .exe : zig-out/bin/hello.exe Installing an Executable A normal executable is created like this: const exe =...

Writes › Book › Learn › Learn Zig › Chapter 5. Addresses and Pointer Types ›

Slices

Slices A slice is a pointer and a length. var items = [_]i32{ 10, 20, 30 }; const s: []i32 = items[0..]; The type []i32 means "slice of mutable i32 values." The slice does not own the array. It only refers to part of it. The length is stored in the slice. const std = @import("std"); pub fn main() void { var items = [_]i32{ 10, 20, 30 }; const...

Writes › Book › Learn › Learn Zig › Chapter 5. Addresses and Pointer Types ›

Many-Item Pointers

Many-Item Pointers A many-item pointer points to the first item in a sequence. Its type is written with [*] . var items = [_]i32{ 10, 20, 30 }; const p: [*]i32 = &items; The type [*]i32 means "pointer to many i32 values." It does not store a length. It says where the first item is, but not how many items may be used. Items are accessed with an index. const...

Writes › Book › Learn › Learn Zig › Chapter 5. Addresses and Pointer Types ›

Single-Item Pointers

Single-Item Pointers A single-item pointer points to one value. var x: i32 = 10; const p: *i32 = &x; The type *i32 means that p points to one i32 . The value is read with .* . const y = p.*; The value is written with .* when the pointed-to value is mutable. p.* = 20; A single-item pointer is not an array. It has no length. It does not...

Writes › Book › Learn › Learn Zig › Chapter 5. Addresses and Pointer Types ›

Addresses and Pointer Types

Addresses and Pointer Types A variable has a value. In Zig, a variable may also have an address. The address of a value is obtained with & . const std = @import("std"); pub fn main() void { var x: i32 = 10; const p = &x; std.debug.print("{d}\n", .{p.*}); } The expression &x means "the address of x ." The value stored in p is a pointer to x . The...

Writes › Book › Learn › Learn Zig › Chapter 4. Defining Functions ›

Exercises

Exercises Write a function max3 that returns the largest of three integers. Write a function minSlice that returns the smallest element of a slice of integers. Write a function count that counts how many times a byte appears in a string. Write a function reverse that reverses a slice in place using pointers. Write a module temperature.zig with public functions: celsiusToFahrenheit fahrenheitToCelsius Write a function: fn swap(a: *i32, b: *i32)...

Writes › Book › Learn › Learn Zig › Chapter 4. Defining Functions ›

Organizing a Small Program

Organizing a Small Program A program grows gradually. At first, everything may fit in one file: const std = @import("std"); fn square(x: i32) i32 { return x * x; } pub fn main() void { std.debug.print("{d}\n", .{square(5)}); } As the program becomes larger, declarations should be separated into logical units. A common organization is: src/ main.zig math.zig parser.zig config.zig Each file handles one area of responsibility. For example: // math.zig...

Writes › Book › Learn › Learn Zig › Chapter 4. Defining Functions ›

Importing Files

Importing Files Large programs are divided into smaller files. Zig uses @import to include declarations from another file. Suppose a directory contains these files: main.zig math.zig The file math.zig contains: pub fn add(a: i32, b: i32) i32 { return a + b; } pub fn sub(a: i32, b: i32) i32 { return a - b; } Another file may import it: const std = @import("std"); const math = @import("math.zig"); pub...

Writes › Book › Zig › Part 14. The Standard Library ›

Logging

Logging Logging means recording what a program is doing. A log message is not ordinary output. It is a diagnostic record. It helps you understand what happened before, during, or after a program ran. Programs use logs for: startup messages configuration details warnings errors debugging information performance notes network requests database operations security events A command-line program may print output for the user. A server may write logs for the...

Writes › Book › Zig › Part 14. The Standard Library ›

Networking APIs

Networking APIs Networking means communicating with another program through a network. The other program may be on the same machine, on another machine in your home network, or on a server across the internet. A browser talking to a website is networking. A database client talking to a database server is networking. A multiplayer game, chat app, proxy, crawler, and API client all use networking. At the lowest level, network...

Writes › Book › Learn › Learn Zig › Chapter 4. Defining Functions ›

Public Declarations

Public Declarations A Zig program may be split across many files. Declarations can be made visible outside a file with pub . Here is a small file named math.zig : pub fn square(x: i32) i32 { return x * x; } The function is declared with: pub fn which means the declaration is public. Another file may import and use it: const std = @import("std"); const math = @import("math.zig"); pub...

Writes › Book › Zig › Part 14. The Standard Library ›

HTTP Client

HTTP Client An HTTP client is code that sends a request to a web server and reads the response. When you open a web page, your browser acts as an HTTP client. When a command-line tool downloads a file, it may act as an HTTP client. When a program calls a web API, it usually uses an HTTP client. HTTP is built around requests and responses. A request asks for...

Writes › Book › Learn › Learn Zig › Chapter 4. Defining Functions ›

Passing Values

Passing Values When a function is called, values are passed from the caller to the function parameters. Consider: const std = @import("std"); fn addOne(x: i32) i32 { return x + 1; } pub fn main() void { var n: i32 = 5; const m = addOne(n); std.debug.print("n = {d}, m = {d}\n", .{ n, m }); } The output is: n = 5, m = 6 The value of n...

Writes › Book › Learn › Learn Zig › Chapter 4. Defining Functions ›

Parameters and Return Values

Parameters and Return Values Functions communicate through parameters and return values. Here is a function with one parameter and one return value: fn increment(x: i32) i32 { return x + 1; } The parameter is declared inside the parentheses: x: i32 x is the parameter name. i32 is the parameter type. The caller passes a value to the function: const n = increment(10); Inside the function, x receives the value...

Writes › Book › Zig › Part 14. The Standard Library ›

JSON Support

JSON Support JSON is a text format for storing structured data. JSON is common because it is simple, readable, and widely supported. Web APIs use it. Configuration files use it. Command-line tools use it. Databases and message queues often accept it. A JSON value can be: null true false 123 "hello" [1, 2, 3] {"name": "Alice", "age": 30} JSON looks simple, but parsing it correctly still matters. A parser must...

Writes › Book › Learn › Learn Zig › Chapter 4. Defining Functions ›

Defining Functions

Defining Functions A function groups statements into a single operation. Functions are the basic unit of organization in a Zig program. Here is a small function: const std = @import("std"); fn square(x: i32) i32 { return x * x; } pub fn main() void { const n = square(5); std.debug.print("{d}\n", .{n}); } The output is: 25 A function declaration has four parts: fn square(x: i32) i32 { return x *...

Writes › Book › Zig › Part 14. The Standard Library ›

Compression

Compression Compression means making data smaller. A text file may contain repeated words. A log file may contain repeated timestamps. A binary file may contain repeated patterns. Compression algorithms find these patterns and store the same information using fewer bytes. For example, this text has obvious repetition: hello hello hello hello hello A compressor can store it more compactly than the original bytes. Compression is useful for: saving disk space...

Writes › Book › Learn › Learn Zig › Chapter 3. Blocks are Expressions ›

Exercises

Exercises This section collects the exercises for the chapter. They are meant to be small programs. Each one should compile and run. Exercise 3-1. Write a block expression that sets x to 10 + 20 . const x = blk: { break :blk 10 + 20; }; Exercise 3-2. Write a block expression that classifies an integer as "small" or "large" . const label = classify: { if (n <...

Writes › Book › Learn › Learn Zig › Chapter 3. Blocks are Expressions ›

`defer`

defer defer runs a statement when control leaves the current block. const std = @import("std"); pub fn main() void { defer std.debug.print("second\n", .{}); std.debug.print("first\n", .{}); } The output is: first second The deferred statement is written first, but it runs later. The block matters. A deferred statement runs at the end of the block where it was declared. const std = @import("std"); pub fn main() void { { defer std.debug.print("leaving...

Writes › Book › Zig › Part 14. The Standard Library ›

Process Management

Process Management A process is a running program. When you run: zig build-exe main.zig ./main the operating system creates a process for ./main . A process has memory, open files, environment variables, command-line arguments, and an exit code. It may also create other processes. Command-Line Arguments Command-line arguments are text values passed to a program when it starts. Example: ./hello Alice Here, Alice is an argument. A simple Zig program...

Writes › Book › Learn › Learn Zig › Chapter 3. Blocks are Expressions ›

`break`, `continue`, and Labels

break , continue , and Labels break leaves a loop. var i: usize = 0; while (i < 10) : (i += 1) { if (i == 5) break; std.debug.print("{d}\n", .{i}); } This prints: 0 1 2 3 4 When i becomes 5 , the loop ends. continue skips the rest of the current iteration and starts the next one. var i: usize = 0; while (i < 10) :...

Writes › Book › Learn › Learn Zig › Chapter 3. Blocks are Expressions ›

`for` Loops

for Loops A for loop visits the elements of an array, slice, or range. const std = @import("std"); pub fn main() void { const data = [_]u8{ 10, 20, 30 }; for (data) |x| { std.debug.print("{d}\n", .{x}); } } The output is: 10 20 30 The name between bars is the loop capture. |x| On each iteration, x is the current element. A for loop over an array visits each...

Writes › Book › Zig › Part 14. The Standard Library ›

Environment Variables

Environment Variables An environment variable is a named value provided to a program by the operating system. Programs use environment variables for configuration. Examples: HOME PATH TMPDIR USER EDITOR A program may also define its own variables: APP_PORT DATABASE_URL LOG_LEVEL Environment variables are text. If you need a number, boolean, path, or URL, you must parse the text yourself. Viewing Environment Variables On Linux and macOS: echo $HOME On Windows...

Writes › Book › Learn › Learn Zig › Chapter 3. Blocks are Expressions ›

`while` Loops

while Loops A while loop repeats while a condition is true. var i: usize = 0; while (i < 5) { std.debug.print("{d}\n", .{i}); i += 1; } The output is: 0 1 2 3 4 The condition must be a boolean. Zig does not treat integers as true or false. This is correct: while (i != 0) { i -= 1; } This is wrong: while (i) { i -=...

Writes › Book › Learn › Learn Zig › Chapter 3. Blocks are Expressions ›

`switch` Expressions

switch Expressions A switch chooses one branch from several alternatives. const name = switch (code) { 200 => "ok", 404 => "not found", 500 => "server error", else => "unknown", }; This is an expression. The value of the selected branch becomes the value of name . The value being tested is called the switch operand. switch (code) { ... } Each branch has one or more cases. 200 =>...

Writes › Book › Learn › Learn Zig › Chapter 3. Blocks are Expressions ›

`if` Expressions

if Expressions In Zig, if is an expression. It can produce a value. const max = if (a > b) a else b; This is common Zig style. The if expression chooses one of two values. The condition must be a boolean value. Zig does not convert integers to booleans automatically. This is correct: if (x != 0) { // ... } This is wrong: if (x) { // ......

Writes › Book › Zig › Part 14. The Standard Library ›

Random Number Generation

Random Number Generation Random numbers are used when a program needs variation. Games use random numbers for movement, maps, enemies, and loot. Simulations use random numbers to model uncertain events. Tests use random numbers to generate many inputs. Security code uses random bytes for keys, tokens, salts, and nonces. These uses are not all the same. For normal program behavior, a pseudo-random number generator is often enough. For security, you...

Writes › Book › Learn › Learn Zig › Chapter 3. Blocks are Expressions ›

Blocks are Expressions

Blocks are Expressions A block is a sequence of statements inside braces. { const x = 1; const y = 2; _ = x + y; } Blocks are used for function bodies, if bodies, loop bodies, and local scopes. A name declared inside a block exists only inside that block. const std = @import("std"); pub fn main() void { { const x = 10; std.debug.print("{d}\n", .{x}); } // x...

Writes › Book › Learn › Learn Zig › Chapter 2. Names and Declarations ›

Exercises

Exercises This chapter introduced the basic forms of values and declarations: names, constants, variables, integer types, floating-point types, booleans, bytes, inferred types, and explicit casts. The exercises below are small. Type them by hand. Compile them. Change them. Read the error messages. Write a program that declares a constant named answer with value 42 and prints it. const std = @import("std"); pub fn main() void { const answer = 42;...

Writes › Book › Zig › Part 13. Collections and Data Structures ›

Start with the Operations

Performance Tradeoffs A data structure is never just a container. It is also a set of tradeoffs. When you choose between ArrayList , HashMap , StringHashMap , linked lists, queues, bit sets, ring buffers, and trees, you are choosing how your program will use memory, CPU time, allocation, cache locality, and complexity. The right choice depends on what the program does most often. Start with the Operations Before choosing a...

Writes › Book › Learn › Learn Zig › Chapter 2. Names and Declarations ›

Explicit Casts

Explicit Casts Zig does not perform most numeric conversions automatically. This is intentional. Conversions can lose information, change sign, truncate values, or change precision. Zig requires the programmer to write conversions explicitly. Consider: const a: i32 = 10; const b: u32 = 20; const c = a + b; // error The types differ. Zig does not guess which conversion is correct. You must convert one value explicitly. const a:...

Writes › Book › Learn › Learn Zig › Chapter 2. Names and Declarations ›

Type Inference

Type Inference A declaration may name its type explicitly. const n: i32 = 10; The part after the colon is the type: i32 A declaration may also leave the type out. const n = 10; In this case, Zig infers the type from the value and the surrounding context. Type inference removes repetition. It does not remove types. Every value still has a type. const std = @import("std"); pub fn...

Writes › Book › Zig › Part 13. Collections and Data Structures ›

Start with the Rule

Building Your Own Collections A collection is a type that stores many values. You have already seen several examples: std.ArrayList(T) std.AutoHashMap(K, V) std.StringHashMap(V) These are general-purpose collections. They are useful because they solve common problems. But sometimes you need a collection with rules that are specific to your program. Examples: a stack that never grows past 64 items a queue that overwrites old values a list that stores only unique...

Writes › Book › Zig › Part 11. Zig Builtins ›

Important Builtins in Zig 1.16

Important Builtins in Zig 1.16 This chapter covered the builtins you will see most often as a beginner. A builtin is a compiler-provided function. Its name starts with @ . @import("std") @sizeOf(u32) @alignOf(u32) @intCast(x) These are not standard library functions. They are part of the language. Type and Module Builtins Use these to import code or work with types. Builtin Meaning @import Load a Zig module or source file @TypeOf...

Writes › Book › Zig › Part 11. Zig Builtins ›

`@embedFile`

@embedFile @embedFile reads a file at compile time and embeds its bytes into the final program. Example: const data = @embedFile("data.txt"); This means: Read data.txt while compiling. Store its contents inside the executable. Give me access to those bytes. The file is not opened at runtime. The bytes are already part of the compiled program. A Simple Example Suppose your project has this structure: project/ ├── main.zig └── message.txt message.txt...

Writes › Book › Learn › Learn Zig › Chapter 2. Names and Declarations ›

Characters and Bytes

Characters and Bytes Zig does not have a separate character type for ordinary strings. A string is a sequence of bytes. const message = "hello"; The bytes are: 104 101 108 108 111 These are the ASCII byte values for h , e , l , l , and o . A byte has type u8 . const c: u8 = 'A'; The value of c is 65 . A...

Writes › Book › Learn › Learn Zig › Chapter 2. Names and Declarations ›

Booleans

Booleans A boolean value is either true or false . const ready: bool = true; const done: bool = false; The type is bool . Boolean values are used in conditions. const std = @import("std"); pub fn main() void { const ready = true; if (ready) { std.debug.print("ready\n", .{}); } } The condition of an if must be a boolean. const n = 1; if (n) { // error //...

Writes › Book › Learn › Learn Zig › Chapter 2. Names and Declarations ›

Floating-Point Types

Floating-Point Types Zig has floating-point types for numbers with fractional parts. const x: f32 = 3.5; const y: f64 = 3.5; f32 is a 32-bit floating-point number. f64 is a 64-bit floating-point number. Use f64 for ordinary calculations unless there is a reason to use less space. const pi: f64 = 3.141592653589793; A floating-point literal contains a decimal point or an exponent. const a = 1.0; const b = 1.5;...

Writes › Book › Learn › Learn Zig › Chapter 2. Names and Declarations ›

Integer Types

Integer Types Zig has signed and unsigned integer types. A signed integer can hold negative and positive values. const a: i32 = -10; An unsigned integer can hold only zero and positive values. const b: u32 = 10; The letter tells whether the integer is signed or unsigned. i32 u32 i means signed integer. u means unsigned integer. 32 means 32 bits. Common integer types are: Type Meaning i8 signed...

Writes › Book › Learn › Learn Zig › Chapter 2. Names and Declarations ›

`const` and `var`

const and var Zig has two kinds of variable declarations: const and var A const declaration creates a name whose value cannot change. const year = 2026; A var declaration creates a mutable variable. var count = 0; The difference is important. Zig prefers immutability when possible. Consider: const std = @import("std"); pub fn main() void { const x = 10; std.debug.print("{d}\n", .{x}); } This program is correct. Now try...

Writes › Book › Learn › Learn Zig › Chapter 2. Names and Declarations ›

Names and Declarations

Names and Declarations A Zig program is made from declarations. A declaration gives a name to something. The name may refer to a value, a function, a type, or an imported module. const std = @import("std"); const count = 10; pub fn main() void { std.debug.print("{d}\n", .{count}); } There are three declarations here. const std = @import("std"); This declares the name std . const count = 10; This declares the...

Writes › Book › Learn › Learn Zig › Chapter 1. Hello, Zig ›

Exercises

Exercises The programs in this chapter are small. They are meant to be changed, broken, rebuilt, and studied. Do not only read them. Run them. A programming language is learned by writing programs. Exercise 1-1 Run the first hello program. Change the text: std.debug.print("hello, zig\n", .{}); to: std.debug.print("hello, world\n", .{}); Build and run it again. Exercise 1-2 Print two lines with one call to std.debug.print . Expected output: first line...

Writes › Book › Learn › Learn Zig › Chapter 1. Hello, Zig ›

A Word-Count Program

A Word-Count Program A useful program reads text and counts something. This program counts bytes from standard input: const std = @import("std"); pub fn main() !void { var count: usize = 0; const stdin = std.io.getStdIn().reader(); while (stdin.readByte()) |_| { count += 1; } else |err| { if (err != error.EndOfStream) { return err; } } std.debug.print("{d}\n", .{count}); } Run it: zig run main.zig Type some text, then end the...

Writes › Book › Learn › Learn Zig › Chapter 1. Hello, Zig ›

Reading Command-Line Arguments

Reading Command-Line Arguments Programs often need input. One simple source of input is the command line. When a program starts, the operating system passes a list of arguments to it. Zig can read these arguments through the standard library. This program prints every argument: const std = @import("std"); pub fn main() !void { var args = std.process.args(); while (args.next()) |arg| { std.debug.print("{s}\n", .{arg}); } } Run it: zig run main.zig...

Writes › Book › Learn › Learn Zig › Chapter 1. Hello, Zig ›

A Small Calculator

A Small Calculator A program can compute a value before it prints it. const std = @import("std"); pub fn main() void { const x = 12; const y = 5; const sum = x + y; std.debug.print("{d}\n", .{sum}); } The output is: 17 The expression: x + y adds two values. The result is stored in sum : const sum = x + y; Zig has the usual arithmetic operators:...

Writes › Book › Learn › Learn Zig › Chapter 1. Hello, Zig ›

Printing Values

Printing Values The function std.debug.print writes text. const std = @import("std"); pub fn main() void { std.debug.print("hello\n", .{}); } The first argument is the format string. "hello\n" The second argument is a tuple of values. .{} When there are no values to print, the tuple is empty. To print an integer, put {d} in the format string: const std = @import("std"); pub fn main() void { const n = 42;...

Writes › Book › Learn › Learn Zig › Chapter 1. Hello, Zig ›

Variables and Constants

Variables and Constants A program works with values. In Zig, values are usually stored in constants or variables. A constant is declared with const : const std = @import("std"); pub fn main() void { const year = 2026; std.debug.print("{d}\n", .{year}); } Run it: 2026 The name year cannot be changed after it is declared. A variable is declared with var : const std = @import("std"); pub fn main() void {...

Writes › Book › Learn › Learn Zig › Chapter 1. Hello, Zig ›

Build and Run

Build and Run There are two common ways to run a small Zig program. The first way is direct: zig run main.zig This compiles main.zig , runs the result, and then removes the temporary executable. It is useful while learning. For example: const std = @import("std"); pub fn main() void { std.debug.print("hello, zig\n", .{}); } Run it: zig run main.zig The output is: hello, zig The second way is to...

Writes › Book › Learn › Learn Zig › Chapter 1. Hello, Zig ›

Hello, Zig

Hello, Zig The first program in Zig is small. const std = @import("std"); pub fn main() void { std.debug.print("hello, zig\n", .{}); } Save this in a file named main.zig . Run it: zig run main.zig The output is: hello, zig A Zig program is made of declarations. The first line declares a name: const std = @import("std"); const means the name cannot be changed after it is set. Here the...

Writes › Book › Learn › Learn Zig › Appendix ›

Hello, Zig

Hello, Zig The first program in Zig is small. const std = @import("std"); pub fn main() void { std.debug.print("hello, zig\n", .{}); } Save this in a file named main.zig . Run it: zig run main.zig The output is: hello, zig A Zig program is made of declarations. The first line declares a name: const std = @import("std"); const means the name cannot be changed after it is set. Here the...

Writes › Book › Zig › Part 11. Zig Builtins ›

`@compileError`

@compileError @compileError stops compilation with a custom error message. It does not stop the program while it is running. It stops the program from being built. @compileError("message"); This means: The code is invalid. Show this message during compilation. A Simple Example pub fn main() void { comptime { @compileError("this code is not ready yet"); } } When you compile this program, Zig reports the message and refuses to build the...

Writes › Book › Zig › Part 11. Zig Builtins ›

`@panic`

@panic @panic stops the program immediately with a message. It is used when the program reaches a state that should never happen, or when continuing would be unsafe. @panic("something went wrong"); This tells Zig: Stop the program here. Print this message. A Simple Example const std = @import("std"); pub fn main() void { @panic("this program cannot continue"); std.debug.print("after panic\n", .{}); } The second print does not run. The program stops...

Writes › Book › Zig › Appendix ›

Appendix I. Zig Coding Style Guide

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. I.1 Prefer const by Default Use const unless the value must change. const x = 10; Use var only when mutation is required. var count: usize = 0; count += 1; This makes the code easier to...

Writes › Book › Zig › Part 24. Reading and Contributing to Zig ›

Contributing to Zig

Contributing to Zig Contributing to Zig means helping the language, compiler, standard library, documentation, tests, or tooling improve. You do not need to be a compiler expert to contribute. Some useful contributions are small: fixing unclear documentation adding missing tests reducing a bug report to a small example improving an error message cleaning up simple code checking behavior on a platform The safest way to begin is to make a...

Writes › Book › Zig › Part 23. Real Projects ›

Build a Programming Language Lexer

Build a Programming Language Lexer A lexer is the first stage of many programming language tools. Its job is simple: input text ↓ sequence of tokens For example, this source code: let x = 42 + y; becomes: KeywordLet Identifier("x") Equal Number("42") Plus Identifier("y") Semicolon A lexer does not understand meaning yet. It only splits text into pieces. Parsers, compilers, interpreters, formatters, syntax highlighters, and linters usually begin with lexing....

Writes › Book › Zig › Part 22. Cross-Platform Development ›

Handling Platform Differences

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 rules. Good portable code accepts those differences, puts them in clear places, and keeps the rest of the program simple. The goal is not to remove platform differences. The goal is to control where they appear. The Problem Suppose your program needs a...

Writes › Book › Zig › Part 21. Advanced Zig ›

Writing a Compiler in Zig

Writing a Compiler in Zig A compiler translates one form of code into another form. For this chapter, we will use a small meaning: source code -> tokens -> AST -> bytecode The source code is what the user writes. The bytecode is what our virtual machine runs. A full production compiler can generate machine code, optimize programs, perform type checking, emit debug information, and link object files. We do...

Writes › Book › Zig › Part 20. Performance and Optimization ›

Benchmark the Right Thing

Benchmark Methodology Benchmarking means measuring how fast code runs. A benchmark answers a narrow question: How long does this operation take under these conditions? That last part matters. A benchmark is only useful when the conditions are clear. Different inputs, build modes, machines, allocators, and operating system states can produce different results. Good benchmarking is not only running a timer. It is designing a measurement that tells the truth. Benchmark...

Writes › Book › Zig › Part 19. Systems Programming ›

Writing a TCP Server

Writing a TCP Server A TCP server is a program that waits for clients to connect. Once a client connects, the server can read bytes from the client and write bytes back. This is the foundation of many network programs: web servers, databases, proxies, chat servers, RPC services, and development tools. TCP gives your program a reliable byte stream. Bytes arrive in order, or the connection fails. TCP does not...

Writes › Book › Zig › Part 18. Concurrency and Async ›

Event Loops

Event Loops An event loop is code that waits for events, then runs the right piece of work for each event. An event can be many things: Event Meaning A socket is ready Network data can be read or written A timer expired A scheduled time has arrived A file operation finished The result is ready A process exited A child process has ended A signal arrived The operating system...

Writes › Book › Zig › Part 17. Interfacing with C ›

ABI Compatibility

ABI Compatibility ABI means Application Binary Interface. An API describes how source code calls something. An ABI describes how compiled code calls something. When Zig calls C, source code is only half of the story. The final machine code must agree on details such as: ABI detail What it controls Calling convention How function arguments are passed Return values How results come back Struct layout How fields are placed in...

Writes › Book › Zig › Part 16. Testing and Debugging ›

Memory Debugging

Memory Debugging Memory debugging means finding mistakes in how a program uses memory. In Zig, memory bugs usually come from one of these problems: using memory after it has been freed freeing the same memory twice forgetting to free allocated memory reading or writing past the end of a slice returning a pointer to memory that no longer exists using an allocator incorrectly Zig gives you tools and habits that...

Writes › Book › Zig › Part 15. Build System and Tooling ›

Running Tests

Running Tests Zig has built-in support for tests. You can test one file directly with: zig test src/main.zig That command compiles the file, finds its test blocks, and runs them. Inside a project, you usually run tests through build.zig : zig build test This gives the project one standard test command. A Simple Test A Zig test uses a test block: const std = @import("std"); fn add(a: i32, b: i32)...

Writes › Book › Zig › Part 14. The Standard Library ›

Time and Timers

Time and Timers Programs often need to work with time. A program may need to measure how long something takes. It may need to wait for a short duration. It may need to store timestamps in logs. It may need to compare two moments. Zig’s standard library provides time utilities in: std.time For beginners, the most important use is measuring elapsed time. Getting a Timestamp A timestamp is a number...

Writes › Book › Zig › Part 11. Zig Builtins ›

`@floatCast`

@floatCast @floatCast converts one floating-point value to another floating-point type. You use it when changing between types such as f16 , f32 , f64 , and f128 . const small: f32 = @floatCast(big); This means: Convert big to f32. The destination type comes from context. A Simple Example const std = @import("std"); pub fn main() void { const x: f64 = 3.141592653589793; const y: f32 = @floatCast(x); std.debug.print("{}\n", .{y}); }...

Writes › Book › Zig › Appendix ›

Appendix H. Useful Open Source Zig Projects

Appendix H. Useful Open Source Zig Projects This appendix lists useful Zig projects to read after you know the basics. H.1 Zig Compiler The Zig compiler itself is the most important Zig codebase. Repository: ziglang/zig Read it when you want to understand: Area What to study Parser How Zig source becomes syntax trees Sema How semantic analysis works Code generation How Zig lowers code Build system How large Zig projects...

Writes › Book › Zig › Part 24. Reading and Contributing to Zig ›

Open Issues and RFCs

Open Issues and RFCs A programming language is never only its syntax. It is also a project. It has maintainers, users, design debates, bug reports, accepted changes, rejected ideas, unfinished work, and long-term goals. Zig is still before 1.0, so this matters even more. The language and standard library can still change in significant ways before the stable 1.0 release. To understand Zig well, you should learn how to read...

Writes › Book › Zig › Part 23. Real Projects ›

Build a Small Database

Build a Small Database A database stores data so it can be saved, searched, updated, and loaded again later. In this project, we will build a very small database engine using a single file. The database will support: insert get list save to disk load from disk We will store records like this: id name email Example: 1 alice alice@example.com 2 bob bob@example.com This project teaches several important systems programming...

Writes › Book › Zig › Part 22. Cross-Platform Development ›

Portable APIs

Portable APIs A portable API is an interface that works across more than one platform. In Zig, this usually means code that can run on Windows, Linux, macOS, and sometimes other targets without rewriting the program for each operating system. The main idea is simple: write against Zig’s standard library when possible, and isolate platform-specific code when necessary. Why Portable APIs Matter Operating systems differ. Windows paths look like this:...

Writes › Book › Zig › Part 21. Advanced Zig ›

Writing a Virtual Machine

Writing a Virtual Machine A virtual machine is a program that runs another program. The “machine” part means it has its own instruction format, its own execution rules, and usually its own memory model. The “virtual” part means this machine is implemented in software. A CPU runs machine code. A virtual machine runs bytecode. For example, instead of executing native CPU instructions directly, a VM may execute instructions like: push...

Writes › Book › Zig › Part 20. Performance and Optimization ›

Why Branch Prediction Exists

Branch Prediction Branch prediction is a CPU optimization. A branch is a point where the program can go in more than one direction. The most common branch is an if . if (value > 0) { positive += 1; } else { non_positive += 1; } The CPU does not like waiting. When it sees a branch, it tries to guess which path the program will take. If the guess...

Writes › Book › Zig › Part 19. Systems Programming ›

Network Protocols

Network Protocols A network protocol is a rulebook for how programs talk over a network. When two programs communicate, they cannot just send random bytes and hope the other side understands. They need an agreed format. A protocol defines things like: What messages exist? What does each message mean? How are messages encoded as bytes? Who sends first? How does the other side respond? How are errors represented? When does...

Writes › Book › Zig › Part 18. Concurrency and Async ›

Await and Suspension

Await and Suspension await means: wait until an asynchronous operation has finished, then continue with its result. A suspension point is a place where the current operation may pause so something else can make progress. In simple words: async starts work await waits for work suspension lets other work run This is the basic shape of asynchronous programming. Start First, Wait Later A normal function call works like this: const...

Writes › Book › Zig › Part 17. Interfacing with C ›

Exporting Zig to C

Exporting Zig to C Zig can call C, but C can also call Zig. This is useful when you want to add Zig code to an existing C project, write a library in Zig with a C API, or replace part of a C codebase gradually. The key tool is export . export fn add(a: c_int, b: c_int) c_int { return a + b; } This defines a Zig function...

Writes › Book › Zig › Part 16. Testing and Debugging ›

Using GDB and LLDB

Using GDB and LLDB GDB and LLDB are debuggers. A debugger lets you run a program under inspection. You can stop the program, move through it line by line, inspect variables, and see the call stack. For Zig beginners, debuggers are useful when std.debug.print is no longer enough. Build with Debug Information First, compile normally: zig build-exe main.zig Debug information is included in normal debug builds. Then run the program...

Writes › Book › Zig › Part 15. Build System and Tooling ›

Release Modes

Release Modes Zig can build the same program in different optimization modes. The optimization mode controls how the compiler balances debugging, safety checks, speed, and binary size. In build.zig , release modes usually come from this line: const optimize = b.standardOptimizeOption(.{}); Then the executable uses it: const exe = b.addExecutable(.{ .name = "hello", .root_module = b.createModule(.{ .root_source_file = b.path("src/main.zig"), .target = target, .optimize = optimize, }), }); The important field...

Writes › Book › Zig › Part 14. The Standard Library ›

Parsing Numbers and Text

Parsing Numbers and Text Parsing means turning text into data. For example, this text: 123 can become the integer value: 123 This text: 3.14 can become a floating point value: 3.14 This text: true can become a boolean value: true Programs parse text all the time. Command-line arguments are text. Environment variables are text. Configuration files often contain text. Network protocols often begin as text. Logs, CSV files, JSON files,...

Writes › Book › Zig › Part 13. Collections and Data Structures ›

Why Trees Matter

Trees A tree is a collection made of nodes. Each node can point to other nodes. The first node is called the root. 10 / \ 5 20 / \ 2 7 This tree has one root: 10 The root has two children: 5 and 20 Node 5 also has two children: 2 and 7 A node with no children is called a leaf. 2, 7, and 20 Why Trees...

Writes › Book › Zig › Part 12. Allocators and Memory Management ›

Building Allocation-Friendly APIs

Building Allocation-Friendly APIs An allocation-friendly API makes memory behavior clear to the caller. In Zig, this usually means the function does not secretly allocate. If a function needs heap memory, it receives an allocator. If it returns owned memory, the caller knows they must free it. This style makes code easier to test, easier to reuse, and easier to optimize. Start with the Caller When designing an API, begin with...

Writes › Book › Zig › Part 11. Zig Builtins ›

`@truncate`

@truncate @truncate converts an integer to a smaller integer type by keeping only the low bits. It does not check whether the original value fits. It deliberately throws away the high bits. const small: u8 = @truncate(big); This means: Keep the lowest 8 bits of big. Discard the rest. A Simple Example const std = @import("std"); pub fn main() void { const x: u16 = 300; const y: u8 =...

Writes › Book › Zig › Appendix ›

Appendix G. C Interop Reference

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. This appendix gives the practical reference you need first. G.1 Importing a C Header Use @cImport with @cInclude . const c = @cImport({ @cInclude("stdio.h"); }); Then call C functions through c . pub fn...

Writes › Book › Zig › Part 24. Reading and Contributing to Zig ›

LLVM Integration

LLVM Integration LLVM is a compiler infrastructure project. A compiler infrastructure is a collection of reusable compiler parts. Instead of every language building every backend from scratch, a language can use LLVM for optimization and machine code generation. Many languages use LLVM because it already knows how to target many CPUs and operating systems. Zig has used LLVM as an important backend. This means Zig can lower analyzed Zig code...

Writes › Book › Zig › Part 23. Real Projects ›

Build a Memory Allocator

Build a Memory Allocator A memory allocator is code that gives memory to the rest of a program. When a program needs space for data, it asks an allocator: const buffer = try allocator.alloc(u8, 1024); That means: give me 1024 bytes. Later, when the program is done with that memory, it gives it back: allocator.free(buffer); Zig makes allocators explicit. A function that needs heap memory usually receives an allocator from...

Writes › Book › Zig › Part 22. Cross-Platform Development ›

Cross-Target Debugging

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. For example, you may write Zig code on an x86_64 laptop, build it for aarch64-linux , copy it to a Raspberry Pi, and debug it from your main computer. The basic workflow is: write code on host machine build for target machine run program on...

Writes › Book › Zig › Part 21. Advanced Zig ›

Writing a Parser

Writing a Parser A parser reads text and turns it into structure. For example, this text: 1 + 2 * 3 can become a tree: + 1 * 2 3 That tree tells the program what the text means. The multiplication belongs together before the addition. A parser is useful when writing: programming languages configuration formats query languages template engines data formats command-line expressions A parser usually has two stages:...

Writes › Book › Zig › Part 20. Performance and Optimization ›

Small Values Are Fine to Copy

Avoiding Copies Copying data is sometimes necessary, but unnecessary copying is one of the easiest ways to waste time and memory. A copy takes bytes from one place and writes them to another place. For small values, this is cheap. For large arrays, large structs, strings, buffers, and file contents, copying can become expensive. In Zig, you should learn to notice when data is copied and when data is only...

Writes › Book › Zig › Part 19. Systems Programming ›

Endianness

Endianness Endianness means the order used to store the bytes of a multi-byte value. A single byte has no byte order problem. It is just one byte. 7F But a 32-bit integer uses 4 bytes. Those 4 bytes must be placed in some order. Take this number: 0x12345678 It has four bytes: 12 34 56 78 There are two common ways to store them. Big-Endian Big-endian stores the most significant...

Writes › Book › Zig › Part 18. Concurrency and Async ›

Async Functions

Async Functions Async code lets a program start an operation now and receive the result later. In many languages, this is written with async and await . Zig has used those words in earlier designs, but Zig 0.16 changed the practical shape of async I/O. In Zig 0.16, the important beginner concept is not “mark every function async.” The important concept is: write normal-looking code, pass an I/O interface, and...

Writes › Book › Zig › Part 17. Interfacing with C ›

Building Mixed Zig and C Projects

Building Mixed Zig and C Projects A mixed Zig and C project contains source files from both languages. This is common when you are using an existing C library, replacing part of a C project with Zig, or writing a Zig program that depends on small C helper files. A simple mixed project may look like this: project/ build.zig src/ main.zig mathlib.c mathlib.h The Zig file contains the main program....

Writes › Book › Zig › Part 16. Testing and Debugging ›

Assertions

Assertions An assertion is a check that must be true while the program runs. In Zig, assertions are commonly written with std.debug.assert : const std = @import("std"); pub fn main() void { const x = 10; std.debug.assert(x > 0); } This says: x must be greater than zero If the condition is true, the program continues. If the condition is false, the program stops. Why Assertions Exist Assertions help you...

Writes › Book › Zig › Part 15. Build System and Tooling ›

Static and Dynamic Linking

Static and Dynamic Linking Linking is the step where the compiler connects your program with the code it depends on. Your program may use code from: your own Zig files the Zig standard library C libraries system libraries third-party packages After compilation, those pieces need to become one runnable program. The linker does that job. There are two main styles: static linking dynamic linking Static linking copies library code into...

Writes › Book › Zig › Part 14. The Standard Library ›

Formatting and Printing

Formatting and Printing Formatting means turning values into text. Printing means sending that text somewhere, usually to the terminal. You have already used this many times: const std = @import("std"); pub fn main() void { std.debug.print("Hello, Zig!\n", .{}); } This line is doing two things: std.debug.print("Hello, Zig!\n", .{}); It prints a format string. It receives a tuple of values to insert into that string. The tuple is empty here: .{}...

Writes › Book › Zig › Part 13. Collections and Data Structures ›

The Core Idea

Ring Buffers A ring buffer is a fixed-size queue that reuses its storage. A normal queue has a front and a back: front back [10][20][30][40] When you remove from the front, the front moves forward: [old][20][30][40] ^ front After many removals, unused space builds up at the beginning. A ring buffer solves this by wrapping around to the start of the array. [50][60][old][40] ^ ^ back front The storage is...

Writes › Book › Zig › Part 12. Allocators and Memory Management ›

Lifetime Management

Lifetime Management Memory lifetime means: How long is this memory valid? This is one of the most important ideas in systems programming. A program becomes unsafe when it uses memory after that memory is no longer valid. In Zig, you must think carefully about ownership and lifetime because the language gives you direct control over memory. A Simple Lifetime Look at this example: const std = @import("std"); pub fn main()...

Writes › Book › Zig › Part 11. Zig Builtins ›

`@intCast`

@intCast @intCast converts one integer value to another integer type. You use it when Zig needs an explicit promise that the integer value fits in the destination type. const small: u8 = @intCast(big); This says: Convert big to u8. But the value must fit in u8 . A u8 can store values from 0 to 255 . Why @intCast Exists Integer conversions can lose information. Example: const big: u16 =...

Writes › Book › Zig › Part 10. Compile-Time Programming ›

When Not to Use `comptime`

When Not to Use comptime comptime is one of Zig’s strongest features, but it should not be used everywhere. A simple rule works well: Use comptime when the information is part of the program’s structure. Use runtime code when the information comes from the outside world. Program structure includes types, array sizes, field names, enum tags, build options, and fixed configuration. Outside-world information includes user input, files, network data, database...

Writes › Book › Zig › Appendix ›

Appendix F. Build Modes Reference

Appendix F. Build Modes Reference When Zig compiles a program, it can build the program in different modes. A build mode changes things like: optimization level runtime safety checks debug information binary size execution speed You choose the mode depending on what you are doing. During development, you usually want safety and debugging support. For production releases, you usually want speed or smaller binaries. F.1 The Four Main Build Modes...

Writes › Book › Zig › Part 24. Reading and Contributing to Zig ›

Code Generation

Code Generation Code generation is the compiler stage that turns analyzed program meaning into target code. At this point, the compiler has already parsed the source code and checked that the program is valid. It knows the types, declarations, function calls, control flow, error paths, comptime results, and target platform. Now it must produce something the machine can use. A rough pipeline looks like this: Zig source code ↓ AST...

Writes › Book › Zig › Part 23. Real Projects ›

Build a Thread Pool

Build a Thread Pool A thread pool is a group of worker threads that wait for jobs. Instead of creating a new thread for every task, you create a fixed number of threads once. Then you send jobs to them. This is useful because creating threads is expensive. Reusing threads is cheaper and more predictable. A thread pool usually has this shape: main thread creates worker threads pushes jobs into...

Writes › Book › Zig › Part 22. Cross-Platform Development ›

ARM and Embedded Targets

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 ARM, you are usually writing for a specific machine, not just for “ARM” in general. For beginners, the first idea is this: a target is more than an operating system. It includes the CPU architecture, the operating system, the ABI,...

Writes › Book › Zig › Part 21. Advanced Zig ›

Writing a Game Engine Core

Writing a Game Engine Core A game engine core is the small central layer that runs the game. It does not need to contain everything. A serious engine may have rendering, physics, audio, networking, animation, scripting, asset loading, editor tools, and platform layers. The core is smaller than that. The core usually answers these questions: What objects exist? How is game state stored? What code runs each frame? How does...

Writes › Book › Zig › Part 20. Performance and Optimization ›

Why Allocations Cost Time

Reducing Allocations Allocations are one of the most common causes of slow programs. An allocation asks an allocator for memory at runtime. In Zig, that usually looks like this: const buffer = try allocator.alloc(u8, 1024); defer allocator.free(buffer); This code is clear. It says exactly where memory comes from and where it is released. But clarity does not make allocation free. If this code runs once, it probably does not matter....

Writes › Book › Zig › Part 19. Systems Programming ›

Binary File Formats

Binary File Formats A binary file format stores data as bytes with a specific structure. Text files store data as readable characters: name: Alice age: 30 Binary files store data in compact byte layouts: 41 4C 49 43 45 1E Those bytes may represent a name, an integer, a timestamp, an image, a database page, an executable header, or anything else. The bytes only make sense if you know the...

Writes › Book › Zig › Part 18. Concurrency and Async ›

Condition Variables

Condition Variables A condition variable lets one thread sleep until another thread says that something has changed. It is used with a mutex. The mutex protects the shared data. The condition variable lets waiting threads wake up when that data may now be ready. The Problem Suppose one thread produces work, and another thread consumes work. The consumer should not run forever checking: while (queue_is_empty) { // keep checking }...

Writes › Book › Zig › Part 17. Interfacing with C ›

Linking C Libraries

Linking C Libraries Importing a C header lets Zig understand a C API. Linking gives the final program the actual compiled code. These are separate steps. A header file says what exists: // mathlib.h int add(int a, int b); A source file or library provides the implementation: // mathlib.c #include "mathlib.h" int add(int a, int b) { return a + b; } In Zig, this import only reads the declaration:...

Writes › Book › Zig › Part 16. Testing and Debugging ›

Stack Traces

Stack Traces A stack trace shows how your program reached a failure. When a program crashes, the most important question is not only “what failed?” It is also “how did the program get there?” A stack trace answers that second question. A Simple Crash Look at this program: const std = @import("std"); fn third() void { unreachable; } fn second() void { third(); } fn first() void { second(); }...

Writes › Book › Zig › Part 15. Build System and Tooling ›

Cross Compilation

Cross Compilation Cross compilation means building a program for a different machine than the one you are using. For example, you might write code on macOS but build a Linux executable. Or you might write code on an x86_64 laptop but build for an ARM server, a Raspberry Pi, or WebAssembly. Zig is especially strong at cross compilation because the compiler has built-in target support. In many cases, you do...

Writes › Book › Zig › Part 14. The Standard Library ›

Directories and Paths

Directories and Paths A file lives inside a directory. A directory is a container for file names and other directories. Many systems call directories “folders,” but in programming, “directory” is the more common term. A path is a name that tells the operating system where something is. For example: hello.txt is a path. src/main.zig is also a path. /home/alice/project/src/main.zig is another path. When your program reads or writes files, it...

Writes › Book › Zig › Part 13. Collections and Data Structures ›

Why Bit Sets Matter

Bit Sets A bit set is a compact collection of yes-or-no values. Each value has only two states: true or false present or absent enabled or disabled visited or not visited A normal array of booleans is easy to understand: index: 0 1 2 3 value: true false true false But each boolean may take more space than one bit in memory. A bit set stores each yes-or-no value as...

Writes › Book › Zig › Part 12. Allocators and Memory Management ›

Memory Leak Detection

Memory Leak Detection A memory leak happens when a program allocates memory and then loses the ability to free it. Here is the simplest leak: const std = @import("std"); pub fn main() !void { var gpa = std.heap.GeneralPurposeAllocator(.{}){}; defer _ = gpa.deinit(); const allocator = gpa.allocator(); _ = try allocator.alloc(u8, 1024); } The program asks for 1024 bytes, but it never stores the slice in a useful place and never...

Writes › Book › Zig › Part 11. Zig Builtins ›

`@memcpy`

@memcpy @memcpy copies bytes from one memory region to another. The name means “memory copy.” You use it when you already have destination memory and source memory, and you want the destination to receive the source bytes. @memcpy(destination, source); The destination and source are usually slices. A Simple Example const std = @import("std"); pub fn main() void { var dst = [_]u8{ 0, 0, 0, 0 }; const src =...

Writes › Book › Zig › Part 10. Compile-Time Programming ›

Metaprogramming Patterns

Metaprogramming Patterns Metaprogramming means writing code that helps create, inspect, or specialize other code. In Zig, metaprogramming is mostly built from a few simple tools: Tool Purpose comptime Run code during compilation comptime T: type Pass a type into a function anytype Let the compiler infer a generic parameter inline for Expand repeated code at compile time @typeInfo Inspect a type @field Access a field by name @hasDecl Check whether...

Writes › Book › Zig › Part 6. Pointers and Memory ›

Volatile and Atomic Memory

Volatile and Atomic Memory Most memory in Zig is ordinary memory. You read it. You write it. The compiler is allowed to optimize those reads and writes as long as the program behaves the same according to normal language rules. But some memory is special. Sometimes a memory address is connected to hardware. Sometimes another thread can read or write the same memory at the same time. Sometimes a value...

Writes › Book › Zig › Appendix ›

Appendix E. Memory Safety Checklist

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. This checklist gives you a practical way to avoid common memory bugs. E.1 Initialize Before Reading Do not read a value before it has a real value. var x: i32 = undefined; This is allowed, but x has no meaningful value yet. Bad: var x:...

Writes › Book › Zig › Part 24. Reading and Contributing to Zig ›

Semantic Analysis

Semantic Analysis Semantic analysis is the compiler stage that checks what a program means. Parsing checks the shape of the code. Semantic analysis checks whether that shape is valid according to the rules of Zig. For example, this code has a valid shape: const x: u8 = 300; The parser can understand it. It sees a constant declaration named x , with type u8 , initialized with the integer literal...

Writes › Book › Zig › Part 16. Testing and Debugging ›

Debug Builds

Debug Builds A debug build is a build made for finding mistakes. When you are learning Zig, most of your work should happen in debug mode. It gives you stronger safety checks, better error messages, and more useful stack traces. It is slower than an optimized release build, but that is the point. While developing, correctness matters more than speed. Build Modes Zig programs can be built in different optimization...

Writes › Book › Zig › Part 22. Cross-Platform Development ›

WebAssembly

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, embedded runtimes, and command-line Wasm engines. Zig can compile to WebAssembly. This makes Zig useful for small browser modules, plugin systems, sandboxed code, portable command-line logic, games, interpreters, and compute-heavy functions that need predictable low-level control. A normal Zig program has...

Writes › Book › Zig › Part 6. Pointers and Memory ›

Memory Safety in Zig

Memory Safety in Zig Memory safety means using memory only while it is valid, only through the right type, and only inside the allowed range. Zig gives you direct control over memory, but it also gives you checks and language rules that help catch mistakes. It does not remove the need to think. Instead, it makes many memory rules visible in the code. A Zig programmer should care about four...

Writes › Book › Zig › Part 12. Allocators and Memory Management ›

Allocation Failure Handling

Allocation Failure Handling Allocation can fail. This is one of the most important facts in Zig memory management. When your program asks for heap memory, the request may not succeed. The system may be out of memory. A fixed buffer may be full. A custom allocator may reject the request because of a memory limit. Zig does not hide this. When you allocate memory, the result is usually an error...

Writes › Book › Zig › Part 11. Zig Builtins ›

`@bitCast`

@bitCast @bitCast reinterprets the bits of one value as another type. It does not do a normal conversion. It does not change the bits. It takes the same raw bit pattern and gives it a new type. A Simple Example Suppose you have a u32 : const x: u32 = 0x3f800000; Those 32 bits can also be interpreted as an f32 . const y: f32 = @bitCast(x); The value of...

Writes › Book › Zig › Part 10. Compile-Time Programming ›

Static Dispatch

Static Dispatch Static dispatch means the compiler decides which code to call before the program runs. This is different from dynamic dispatch, where the program decides which code to call while it is running. In Zig, static dispatch is common because types are known at compile time. When a function receives a comptime T: type , the compiler can specialize the function for that exact type. A Simple Example Look...

Writes › Book › Zig › Part 9. Optionals and Advanced Types ›

Type Reflection Basics

Type Reflection Basics Type reflection means asking questions about a type while Zig is compiling the program. In Zig, types are values at compile time. That means code can inspect a type, make decisions from it, and use those decisions to generate normal runtime code. The main tool for this is: @typeInfo(T) where T is a type. For example: const info = @typeInfo(i32); This asks Zig: What kind of type...

Writes › Book › Zig › Part 8. Structs, Enums, and Unions ›

Data-Oriented Design

Data-Oriented Design Data-oriented design means you organize a program around the data it processes. The main question is not “Which objects do I need?” The main question is: What data do I have, and how will the program move through it? This style fits Zig well because Zig gives you direct control over memory layout, allocation, arrays, slices, structs, and pointers. Start with the Data Suppose you are writing a...

Writes › Book › Zig › Part 7. Arrays, Slices, and Strings ›

Efficient Text Processing

Efficient Text Processing Efficient text processing means working with text without doing unnecessary allocation, copying, or decoding. In Zig, text is usually a byte slice: []const u8 That means most text processing starts with a simple idea: read bytes first allocate only when needed decode UTF-8 only when needed This fits Zig well because Zig makes memory and ownership visible. Prefer Slices Over Copies A slice lets you refer to...

Writes › Book › Zig › Part 20. Performance and Optimization ›

Why SIMD Matters

SIMD and Vectorization SIMD means Single Instruction, Multiple Data. It is a CPU feature that lets one instruction operate on several values at the same time. A normal instruction might add one pair of numbers: a + b A SIMD instruction can add several pairs at once: [a0, a1, a2, a3] + [b0, b1, b2, b3] The result is: [a0 + b0, a1 + b1, a2 + b2, a3 +...

Writes › Book › Zig › Part 21. Advanced Zig ›

Embedded Development

Embedded Development Embedded development means writing software for small computers inside devices. These devices may be: microcontrollers sensors robots keyboards drones medical devices industrial controllers network appliances small displays motor controllers An embedded program often runs close to the hardware. It may not have an operating system. It may not have a filesystem. It may not have dynamic memory. It may only have a few kilobytes of RAM. Zig is...

Writes › Book › Zig › Appendix ›

Appendix D. Important Standard Library APIs

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...

Writes › Book › Zig › Part 12. Allocators and Memory Management ›

Custom Allocators

Custom Allocators A custom allocator is an allocator you design for a specific memory policy. Most beginner Zig programs use allocators from the standard library: std.heap.GeneralPurposeAllocator std.heap.ArenaAllocator std.heap.FixedBufferAllocator std.heap.page_allocator These cover many common cases. But Zig also lets you build your own allocator when the standard choices do not match your program. A custom allocator answers the same basic questions as every other allocator: Where does the memory come from?...

Writes › Book › Zig › Part 11. Zig Builtins ›

`@ptrCast`

@ptrCast @ptrCast converts one pointer type into another pointer type. It does not move memory. It does not copy memory. It does not change the bytes stored in memory. It only changes how Zig views the pointer. That makes it powerful, but also dangerous if used carelessly. The Basic Idea Suppose you have a pointer to one type: const p: *u32 = undefined; Sometimes low-level code needs to view the...

Writes › Book › Zig › Part 6. Pointers and Memory ›

Dangling Pointers

Dangling Pointers A dangling pointer is a pointer that refers to memory that is no longer valid. The pointer still contains an address, but the value at that address no longer belongs to the thing the pointer thinks it points to. This is one of the most serious bugs in low-level programming. A dangling pointer can cause wrong results, crashes, memory corruption, or security problems. A Simple Dangling Pointer This...

Writes › Book › Zig › Part 10. Compile-Time Programming ›

Building Generic Data Structures

Building Generic Data Structures A generic data structure is a data structure that works with more than one element type. For example, an array list of u8 stores bytes. An array list of i32 stores signed integers. An array list of User stores User values. The behavior is mostly the same, but the element type changes. Zig does not use classes, inheritance, or a separate template language for this. Zig...

Writes › Book › Zig › Part 9. Optionals and Advanced Types ›

Type Coercion

Type Coercion Type coercion means Zig converts a value from one type to another when the conversion is safe and well-defined. For example: const x: u8 = 10; const y: u16 = x; Here, x is a u8 . y is a u16 . Zig allows this because every u8 value can fit inside a u16 . A u8 can hold values from 0 to 255 . A u16 can...

Writes › Book › Zig › Part 8. Structs, Enums, and Unions ›

Modeling State Machines

Modeling State Machines A state machine is a simple way to describe a program that moves between fixed states. For example, a network connection may be: disconnected connecting connected closing At any moment, it is in exactly one state. It is not both connected and closing . It is one state, then another state, then another. This is exactly the kind of problem where Zig enums and tagged unions are...

Writes › Book › Zig › Part 7. Arrays, Slices, and Strings ›

Building Dynamic Strings

Building Dynamic Strings A dynamic string is text whose length is not fixed ahead of time. In Zig, dynamic strings are usually built as dynamic byte arrays. The most common tool is: std.ArrayList(u8) This means a growable list of bytes. Since Zig represents text as UTF-8 bytes, a growable list of u8 values works well for building strings. Why Dynamic Strings Need Memory A fixed array has a fixed size:...

Writes › Book › Zig › Part 15. Build System and Tooling ›

Build Options

Build Options A build option is a value passed from the command line into build.zig . Build options let one project support several build configurations without editing source code every time. You can use them for feature flags, version strings, debug behavior, optional integrations, platform choices, and other settings. A build option is usually passed with -D : zig build -Denable-logging=true zig build -Dapp-version=0.1.0 zig build -Dmax-clients=128 The -D means...

Writes › Book › Zig › Part 13. Collections and Data Structures ›

The Basic Difference

Queues and Stacks Queues and stacks are two simple ways to organize a collection of items. They are not complicated data structures. Their power comes from the rules they enforce. A stack gives you the last item first. A queue gives you the first item first. These rules appear everywhere in programming: parsers, schedulers, interpreters, graph algorithms, job systems, undo history, message processing, and event loops. The Basic Difference A...

Writes › Book › Zig › Part 12. Allocators and Memory Management ›

Page Allocator

Page Allocator The page allocator asks the operating system for memory directly. It works at the level of memory pages. A page is a fixed-size block of memory managed by the operating system. On many systems, one page is 4096 bytes, but you should not hard-code that assumption unless you have a reason. The page allocator is available as: const allocator = std.heap.page_allocator; A small example: const std = @import("std");...

Writes › Book › Zig › Part 11. Zig Builtins ›

`@typeInfo`

@typeInfo @typeInfo asks the compiler for structured information about a type. Example: const info = @typeInfo(u32); This means: Tell me what kind of type u32 is. The answer is not a string. It is a compile-time value that describes the type. For u32 , the information says: this is an integer type, it is unsigned, and it has 32 bits. @typeInfo Takes a Type This is the normal form: const...

Writes › Book › Zig › Part 10. Compile-Time Programming ›

Reflection with `@typeInfo`

Reflection with @typeInfo Reflection means inspecting a type as data. In ordinary code, you use a type: const User = struct { id: u64, name: []const u8, }; You create values of that type: const user = User{ .id = 1, .name = "Ada", }; With reflection, you ask questions about the type itself: What kind of type is it? Is it a struct? What fields does it have? What...

Writes › Book › Zig › Part 9. Optionals and Advanced Types ›

Error Union Internals

Error Union Internals An error union is a value that can contain either: an error or: a successful value You have already seen this shape: fn readNumber() !i32 { return 42; } The return type is: !i32 This means: either an error, or an i32 You can also write the error set explicitly: fn readNumber() error{InvalidInput}!i32 { return 42; } This means: either error.InvalidInput, or an i32 The short form:...

Writes › Book › Zig › Part 8. Structs, Enums, and Unions ›

Union Safety

Union Safety A union stores one active field at a time. That is the most important rule. A struct groups fields together: const Point = struct { x: i32, y: i32, }; A Point has both x and y . A union chooses one field: const Value = union(enum) { int: i64, text: []const u8, flag: bool, }; A Value is either an int , or a text , or...

Writes › Book › Zig › Part 7. Arrays, Slices, and Strings ›

UTF-8 Processing

UTF-8 Processing Zig string data is usually stored as UTF-8 bytes. That means a string is not a list of “characters” in the simple beginner sense. It is a sequence of bytes, and those bytes encode text. const text = "Zig"; This string has 3 bytes: Z i g But this string: const text = "é"; has 2 bytes, even though it looks like 1 character. That is the first...

Writes › Book › Zig › Part 6. Pointers and Memory ›

Stack vs Heap

Stack vs Heap Zig programs use memory in different places. The two most important places are the stack and the heap. The stack is used for local values and function calls. The heap is used for memory requested from an allocator. Both are ordinary memory, but they are managed differently. Understanding this difference is necessary before you write programs that allocate buffers, build dynamic arrays, return data from functions, or...

Writes › Book › Zig › Part 19. Systems Programming ›

Terminal Programming

Terminal Programming Terminal programming means writing programs that interact with the command line as more than simple text output. A basic program prints text: std.debug.print("hello\n", .{}); A terminal program may also read keys, move the cursor, clear the screen, draw text interfaces, use colors, hide the cursor, or read input without waiting for the user to press Enter. This is useful for command-line tools, text editors, shells, debuggers, log viewers,...

Writes › Book › Zig › Part 23. Real Projects ›

Build a Static File Server

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. For example, suppose you have this directory: public/ index.html style.css app.js A browser can request: / The server returns: public/index.html A browser can request: /style.css The server returns: public/style.css This project teaches file paths, networking, HTTP basics, error handling, and safe input handling. A...

Writes › Book › Zig › Part 11. Zig Builtins ›

`@Type`

@Type @Type builds a type from compile-time type information. That sounds abstract, so start with the simple version: const MyInt = u32; Here, MyInt is just another name for the type u32 . But @Type lets you create a type from a structured description: const T = @Type(.{ .int = .{ .signedness = .unsigned, .bits = 32, }, }); This creates the type u32 . You will not use @Type...

Writes › Book › Zig › Part 10. Compile-Time Programming ›

Generating Code at Compile Time

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. This does not mean Zig writes a new .zig file for you. It means the compiler executes compile-time logic and uses the result to build the final program. In Zig, compile-time code generation usually comes from: Feature What It Does comptime parameters Pass types, sizes,...

Writes › Book › Zig › Part 9. Optionals and Advanced Types ›

`anytype`

anytype anytype means the function parameter can accept many different types. It is Zig’s simplest way to write a generic function. Here is a normal function: fn double(x: i32) i32 { return x * 2; } This works only with i32 . const a = double(10); But this does not work: const b = double(1.5); // error The function expects an i32 , not a floating-point number. With anytype ,...

Writes › Book › Zig › Part 8. Structs, Enums, and Unions ›

Tagged Unions

Tagged Unions A tagged union is a type that can store one value from several possible shapes. Use a tagged union when a value can be different kinds of things, and each kind may carry different data. For example, imagine a command-line program that accepts several commands: const Command = union(enum) { quit, help, open: []const u8, write: []const u8, }; This says a Command can be one of four...

Writes › Book › Zig › Part 6. Pointers and Memory ›

Sentinel-Terminated Arrays

Sentinel-Terminated Arrays A sentinel-terminated array is an array with a special value at the end. That special value is called the sentinel. The sentinel marks where the useful data stops. The most common sentinel is 0 . C strings use this idea. A C string is a sequence of bytes ending with a zero byte. h e l l o 0 The useful text is: hello The final 0 is...

Writes › Book › Zig › Part 9. Optionals and Advanced Types ›

Opaque Types

Opaque Types An opaque type is a type whose internal structure is hidden. In Zig, you write an opaque type with opaque {} . const Handle = opaque {}; This defines a type named Handle , but it does not say what fields Handle has. You cannot create a normal Handle value directly. You also cannot access fields inside it. The whole point is that the inside is unknown. Opaque...

Writes › Book › Zig › Appendix ›

Appendix C. Common Compiler Errors

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. At first, Zig error messages can feel strict. That is normal. The compiler is teaching you how Zig thinks about types, memory, errors, and control flow. This appendix explains common errors beginners see, why they happen, and how to fix them. C.1 “unused local constant” Example:...

Writes › Book › Zig › Part 7. Arrays, Slices, and Strings ›

Mutable Strings

Mutable Strings Zig does not have a separate built-in mutable String type. Text is usually stored as bytes. If the bytes are read-only, you use []const u8 . If the bytes can change, you use []u8 . []const u8 // read-only bytes []u8 // mutable bytes A string literal is read-only: const name = "zig"; You cannot change it: name[0] = 'Z'; // error To change text, you need mutable...

Writes › Book › Zig › Part 8. Structs, Enums, and Unions ›

Enums

Enums An enum is a type whose value must be one item from a fixed list. Use an enum when a value has a small number of named choices. For example, a traffic light can be red, yellow, or green: const TrafficLight = enum { red, yellow, green, }; This defines a new type named TrafficLight . A value of this type can only be one of these: TrafficLight.red TrafficLight.yellow...

Writes › Book › Zig › Part 13. Collections and Data Structures ›

Why Linked Lists Exist

Linked Lists A linked list is a collection where each item points to the next item. An array stores items beside each other in memory: [10][20][30][40] A linked list stores items as separate nodes: [10] -> [20] -> [30] -> [40] Each node contains two things: value pointer to next node That pointer connects the nodes into a chain. Why Linked Lists Exist With an array or ArrayList , the...

Writes › Book › Zig › Part 17. Interfacing with C ›

Using C Structs

Using C Structs A C struct groups several fields into one value. For example: struct Point { int x; int y; }; This defines a value with two fields: x y In Zig, you can use C structs in two main ways. You can import a struct from a C header. You can define a C-compatible struct yourself with extern struct . Both are useful. Importing a C Struct Suppose...

Writes › Book › Zig › Part 16. Testing and Debugging ›

Fuzz Testing

Fuzz Testing Fuzz testing means testing a program with many generated inputs. A normal unit test checks examples that you choose by hand: try std.testing.expectEqual(@as(u8, 5), parseDigit('5')); A fuzz test checks many inputs automatically. Instead of asking only “does this work for '5' ?”, it asks a broader question: Can this code survive many possible inputs without crashing, corrupting memory, or violating its rules? Why Fuzz Testing Exists Hand-written tests...

Writes › Book › Zig › Part 12. Allocators and Memory Management ›

Fixed Buffer Allocator

Fixed Buffer Allocator A fixed buffer allocator gives memory from a buffer you already own. It does not ask the operating system for more memory. It does not grow without limit. It can only allocate from the fixed slice you give it. That makes it useful when you want strict control. fixed buffer = known amount of memory fixed buffer allocator = allocator that uses that memory A First Example...

Writes › Book › Zig › Part 11. Zig Builtins ›

`@alignOf`

@alignOf @alignOf asks the Zig compiler for the required memory alignment of a type. Example: const a = @alignOf(u32); This means: “What alignment does u32 need?” On many targets, u32 has alignment 4 . That means a u32 value should usually start at a memory address divisible by 4. What Alignment Means Memory is a long sequence of bytes. Each byte has an address: address: 0 1 2 3 4...

Writes › Book › Zig › Part 10. Compile-Time Programming ›

Compile-Time Loops

Compile-Time Loops A compile-time loop is a loop that runs while Zig is compiling your program. The loop does not run after the final executable starts. The compiler runs it earlier, uses the result, and then produces normal machine code. This is useful when the loop works with information that is already known: types, fixed lists, array sizes, field names, enum tags, build options, or constant values. Runtime Loops A...

Writes › Book › Zig › Part 24. Reading and Contributing to Zig ›

How Parsing Works

How Parsing Works Parsing is the part of the compiler that reads source code and turns it into structure. When you write a Zig file, you write plain text: pub fn main() void { const x = 10 + 20; } The compiler cannot understand this text directly as a program. First, it must break the text into smaller pieces. Then it must organize those pieces into a tree. That...

Writes › Book › Zig › Part 15. Build System and Tooling ›

Adding Dependencies

Adding Dependencies A Zig project can depend on other Zig packages. A dependency is code that lives outside your project but is used by your project. It might be a library for parsing JSON, handling command-line flags, working with databases, building web servers, writing tests, or sharing common code between several projects. In Zig, dependencies are described in two main places: build.zig.zon build.zig The build.zig.zon file lists the package dependencies....

Writes › Book › Zig › Part 22. Cross-Platform Development ›

macOS Support

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. For beginners, the main idea is simple: macOS is Unix-like, so many habits from Linux also apply. It uses / paths, terminals, permissions, stdin, stdout, stderr, pipes, and exit codes. But macOS also has its own system libraries, application model, security rules, and...

Writes › Book › Zig › Part 14. The Standard Library ›

Writing Files

Writing Files Writing a file means sending bytes from your program to the operating system so they can be stored on disk. Reading files and writing files are closely related. In both cases, you work with bytes. The main difference is direction. When reading, bytes move from a file into your program. When writing, bytes move from your program into a file. In Zig, writing files usually follows this pattern:...

Writes › Book › Zig › Part 18. Concurrency and Async ›

Atomics

Atomics An atomic operation is a small operation that can safely happen while several threads are running. Atomics are used for simple shared values, such as counters, flags, indexes, and state markers. They are lower-level than mutexes. They can be faster in some cases, but they are also easier to misuse. Use atomics when the shared operation is small and independent. Use a mutex when several pieces of data must...

Writes › Book › Zig › Part 6. Pointers and Memory ›

Alignment

Alignment Alignment is a rule about where a value may be placed in memory. Every value has a size. Many values also have an alignment requirement. The size tells you how many bytes the value occupies. The alignment tells you what kind of address is acceptable for the value. For example, a u8 can usually live at any byte address. A u32 often wants to live at an address divisible...

Writes › Book › Zig › Part 5. Error Handling ›

Panic and Crash Behavior

Panic and Crash Behavior Errors are for expected failures. Panics are for broken assumptions. This is the most important difference. A missing file can be an error. Invalid user input can be an error. A network timeout can be an error. These are normal things that can happen while the program is running. But an out-of-bounds array index, an impossible state, or a violated invariant usually means the program logic...

Writes › Book › Zig › Part 21. Advanced Zig ›

Plugin Architectures

Plugin Architectures A plugin architecture lets a program be extended without rewriting the whole program. The main program provides a stable core. Plugins add behavior around that core. Examples: text editor plugins database extensions compiler passes game engine modules image processing filters web server middleware command-line subcommands The basic idea is simple: core program + plugin interface + plugin implementations The hard part is designing the boundary between the core...

Writes › Book › Zig › Part 20. Performance and Optimization ›

The Basic Idea

Cache-Friendly Design Modern CPUs are fast, but memory is much slower. This is one of the most important facts in performance work. A simple arithmetic instruction may be cheap, while waiting for memory may be expensive. A program that keeps data close together in memory can be much faster than a program that constantly jumps around. Cache-friendly design means arranging data and code so the CPU can read memory efficiently....

Writes › Book › Zig › Part 19. Systems Programming ›

Working with the OS

Working with the OS Systems programming means working directly with the operating system. The operating system gives your program access to files, processes, memory, clocks, terminals, environment variables, network sockets, permissions, and hardware-backed resources. Zig can use all of these, but it usually gives you two levels of access. The first level is portable standard library code. This is what you should use first. std.fs std.io std.process std.Thread std.time std.net...

Writes › Book › Zig › Part 5. Error Handling ›

Custom Error Types

Custom Error Types Most Zig programs start with small error sets: const ParseError = error{ InvalidDigit, EmptyInput, }; This is enough for many cases. But larger programs often need more structure. Different modules may define their own error sets. Some errors may need to be grouped, mapped, or exposed differently across API boundaries. This chapter explains how to design and organize your own error types. Error Sets Are Types An...

Writes › Book › Zig › Part 4. Functions ›

Zig Generics Use `comptime`

Generic Functions A generic function is a function that works with many types instead of only one type. Without generics, you often duplicate code. Example: fn addI32(a: i32, b: i32) i32 { return a + b; } Then later: fn addF64(a: f64, b: f64) f64 { return a + b; } The logic is identical. Only the types change. Generic functions solve this problem. Zig Generics Use comptime Zig implements...

Writes › Book › Zig › Part 23. Real Projects ›

Build a JSON Parser

Build a JSON Parser A JSON parser reads JSON text and turns it into data your program can use. JSON looks like this: { "name": "Zig", "year": 2016, "systems_language": true } A parser does not just store this as text. It understands the structure: object name -> string "Zig" year -> number 2016 systems_language -> boolean true In this section, we will build a small JSON parser for a limited...

Writes › Book › Zig › Appendix ›

Appendix B. Zig Cheat Sheet

Appendix B. Zig Cheat Sheet B.1 Basic Program const std = @import("std"); pub fn main() void { std.debug.print("Hello, Zig!\n", .{}); } main is where the program starts. std is the standard library. std.debug.print prints formatted text. B.2 Build and Run zig run main.zig Compile and run one file. zig build-exe main.zig Compile one file into an executable. zig test main.zig Run tests in one file. zig build Run the project...

Writes › Book › Zig › Part 9. Optionals and Advanced Types ›

Vectors

Vectors A vector is a fixed-size group of values of the same type. In Zig, vector types are written like this: @Vector(length, ElementType) For example: const Vec4 = @Vector(4, i32); This means: a vector with 4 i32 values A value of this type holds four integers together: const a: @Vector(4, i32) = .{ 1, 2, 3, 4 }; You can think of it as a small fixed-size array, but with...

Writes › Book › Zig › Part 8. Structs, Enums, and Unions ›

Anonymous Structs

Anonymous Structs An anonymous struct is a struct type without a name. You have already seen named structs: const Point = struct { x: i32, y: i32, }; Here, the struct type has a name: Point . An anonymous struct does not have a declared name: const p = .{ .x = 10, .y = 20, }; This creates a value with two fields, x and y , but we...

Writes › Book › Zig › Part 7. Arrays, Slices, and Strings ›

String Literals

String Literals A string literal is text written directly in your source code. const name = "Zig"; The text between the double quotes is the string literal: "Zig" In Zig, strings are bytes. More precisely, a string literal is a constant sequence of UTF-8 bytes. That means "Zig" contains these three visible bytes: Z i g Their byte values are: 90 105 103 Zig does not have a special built-in...

Writes › Book › Zig › Part 6. Pointers and Memory ›

Pointer Arithmetic

Pointer Arithmetic Pointer arithmetic means moving a pointer forward or backward through memory. In Zig, pointer arithmetic is not available on every pointer type. A single item pointer points to one value, so it does not support normal indexing or arithmetic. A many item pointer points into a sequence, so it can be moved. *T // single item pointer [*]T // many item pointer A *T means “pointer to one...

Writes › Book › Zig › Part 5. Error Handling ›

Designing Error APIs

Designing Error APIs An error API is the part of your function signature that tells callers how failure works. In Zig, this is not hidden. A function that can fail shows that fact in its return type: fn loadConfig() !Config { // ... } The !Config return type says: this function returns either an error or a Config That is already an API decision. You are telling callers that loading...

Writes › Book › Zig › Part 4. Functions ›

What “Exported” Means

Exported Functions An exported function is a function made visible outside the current Zig program. Normally, functions only exist inside the compiled program itself. Example: fn add(a: i32, b: i32) i32 { return a + b; } This function is internal. Other programs cannot see it. An exported function changes that. Example: export fn add( a: i32, b: i32, ) i32 { return a + b; } Now the function...

Writes › Book › Zig › Part 17. Interfacing with C ›

Calling C Functions

Calling C Functions Calling a C function from Zig has three parts. First, Zig must know the C function exists. Second, the final executable must link to the compiled C code. Third, your Zig code must call the function using the right types. A header gives Zig the declaration: // mathlib.h int add(int a, int b); A C file gives the linker the implementation: // mathlib.c #include "mathlib.h" int add(int...

Writes › Book › Zig › Part 12. Allocators and Memory Management ›

Arena Allocator

Arena Allocator An arena allocator is an allocator that frees many allocations at once. This is useful when several pieces of memory have the same lifetime. For example, imagine a parser. It may allocate many small objects while reading a file: tokens syntax nodes temporary strings metadata You usually do not want to free each object one by one. You want to keep all of them while parsing, then free...

Writes › Book › Zig › Part 13. Collections and Data Structures ›

Why StringHashMap Exists

StringHashMap A StringHashMap is a hash map where the key is a string. In Zig, a string is usually a slice of bytes: []const u8 So this: std.StringHashMap(u32) means: string -> u32 Examples: "alice" -> 120 "bob" -> 95 "charlie" -> 180 Use StringHashMap when you want to look up values by text. Why StringHashMap Exists You already saw AutoHashMap . For number keys, this is fine: std.AutoHashMap(u32, []const u8)...

Writes › Book › Zig › Part 16. Testing and Debugging ›

Table-Driven Tests

Table-Driven Tests A table-driven test checks many input cases with one test loop. Instead of writing many separate tests like this: test "double handles one" { try std.testing.expectEqual(@as(i32, 2), double(1)); } test "double handles two" { try std.testing.expectEqual(@as(i32, 4), double(2)); } test "double handles ten" { try std.testing.expectEqual(@as(i32, 20), double(10)); } You put the cases in a small table: const std = @import("std"); fn double(n: i32) i32 { return n...

Writes › Book › Zig › Part 11. Zig Builtins ›

`@sizeOf`

@sizeOf @sizeOf asks the Zig compiler how many bytes a type needs in memory. Example: const n = @sizeOf(u32); For u32 , the result is 4 , because a 32-bit unsigned integer uses 4 bytes. A byte is 8 bits. So: u8 = 1 byte u16 = 2 bytes u32 = 4 bytes u64 = 8 bytes The name @sizeOf means “size of this type.” @sizeOf Takes a Type @sizeOf...

Writes › Book › Zig › Part 10. Compile-Time Programming ›

Inline Branching

Inline Branching Inline branching means Zig chooses a branch during compilation, not during runtime. This is closely related to comptime . When a condition is known at compile time, Zig can decide which path to keep before the final program is built. The result is specialized code. Runtime Branching A normal if usually runs at runtime. const std = @import("std"); pub fn main() void { var x: i32 = 10;...

Writes › Book › Zig › Part 6. Pointers and Memory ›

Optional Pointers

Optional Pointers An optional pointer is a pointer that may have no value. In Zig, a normal pointer must point to something valid. It cannot be null . var x: i32 = 10; const p: *i32 = &x; Here, p points to x . This is not allowed: const p: *i32 = null; A normal pointer says: I point to a valid i32. But sometimes a pointer needs to represent...

Writes › Book › Zig › Part 5. Error Handling ›

Propagating Errors

Propagating Errors Propagating an error means passing it to the caller instead of handling it immediately. In Zig, this is normal. Many functions are not the right place to decide what an error means. A low-level function may know that opening a file failed, but it may not know whether the program should retry, create a default file, print a warning, or stop. So the low-level function returns the error...

Writes › Book › Zig › Part 4. Functions ›

A Mental Model

Calling Conventions A calling convention defines how functions communicate at the machine level. When one function calls another, many low-level details must be agreed upon: where arguments are stored where return values go which registers are preserved how the stack is used how the function returns The calling convention defines these rules. Without calling conventions, separately compiled code could not safely call each other. Calling conventions are extremely important in:...

Writes › Book › Zig › Part 3. Control Flow ›

Compile Errors as Safety Checks

Compile Errors as Safety Checks A compile error means Zig refused to build your program. At first, this can feel annoying. You write code, run the compiler, and Zig stops you. But this is one of Zig’s main strengths. A compile error is often a safety check. It means Zig found a problem before the program ran. That is better than finding the same problem later as a crash, corrupted...

Writes › Book › Zig › Part 7. Arrays, Slices, and Strings ›

Slice Lifetimes

Slice Lifetimes A slice is a view into memory. It does not own the memory. It only points to memory that belongs to something else. That means a slice is valid only while the original memory is still valid. var numbers = [_]i32{ 10, 20, 30, 40 }; const part = numbers[1..3]; Here, part points into numbers . numbers: 10, 20, 30, 40 part: 20, 30 The slice part is...

Writes › Book › Zig › Part 9. Optionals and Advanced Types ›

Nullable Pointers

Nullable Pointers A pointer stores the address of a value in memory. In Zig, a normal pointer is expected to point to something valid. It is not supposed to be null . const ptr: *i32 = &value; The type *i32 means: a pointer to an i32 It does not mean: a pointer to an i32, or maybe nothing When a pointer may be missing, you must write that in the...

Writes › Book › Zig › Part 8. Structs, Enums, and Unions ›

Packed Structs

Packed Structs A normal Zig struct is designed for ordinary data modeling. const Point = struct { x: i32, y: i32, }; This is the right choice most of the time. You define fields, create values, pass them to functions, and access fields by name. A packed struct has a different purpose. A packed struct gives you tighter control over how fields are stored in memory. It is mainly used...

Writes › Book › Zig › Part 24. Reading and Contributing to Zig ›

Understanding Stage2

Understanding Stage2 When people talk about Zig compiler internals, they often mention stage2 . The name can be confusing at first because it sounds like a single feature. It is better to understand it as part of Zig’s compiler history. Zig started with an older compiler implementation. Over time, the project moved toward a newer compiler written mostly in Zig itself. That newer self-hosted compiler work was commonly called stage2...

Writes › Book › Zig › Part 4. Functions ›

A Simple Function

Inline Functions 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. Normally, calling a function works like this: caller -> jump to function -> run function -> return back Inlining changes this. Instead of jumping to the function, the compiler copies the function body directly into the caller. Conceptually: replace function call with...

Writes › Book › Zig › Part 3. Control Flow ›

Unreachable Code

Unreachable Code Some parts of a program should never run. For example: switch (status) { .ok => handleOk(), .failed => handleFailed(), } If every possible status value is handled, there should be no unknown case. But sometimes you need to tell Zig: this point should be impossible to reach. Zig gives you unreachable for that. unreachable; unreachable means: if the program reaches this point, something is wrong. A First Example...

Writes › Book › Zig › Part 24. Reading and Contributing to Zig ›

Zig Source Tree

Zig Source Tree When you first open the Zig source code repository, it can feel overwhelming. There are thousands of files. Some are Zig code. Some are C++. Some are generated files. Some belong to LLVM integration. Some belong to the standard library. Some belong to the compiler itself. A beginner often asks: Where should I start reading? The answer is: do not try to understand everything at once. The...

Writes › Book › Zig › Part 22. Cross-Platform Development ›

Linux Support

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 systems, command-line tools, and systems programming. For a beginner, the main idea is this: Zig can write ordinary Linux programs using the standard library, and it can also go lower when you need direct access to Linux system calls, files,...

Writes › Book › Zig › Part 21. Advanced Zig ›

Reflection Systems

Reflection Systems Reflection means a program can inspect information about types while the program is being compiled or running. Some languages provide runtime reflection. A program can ask questions like: What fields does this struct contain? What is the name of this type? How many arguments does this function take? In many languages, this information exists at runtime inside the final executable. Zig takes a different approach. Zig reflection is...

Writes › Book › Zig › Part 20. Performance and Optimization ›

Why Profiling Matters

Profiling When a program feels slow, your first job is not optimization. Your first job is measurement. Profiling is the process of measuring where your program spends time, allocates memory, or uses CPU resources. Without profiling, optimization becomes guessing. Good engineers do not guess. They measure first. Why Profiling Matters Suppose a program takes 10 seconds to finish. You may think the problem is: loops function calls allocations file access...

Writes › Book › Zig › Part 19. Systems Programming ›

System Calls

System Calls A system call is a request from your program to the operating system. Your program cannot directly do everything it wants. It cannot directly open files, create processes, read from the network, allocate virtual memory pages, or talk to hardware. Those operations belong to the operating system. So your program asks. That request is called a system call. A normal function call stays inside your program: const x...

Writes › Book › Zig › Part 18. Concurrency and Async ›

Mutexes

Mutexes A mutex is a lock for shared data. The word “mutex” means “mutual exclusion.” That means only one thread is allowed to enter a protected section of code at a time. You use a mutex when several threads need to access the same data, and at least one of them may change it. Why Mutexes Exist This code looks harmless: counter += 1; But it is not one simple...

Writes › Book › Zig › Part 17. Interfacing with C ›

`@cImport`

@cImport @cImport is Zig’s built-in way to import C declarations from header files. A C header file describes functions, structs, constants, enums, and macros. Zig can read that header, translate the declarations, and make them available inside Zig code. For example, this imports the C standard I/O header: const c = @cImport({ @cInclude("stdio.h"); }); After that, you can call C functions through c : pub fn main() void { _...

Writes › Book › Zig › Part 14. The Standard Library ›

Reading Files

Reading Files Reading a file means asking the operating system for bytes stored on disk. A file may contain text, JSON, source code, an image, a database page, or any other data. At the lowest level, a file is just a sequence of bytes. In Zig, file reading teaches several important ideas at once: You must open the file. You must handle errors. You must close the file. You must...

Writes › Book › Zig › Part 16. Testing and Debugging ›

Writing Unit Tests

Writing Unit Tests A unit test checks one small piece of code in isolation. Usually, that “unit” is a single function. For example: fn multiply(a: i32, b: i32) i32 { return a * b; } A unit test for this function checks whether it behaves correctly: const std = @import("std"); test "multiply returns the product of two numbers" { try std.testing.expectEqual(@as(i32, 12), multiply(3, 4)); } The goal is simple: give...

Writes › Book › Zig › Part 15. Build System and Tooling ›

Creating Build Steps

Creating Build Steps A Zig build is made from steps. A step is one action in the build process. It might compile an executable, run tests, copy a file, generate code, or run a command. When you write: zig build Zig loads build.zig , creates a graph of steps, and runs the default step. The build graph is important. A build step can depend on another build step. If step...

Writes › Book › Zig › Part 13. Collections and Data Structures ›

The Basic Idea

HashMap A HashMap is a data structure for storing values by key. An array stores values by position: items[0] items[1] items[2] A hash map stores values by name, number, pointer, or another key: scores.get("alice") scores.get("bob") scores.get("charlie") The key tells the map where to find the value. The Basic Idea Suppose you want to store scores for players: alice -> 120 bob -> 95 charlie -> 180 You could use two...

Writes › Book › Zig › Part 12. Allocators and Memory Management ›

General Purpose Allocator

General Purpose Allocator The general purpose allocator is Zig’s standard allocator for ordinary heap allocation. Use it when your program needs heap memory, but you do not need a special strategy yet. It can allocate memory of different sizes, free memory in any order, and help detect memory mistakes during development. A small program usually starts like this: const std = @import("std"); pub fn main() !void { var gpa =...

Writes › Book › Zig › Part 11. Zig Builtins ›

`@import`

@import One of the first Zig builtins you will learn is @import . You have already seen it many times: const std = @import("std"); This imports Zig’s standard library and gives it the local name std . Without @import , your program would not know where std.debug.print comes from. @import is how Zig loads code from other files and modules. It is one of the most important builtins in the...

Writes › Book › Zig › Part 10. Compile-Time Programming ›

Compile-Time Variables

Compile-Time Variables In the previous section, you learned that Zig can execute code during compilation. Now we will look at compile-time variables. A compile-time variable is a variable that exists while the compiler is building the program. Its value is known completely before runtime begins. This is different from normal runtime variables. Runtime Variables Here is a normal runtime variable: pub fn main() void { var x: i32 = 10;...

Writes › Book › Zig › Part 5. Error Handling ›

`errdefer`

errdefer errdefer is a cleanup tool. It means: run this cleanup code only if the function returns with an error It is similar to defer , but more specific. defer runs when the function exits for any reason. errdefer runs only when the function exits because of an error. The Problem errdefer Solves Many functions build something step by step. For example, a function might: allocate memory open a file...

Writes › Book › Zig › Part 4. Functions ›

What Anonymous Functions Usually Mean

Anonymous Functions An anonymous function is a function without a permanent name. Many programming languages support anonymous functions heavily. JavaScript, Python, Rust, and Go all provide different forms of them. Zig takes a more conservative approach. Zig does not currently have full closure-based anonymous functions like JavaScript or Python. Instead, Zig prefers: named functions compile-time function generation structs with methods explicit state passing This design keeps behavior predictable and avoids...

Writes › Book › Zig › Part 3. Control Flow ›

Defer and Cleanup

Defer and Cleanup Many programs need to clean something up after using it. A program may need to: close a file free memory unlock a mutex restore a setting print a final message before leaving a scope Zig gives you defer for this. defer means: run this statement when the current scope ends. A First Example const std = @import("std"); pub fn main() void { std.debug.print("first\n", .{}); defer std.debug.print("third\n", .{});...

Writes › Book › Zig › Part 9. Optionals and Advanced Types ›

Optional Unwrapping

Optional Unwrapping Optional unwrapping means taking the value out of an optional. An optional value has this shape: const maybe_number: ?i32 = 42; The type is ?i32 , not i32 . That means you cannot use it directly as a normal integer: const doubled = maybe_number * 2; // error The compiler rejects this because maybe_number might be null . Before you can use the inner value, you must unwrap...

Writes › Book › Zig › Part 6. Pointers and Memory ›

Slices

Slices A slice is a view into a sequence of values. A slice does not own the values. It points to existing memory and stores how many items are available. The type of a slice looks like this: []T Read it as: slice of T For example: []u8 means: slice of u8 values And: []const u8 means: slice of read-only u8 values Slices are one of the most common types...

Writes › Book › Zig › Part 7. Arrays, Slices, and Strings ›

Slices in Detail

Slices in Detail A slice is a view into a sequence of values. It does not own the values. It points to values stored somewhere else. const values = [_]i32{ 10, 20, 30, 40 }; const part = values[1..3]; The slice part refers to this part of the array: 20, 30 It does not copy those values. It only describes where they are and how many there are. What a...

Writes › Book › Zig › Part 8. Structs, Enums, and Unions ›

Default Field Values

Default Field Values A struct field can have a default value. A default field value is used when you create a struct value and do not provide that field yourself. const Config = struct { port: u16 = 8080, debug: bool = false, }; This defines a struct type named Config . It has two fields: port: u16 = 8080 debug: bool = false The field port has the default...

Writes › Book › Zig › Part 5. Error Handling ›

`catch`

catch catch handles an error at the place where it happens. Use try when you want to pass the error to the caller. Use catch when you want to decide what to do right now. A function call that returns an error union has two possible outcomes: success: use the value failure: handle the error catch gives you the failure branch. Basic catch Suppose we have this function: const ParseError...

Writes › Book › Zig › Part 4. Functions ›

A First Example

Function Pointers Functions are values. That means a function can be: stored passed to another function selected dynamically called indirectly A function pointer stores the address of a function. Instead of calling a function directly: add(10, 20); you can store the function in a variable and call it later. This is called indirect function calling. Function pointers are important in: callbacks event systems plugin systems virtual machines game engines operating...

Writes › Book › Zig › Part 3. Control Flow ›

Inline Loops

Inline Loops Zig has normal loops that run when the program runs. for (items) |item| { process(item); } Zig also has inline loops. An inline loop is expanded by the compiler. That means the compiler does not treat it as an ordinary runtime loop. Instead, it repeats the loop body during compilation and generates code from the result. The two forms are: inline for (items) |item| { // repeated at...

Writes › Book › Zig › Appendix ›

Appendix A. Zig 0.16 New Features

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 interface design, language cleanup, standard library changes, build system improvements, compiler improvements, linker work, and fuzzer changes. A.1 A Note About “Zig 1.16” There is no official Zig 1.16 release. Zig has not reached...

Writes › Book › Zig › Part 24. Reading and Contributing to Zig ›

Zig Compiler Architecture

Zig Compiler Architecture The Zig compiler is not only a compiler for the Zig language. It is also the center of the Zig toolchain. When you install Zig, you get several tools in one executable: zig build-exe main.zig zig run main.zig zig test main.zig zig build zig cc zig c++ These commands look different, but they all go through the same toolchain. Zig can compile Zig code, run tests, build...

Writes › Book › Zig › Part 23. Real Projects ›

Build a CLI Calculator

Build a CLI Calculator In this project, we will build a small command-line calculator. The program will read an expression from the command line, parse it, compute the result, and print the answer. We will start with simple expressions like this: zig build run -- "1 + 2" Output: 3 Then: zig build run -- "10 - 4" Output: 6 And: zig build run -- "6 * 7" Output: 42...

Writes › Book › Zig › Part 22. Cross-Platform Development ›

Windows Support

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 cross-compile Windows programs from Linux or macOS. For beginners, the most important idea is simple: Zig does not treat Windows as a second-class target. Windows support is part of the normal Zig workflow. You can write: const std = @import("std"); pub...

Writes › Book › Zig › Part 21. Advanced Zig ›

Custom Formatting

Custom Formatting Zig has a formatting system built into the standard library. You have already used it many times through std.debug.print . const std = @import("std"); pub fn main() void { std.debug.print("name = {s}, age = {}\n", .{ "Ada", 36 }); } This prints: name = Ada, age = 36 The first argument is the format string: "name = {s}, age = {}\n" The second argument is a tuple of...

Writes › Book › Zig › Part 20. Performance and Optimization ›

What Actually Makes Programs Slow?

Understanding Zig Performance Performance is one of the main reasons people choose Zig. Zig is designed for software where speed, memory usage, startup time, and predictable behavior matter. But “performance” is a broad word. It does not only mean “runs fast.” A program can be considered performant if it: finishes work quickly uses little memory avoids unnecessary allocations starts instantly scales well under load keeps CPU caches busy efficiently avoids...

Writes › Book › Zig › Part 19. Systems Programming ›

Memory Mapped Files

Memory Mapped Files A memory mapped file is a file that the operating system places into your program's address space. That sounds strange at first, so use this simple picture: Normally, when you read a file, you ask the operating system to copy bytes from the file into a buffer. With a memory mapped file, you ask the operating system to make the file look like memory. Then your program...

Writes › Book › Zig › Part 18. Concurrency and Async ›

Threads in Zig

Threads in Zig A thread is a separate path of execution inside one program. A normal program starts with one thread. That thread begins at main , runs each statement in order, and ends when main returns. pub fn main() void { // one thread runs this code } A multithreaded program has more than one thread running at the same time. One thread may read a file. Another thread...

Writes › Book › Zig › Part 17. Interfacing with C ›

Why Zig Works Well with C

Why Zig Works Well with C Zig works unusually well with C because it treats C as a first-class part of systems programming. Many languages can call C, but they usually need a foreign function interface, a binding generator, a wrapper layer, or a separate build system. Zig tries to remove most of that friction. It can import C headers, call C functions, link C libraries, compile C source files,...

Writes › Book › Zig › Part 16. Testing and Debugging ›

Zig Test Framework

Zig Test Framework Zig has a built-in test system. You do not need a separate testing library to start writing tests. A test is written with a test block: const std = @import("std"); test "addition works" { try std.testing.expect(1 + 1 == 2); } Run it with: zig test main.zig Zig compiles the file, finds the test blocks, builds a temporary test program, runs it, and reports whether the tests...

Writes › Book › Zig › Part 15. Build System and Tooling ›

Introduction to `build.zig`

Introduction to build.zig Zig has a built-in build system. That means you do not need a separate tool like Make, CMake, Ninja, or a shell script for ordinary Zig projects. You can describe your build directly in Zig code. The main file is usually named: build.zig This file tells Zig how to build your program, how to run it, how to test it, what dependencies it needs, and what options...

Writes › Book › Zig › Part 14. The Standard Library ›

Tour of `std`

Tour of std std is Zig’s standard library. A standard library is the set of useful code that comes with the language. You do not need to download it from a package manager. When you install Zig, you already have std . Zig’s official documentation describes the standard library as a collection of commonly used algorithms, data structures, and definitions for building programs and libraries. You can also view the...

Writes › Book › Zig › Part 13. Collections and Data Structures ›

Importing ArrayList

ArrayList An ArrayList is one of the most important data structures in Zig. It is a growable array. A normal Zig array has a fixed size: const numbers = [_]i32{ 1, 2, 3 }; This array always contains exactly 3 items. You cannot add a fourth item later. But many real programs need collections that grow and shrink dynamically: reading lines from a file storing network packets collecting search results...

Writes › Book › Zig › Part 12. Allocators and Memory Management ›

Why Zig Uses Allocators

Why Zig Uses Allocators Memory is one of the most important ideas in Zig. Many programming languages hide memory management from you. You create objects, strings, lists, maps, and buffers, and the language decides where the memory comes from and when it is released. Zig takes a different approach. Zig wants memory use to be visible. When a Zig function needs heap memory, it usually asks for an allocator. An...

Writes › Book › Zig › Part 11. Zig Builtins ›

Understanding `@` Builtins

Understanding @ Builtins Zig has special built-in functions whose names start with @ . You have already seen one of them: const std = @import("std"); The function @import is a Zig builtin. It is provided by the compiler itself. You do not define it. You do not import it from the standard library. It is always available. Builtins are used for operations that need direct help from the compiler. Some...

Writes › Book › Zig › Part 10. Compile-Time Programming ›

What Is `comptime`

What Is comptime comptime means “compile time.” In Zig, some code runs while your program is being compiled. That code does not run later when the final program starts. It runs earlier, inside the compiler, while Zig is checking and building your program. This is one of Zig’s most important features. Most languages have a sharp split: You write source code. The compiler turns it into a program. The program...

Writes › Book › Zig › Part 9. Optionals and Advanced Types ›

Optional Types

Optional Types An optional type is a type that can hold either a value or no value. In Zig, “no value” is written as null . For example: const maybe_number: ?i32 = 10; The type ?i32 means: either an i32 value, or null So this variable can hold an integer: const a: ?i32 = 123; Or it can hold no integer: const b: ?i32 = null; The ? is part...

Writes › Book › Zig › Part 8. Structs, Enums, and Unions ›

Struct Methods

Struct Methods A struct method is a function that belongs to a struct. Start with a normal struct: const Point = struct { x: i32, y: i32, }; Now add a function inside it: const Point = struct { x: i32, y: i32, fn print(self: Point) void { std.debug.print("({}, {})\n", .{ self.x, self.y }); } }; The function print is inside Point , so you call it through Point or...

Writes › Book › Zig › Part 7. Arrays, Slices, and Strings ›

Multidimensional Arrays

Multidimensional Arrays A multidimensional array is an array whose elements are also arrays. The most common example is a table, grid, or matrix. const grid = [2][3]i32{ .{ 1, 2, 3 }, .{ 4, 5, 6 }, }; The type is: [2][3]i32 Read it as: array of 2 rows, where each row is an array of 3 i32 values So this array has: 2 rows 3 columns per row 6...

Writes › Book › Zig › Part 6. Pointers and Memory ›

Many Item Pointers

Many Item Pointers A many item pointer is a pointer that can move across several values of the same type. Its type looks like this: [*]T Read it as: many item pointer to T For example: [*]u8 means: many item pointer to u8 A single item pointer, *T , points to one value. A many item pointer, [*]T , points to the first value in a sequence. The important difference...

Writes › Book › Zig › Part 5. Error Handling ›

`try`

try try is the most common way to handle errors in Zig. It means: call this function; if it succeeds, give me the success value; if it fails, return the error from the current function So try does two jobs: It unwraps the success value. It propagates the error upward. The Basic Shape Suppose we have this function: const ParseError = error{ InvalidDigit, }; fn parseDigit(c: u8) ParseError!u8 { if...

Writes › Book › Zig › Part 4. Functions ›

A First Example

Recursion Recursion is a technique where a function calls itself. Instead of solving a problem all at once, the function solves a smaller version of the same problem repeatedly. A recursive function usually has two parts: a base case a recursive case The base case stops the recursion. The recursive case calls the function again with a smaller problem. A First Example const std = @import("std"); fn countdown(n: u32) void...

Writes › Book › Zig › Part 8. Structs, Enums, and Unions ›

Struct Definitions

Struct Definitions A struct is a type that groups several values together. You use a struct when one idea has several pieces of data. For example, a point has an x value and a y value. A user has an id, a name, and an email. A file entry has a path, a size, and a timestamp. In Zig, a struct is written like this: const Point = struct {...

Writes › Book › Zig › Part 7. Arrays, Slices, and Strings ›

Array Literals

Array Literals An array literal is the syntax you use to write array values directly in source code. You already saw this form: const numbers = [3]i32{ 10, 20, 30 }; This creates a fixed array with 3 elements. Each element has type i32 . The full shape is: [3]i32{ 10, 20, 30 } Read it as: an array of 3 i32 values, initialized with 10, 20, and 30 The...

Writes › Book › Zig › Part 6. Pointers and Memory ›

Single Item Pointers

Single Item Pointers A pointer is a value that stores the address of another value. In Zig, a single item pointer points to exactly one value. Its type looks like this: *T Read *T as: pointer to T So: *i32 means: pointer to one i32 value And: *u8 means: pointer to one u8 value A pointer does not contain the value itself. It contains the location where the value lives....

Writes › Book › Zig › Part 5. Error Handling ›

Error Union Types

Error Union Types An error union type means: either an error, or a normal value You have already seen this shape: !i32 This means: either an error, or an i32 More explicitly, Zig can also write: SomeError!i32 This means: either one error from SomeError, or an i32 So an error union joins two things together: error set + success type For example: const DivideError = error{ DivisionByZero, }; fn divide(a:...

Writes › Book › Zig › Part 4. Functions ›

Returning a Struct

Multiple Return Patterns Many functions need to produce more than one piece of information. For example: a parser may return both a value and a position a file loader may return data and metadata a math function may return multiple coordinates a search function may return a result and a status Some languages support multiple return values directly. Zig takes a simpler approach. Instead of special syntax, Zig usually uses:...

Writes › Book › Zig › Part 3. Control Flow ›

`break` and `continue`

break and continue Loops repeat code. But sometimes you do not want a loop to finish in the normal way. You may want to stop early. You may want to skip one item. You may want to leave an outer loop from inside an inner loop. Zig gives you two simple tools for this: break and: continue break exits a loop. continue skips to the next loop iteration. break Stops...

Writes › Book › Zig › Part 7. Arrays, Slices, and Strings ›

Fixed Arrays

Fixed Arrays An array is a group of values stored next to each other. In Zig, a fixed array has a length known at compile time. The length is part of the type. const numbers = [3]i32{ 10, 20, 30 }; This creates an array with 3 values. Each value has type i32 . The type of numbers is: [3]i32 Read this as: array of 3 i32 values The length...

Writes › Book › Zig › Part 6. Pointers and Memory ›

Memory Model Basics

Memory Model Basics Memory is where a program keeps its data while it runs. Every variable, array, string, object, pointer, and function call uses memory in some way. When you write Zig, you are closer to memory than you are in languages like Python, JavaScript, Java, or Go. Zig does not hide memory from you. It makes memory part of the program’s design. This is one of the most important...

Writes › Book › Zig › Part 5. Error Handling ›

Error Sets

Error Sets An error set is a group of possible error names. In Zig, errors are not strings. They are not exception objects. They are named values. For example: const FileError = error{ NotFound, PermissionDenied, InvalidFormat, }; This defines an error set named FileError . It contains three possible errors: error.NotFound error.PermissionDenied error.InvalidFormat Each name describes one kind of failure. Error Names An error name starts with error. when used...

Writes › Book › Zig › Part 3. Control Flow ›

Labels and Block Expressions

Labels and Block Expressions Zig has blocks. A block is a group of statements surrounded by braces: { const x = 10; const y = 20; _ = x + y; } You have already seen blocks in if , switch , while , and for . if (age >= 18) { std.debug.print("adult\n", .{}); } The part inside {} is a block. Most beginner code uses blocks only to group...

Writes › Book › Zig › Part 4. Functions ›

The `return` Keyword

Return Values Functions often need to produce results. A function may calculate something, create data, search for information, or transform input into output. The result comes back to the caller through a return value. A simple example: fn add(a: i32, b: i32) i32 { return a + b; } This function: receives two integers adds them returns the result The return type appears after the parameter list: i32 meaning the...

Writes › Book › Zig › Part 2. Zig Language Fundamentals ›

Reserved Keywords

Reserved Keywords A keyword is a word that has special meaning in Zig. You cannot use a keyword as your own variable name, function name, struct name, or field name, because the compiler already uses that word for the language itself. For example, this is invalid: const if = 10; if is a keyword. Zig uses it for conditional logic. This is also invalid: fn return() void {} return is...

Writes › Book › Zig › Part 5. Error Handling ›

Why Zig Has No Exceptions

Why Zig Has No Exceptions Most programming languages need a way to handle failure. A file might not exist. A network connection might close. A program might run out of memory. A user might type invalid input. These are normal problems. They are not rare, and they are not always bugs. Zig handles these problems without exceptions. Instead of throwing exceptions, Zig makes errors part of the function’s return type....

Writes › Book › Zig › Part 3. Control Flow ›

`for` Loops

for Loops A while loop repeats while a condition is true. A for loop is different. It walks through items. Use for when you already have a group of values and want to visit each one. const std = @import("std"); pub fn main() void { const numbers = [_]u8{ 10, 20, 30 }; for (numbers) |n| { std.debug.print("{}\n", .{n}); } } This prints: 10 20 30 The array is: const...

Writes › Book › Zig › Part 3. Control Flow ›

`while` Loops

while Loops Programs often need to repeat work. A program may need to: read lines from a file walk through items in a buffer retry an operation count from one number to another keep running until the user quits In Zig, one basic way to repeat work is with while . const std = @import("std"); pub fn main() void { var i: u8 = 0; while (i < 5) {...

Writes › Book › Zig › Part 2. Zig Language Fundamentals ›

Naming Conventions

Naming Conventions Names are part of the program. A good name tells the reader what a value, function, type, or file means. A weak name forces the reader to guess. Zig code usually prefers clear, direct names. The goal is not to make names clever. The goal is to make code easy to read. Variable and Constant Names Variables and constants usually use snake_case . const user_count = 10; var...

Writes › Book › Zig › Part 4. Functions ›

Parameter Syntax

Function Parameters Function parameters are the inputs of a function. They allow functions to work with different values instead of hardcoded data. Without parameters, functions are limited: fn printNumber() void { std.debug.print("{}\n", .{42}); } This function can only print 42 . With parameters: fn printNumber(value: i32) void { std.debug.print("{}\n", .{value}); } Now the function can print any integer. printNumber(10); printNumber(99); printNumber(-5); Output: 10 99 -5 Parameters make functions reusable. Parameter...

Writes › Book › Zig › Part 4. Functions ›

The Structure of a Function

Defining Functions Functions are reusable blocks of code. Instead of writing the same logic again and again, you place the logic inside a function and call it whenever you need it. In Zig, functions are one of the most important building blocks of a program. Every Zig program starts from a function called main . A function can: receive input perform work return a result A simple function looks like...

Writes › Book › Zig › Part 3. Control Flow ›

`switch`

switch An if statement is good for general conditions: if (age >= 18) { // ... } But sometimes you are not testing ranges or complex logic. You are matching one value against several exact cases. For example: a menu choice a command name a keyboard key an enum value a token type in a parser This is where switch is useful. A switch compares one value against multiple possible...

Writes › Book › Zig › Part 2. Zig Language Fundamentals ›

Comments and Documentation

Comments and Documentation Comments are notes for humans who read the code. The compiler mostly ignores comments. They do not change what the program does. Their job is to explain intent, warn about important details, or make code easier to understand. Line Comments A normal comment starts with // . // This is a comment. const x = 10; Everything after // on the same line is a comment. const...

Writes › Book › Zig › Part 2. Zig Language Fundamentals ›

Strings and UTF-8

Strings and UTF-8 A string is text. const name = "Zig"; The text "Zig" is a string literal. A string literal is text written directly in the source code. const message = "Hello"; const language = "Zig"; const path = "/usr/bin"; Strings look simple, but in Zig they are more explicit than in many beginner languages. Zig does not hide the fact that text is stored as bytes. Strings are...

Writes › Book › Zig › Part 2. Zig Language Fundamentals ›

Zero Values and Initialization

Zero Values and Initialization Initialization means giving a value to something when it is created. const x: i32 = 10; Here, x is initialized with 10 . A value should usually be initialized immediately. This keeps the program simple. When a reader sees the name, they also see the value it starts with. Zig Does Not Automatically Zero Everything In some languages, variables may automatically start as zero, false, or...

Writes › Book › Zig › Part 2. Zig Language Fundamentals ›

Undefined Values

Undefined Values In Zig, undefined means “this value has not been initialized.” It is not zero. It is not null . It is not an empty value. It means the memory exists, but its contents are not meaningful yet. var x: i32 = undefined; This creates a variable named x with type i32 , but it does not give x a real value. Why undefined Exists Sometimes you need to...

Writes › Book › Zig › Part 2. Zig Language Fundamentals ›

Type Inference

Type Inference Type inference means Zig can figure out a type from the value you write. Instead of writing this: const age: i32 = 30; you can often write this: const age = 30; Zig looks at the value 30 and works out what type it should have. This keeps simple code short. You do not need to write obvious types everywhere. A first example const std = @import("std"); pub...

Writes › Book › Zig › Part 2. Zig Language Fundamentals ›

Booleans and Comparisons

Booleans and Comparisons A boolean is a value that can be only one of two things: true false The boolean type in Zig is: bool You use booleans when a program needs to answer a yes-or-no question. const is_ready: bool = true; const is_empty: bool = false; A boolean value is usually used with if , while , and other control-flow constructs. if (is_ready) { // run this code only...

Writes › Book › Zig › Part 2. Zig Language Fundamentals ›

Floating Point Numbers

Floating Point Numbers Floating point numbers are numbers with fractional parts. Examples: const price = 19.99; const temperature = -3.5; const pi = 3.14159; Integers store whole numbers. Floating point numbers store approximate real numbers. Use integers for counts: const files: u32 = 12; Use floating point numbers for measurements: const height: f64 = 1.75; const weight: f64 = 68.5; The main floating point types Zig provides several floating point...

Writes › Book › Zig › Part 2. Zig Language Fundamentals ›

Integer Types and Overflow

Integer Types and Overflow Integers are whole numbers. const a = 10; const b = -5; const c = 0; Zig has many integer types because systems programs often need exact control over size. A number might be stored in one byte, four bytes, eight bytes, or some unusual number of bits. Zig lets you say exactly what you want. Signed and unsigned integers Integer types usually start with either...

Writes › Book › Zig › Part 2. Zig Language Fundamentals ›

Primitive Types

Primitive Types Every value in a Zig program has a type. A type tells the compiler what kind of value something is and what operations are allowed on it. For example: const age = 30; The value 30 is an integer. const price = 19.99; The value 19.99 is a floating-point number. const enabled = true; The value true is a boolean. These basic built-in types are called primitive types....

Writes › Book › Zig › Part 1. Introduction and Setup ›

Reading Zig Error Messages

Reading Zig Error Messages Sooner or later, every Zig beginner meets the compiler. Not just the compiler that builds your program, but the compiler that refuses to build your program. That is normal. Compiler errors are part of programming. They are not signs that you are bad at Zig. They are messages from the compiler saying, “This code does not make sense yet.” Your job is to read the message...

Writes › Book › Zig › Part 1. Introduction and Setup ›

Editors, LSP, and Debuggers

Editors, LSP, and Debuggers You can write Zig code in any text editor. A Zig source file is plain text. It usually ends with: .zig For example: main.zig You do not need a special IDE to learn Zig. A simple editor and a terminal are enough. But a good editor setup makes learning easier because it can show errors, format code, and help you move around a project. The Basic...

Writes › Book › Zig › Part 1. Introduction and Setup ›

Project Structure

Project Structure So far, we have used single-file programs. A single-file Zig program looks like this: hello.zig You can run it with: zig run hello.zig This is good for learning small examples. But real programs usually need more structure. They may have source files, tests, dependencies, documentation, generated files, and build settings. A Zig project gives those pieces a predictable place. A Small Zig Project A simple Zig project often...

Writes › Book › Zig › Part 1. Introduction and Setup ›

Zig Compiler as a Toolchain

Zig Compiler as a Toolchain When beginners hear the word “compiler,” they often think of one job: source code -> executable program That is true, but Zig is more than a compiler in the narrow sense. The zig command is a toolchain. A toolchain is a collection of tools used to build, test, format, and manage programs. In many languages, these tools are separate. In Zig, many of them are...

Writes › Book › Zig › Part 1. Introduction and Setup ›

Understanding `zig build-exe`

Understanding zig build-exe In the previous section, we used this command: zig run hello.zig That command compiles your Zig file and runs it immediately. Now we will look at a different command: zig build-exe hello.zig This command compiles your Zig file and creates an executable file. An executable file is a program you can run directly from your operating system. Source File and Executable File Start with this file: hello.zig...

Writes › Book › Zig › Part 1. Introduction and Setup ›

Your First Zig Program

Your First Zig Program Now we will write and run a complete Zig program. Create a file named: hello.zig Put this code inside it: const std = @import("std"); pub fn main() void { std.debug.print("Hello, Zig!\n", .{}); } This is a full Zig program. It is small, but it already shows the basic structure used by larger Zig programs. Running the Program Open a terminal in the same folder as hello.zig...

Writes › Book › Zig › Part 1. Introduction and Setup ›

Zig Release Channels and Versioning

Zig Release Channels and Versioning Before writing larger Zig programs, you need to understand an important fact: Zig is still evolving. Unlike older languages with decades of stable compatibility, Zig is still under active development. Features change, APIs change, syntax changes, and parts of the standard library may be redesigned between releases. This is normal for Zig today because the language has not reached version 1.0 yet. Understanding Zig versions...

Writes › Book › Zig › Part 1. Introduction and Setup ›

Installing Zig

Installing Zig Before we write more Zig code, we need the Zig compiler. The compiler is the program that reads your .zig source files and turns them into programs your computer can run. Zig is distributed as a single toolchain. After installation, the main command you use is: zig The official latest Zig release is 0.16.0 , released on April 14, 2026. The official site lists prebuilt downloads for Windows,...

Writes › Book › Zig › Part 1. Introduction and Setup ›

Why Zig Exists

Why Zig Exists Zig exists because low-level programming is still important, but the old tools have painful tradeoffs. For many decades, C has been the main language for systems programming. C is small, fast, portable, and close to the machine. It is used in operating systems, databases, embedded devices, language runtimes, network servers, game engines, and many other important programs. But C also has problems. A small mistake in C...

Writes › Book › Zig › Part 3. Control Flow ›

`if` Expressions

if Expressions Programs need to make choices. A program may need to ask: Should I print this message? Should I open this file? Should I stop because something went wrong? Should I use this value or another value? In Zig, the simplest way to make a choice is with if . const std = @import("std"); pub fn main() void { const age = 20; if (age >= 18) { std.debug.print("adult\n",...

Writes › Book › Zig › Part 2. Zig Language Fundamentals ›

Variables and Constants

Variables and Constants A program stores values so it can use them later. In Zig, you store values with two main keywords: const var Use const when the value will not change. Use var when the value can change. This is one of the first important habits in Zig: prefer const first. Only use var when you truly need to modify the value. Constants A constant is a named value...

Writes › Book › Zig › Part 1. Introduction and Setup ›

What Is Zig

What Is Zig Zig is a programming language for writing programs that are fast, clear, and close to the machine. A computer does not understand words like print , main , or if . It understands machine instructions. A programming language gives us a way to write instructions in a form humans can read. Then a compiler turns those instructions into a program the computer can run. Zig is a...

Writes › Book › Zig › Part 1. Introduction and Setup ›

What Is Zig

What Is Zig Zig is a programming language for writing fast, small, reliable programs. It is often compared with C, because Zig is designed for the same kind of work: operating systems, command-line tools, databases, game engines, embedded software, compilers, networking programs, and other low-level software. But Zig is not just “modern C.” It has its own design. Zig tries to give you three things at the same time: direct...

Writes › Book › Zig › Appendix ›

What Is Zig

What Is Zig Zig is a programming language for writing fast, small, reliable programs. It is often compared with C, because Zig is designed for the same kind of work: operating systems, command-line tools, databases, game engines, embedded software, compilers, networking programs, and other low-level software. But Zig is not just “modern C.” It has its own design. Zig tries to give you three things at the same time: direct...

Writes › Book › Learn › Learn Zig ›

Chapter 6. Fixed-Size Arrays

Section Title 1 Fixed-Size Arrays 2 Array Literals 3 Slicing Arrays 4 Sentinel Arrays 5 Strings Are Bytes 6 UTF-8 Handling 7 Exercises

Writes › Book › Zig ›

Part 5. Error Handling

Section Title 1 Why Zig Has No Exceptions 2 Error Sets 3 Error Union Types 4 try 5 catch 6 errdefer 7 Propagating Errors 8 Designing Error APIs 9 Custom Error Types 10 Panic and Crash Behavior

Writes › Book › Zig ›

Part 18. Concurrency and Async

Section Title 1 Threads in Zig 2 Mutexes 3 Atomics 4 Condition Variables 5 Async Functions 6 Await and Suspension 7 Event Loops 8 Channels and Queues 9 Data Races 10 High Performance Concurrent Design

Writes › Book › Zig ›

Part 10. Compile-Time Programming

Section Title 1 What Is comptime 2 Compile-Time Variables 3 Inline Branching 4 Compile-Time Loops 5 Generating Code at Compile Time 6 Reflection with @typeInfo 7 Building Generic Data Structures 8 Static Dispatch 9 Metaprogramming Patterns 10 When Not to Use comptime

Writes › Book › Zig ›

Part 9. Optionals and Advanced Types

Section Title 1 Optional Types 2 Optional Unwrapping 3 Nullable Pointers 4 Vectors 5 Opaque Types 6 anytype 7 Error Union Internals 8 Type Coercion 9 Type Reflection Basics

Writes › Book › Learn ›

Learn Zig

Learn Zig Chapter Title Description 1 Chapter 1. Hello, Zig The first program in Zig is small. 2 Chapter 2. Names and Declarations A Zig program is made from declarations. 3 Chapter 3. Blocks are Expressions A block is a sequence of statements inside braces. 4 Chapter 4. Defining Functions A function groups statements into a single operation. Functions are the basic unit of organization in a Zig program. 5...

Writes › Book › Zig ›

Part 17. Interfacing with C

Section Title 1 Why Zig Works Well with C 2 @cImport 3 Calling C Functions 4 Using C Structs 5 Linking C Libraries 6 Building Mixed Zig and C Projects 7 Exporting Zig to C 8 ABI Compatibility 9 Working with Headers 10 Wrapping Existing Libraries

Writes › Book › Learn › Learn Zig ›

Chapter 1. Hello, Zig

Section Title 1 Hello, Zig 2 Build and Run 3 Variables and Constants 4 Printing Values 5 A Small Calculator 6 Reading Command-Line Arguments 7 A Word-Count Program 8 Exercises

Writes › Book › Learn › Learn Zig ›

Chapter 16. Calling C

Section Title 1 Calling C 2 @cImport 3 Header Translation 4 Linking Libraries 5 Calling Zig from C 6 ABI and Layout 7 Exercises

Writes › Book › Zig ›

Part 20. Performance and Optimization

Section Title 1 What Actually Makes Programs Slow? 2 Why Profiling Matters 3 The Basic Idea 4 Why SIMD Matters 5 Why Allocations Cost Time 6 Small Values Are Fine to Copy 7 Why Branch Prediction Exists 8 Benchmark the Right Thing 9 The Basic Idea 10 Case Study 1: Reusing a Temporary Buffer

Writes › Book › Zig ›

Appendix

Section Title 1 What Is Zig 2 Appendix A. Zig 0.16 New Features 3 Appendix B. Zig Cheat Sheet 4 Appendix C. Common Compiler Errors 5 Appendix D. Important Standard Library APIs 6 Appendix E. Memory Safety Checklist 7 Appendix F. Build Modes Reference 8 Appendix G. C Interop Reference 9 Appendix H. Useful Open Source Zig Projects 10 Appendix I. Zig Coding Style Guide 11 Appendix J. Migrating Between...

Writes › Book › Learn › Learn Zig ›

Chapter 10. What `comptime` Means

Section Title 1 What comptime Means 2 Compile-Time Parameters 3 Types as Values 4 Inline Loops 5 Reflection 6 Generating Declarations 7 Exercises

Writes › Book › Zig ›

Part 12. Allocators and Memory Management

Section Title 1 Why Zig Uses Allocators 2 General Purpose Allocator 3 Arena Allocator 4 Fixed Buffer Allocator 5 Page Allocator 6 Custom Allocators 7 Allocation Failure Handling 8 Memory Leak Detection 9 Lifetime Management 10 Building Allocation-Friendly APIs

Writes › Book › Learn › Learn Zig ›

Chapter 7. Struct Declarations

Section Title 1 Struct Declarations 2 Field Access 3 Methods as Functions 4 Enums 5 Tagged Unions 6 Packed Structs 7 Data Layout 8 Exercises

Writes › Book › Learn › Learn Zig ›

Chapter 17. Target Triples

Section Title 1 Target Triples 2 Operating Systems 3 CPU Architectures 4 libc and Freestanding Builds 5 Static and Dynamic Linking 6 Release Modes 7 Exercises

Writes › Book › Zig ›

Part 13. Collections and Data Structures

Section Title 1 Importing ArrayList 2 The Basic Idea 3 Why StringHashMap Exists 4 Why Linked Lists Exist 5 The Basic Difference 6 Why Bit Sets Matter 7 The Core Idea 8 Why Trees Matter 9 Start with the Rule 10 Start with the Operations

Writes › Book › Learn › Learn Zig ›

Chapter 4. Defining Functions

Section Title 1 Defining Functions 2 Parameters and Return Values 3 Passing Values 4 Public Declarations 5 Importing Files 6 Organizing a Small Program 7 Exercises

Writes › Book › Zig ›

Part 21. Advanced Zig

Section Title 1 Custom Formatting 2 Reflection Systems 3 Plugin Architectures 4 Embedded Development 5 Writing a Game Engine Core 6 Writing a Parser 7 Writing a Virtual Machine 8 Writing a Compiler in Zig 9 Self-Hosted Zig Compiler 10 Understanding Zig IR

Writes › Book › Learn › Learn Zig ›

Chapter 5. Addresses and Pointer Types

Section Title 1 Addresses and Pointer Types 2 Single-Item Pointers 3 Many-Item Pointers 4 Slices 5 Pointer Arithmetic 6 Alignment 7 Lifetimes 8 Exercises

Writes › Book › Learn › Learn Zig ›

Chapter 3. Blocks are Expressions

Section Title 1 Blocks are Expressions 2 if Expressions 3 switch Expressions 4 while Loops 5 for Loops 6 break , continue , and Labels 7 defer 8 Exercises

Writes › Book › Zig ›

Part 23. Real Projects

Section Title 1 Build a CLI Calculator 2 Build a JSON Parser 3 Build a Static File Server 4 Build a Thread Pool 5 Build a Memory Allocator 6 Build a Small Database 7 Build a Programming Language Lexer 8 Build a Bytecode VM 9 Build a Simple Game Engine 10 Build a Mini Git Clone 11 Appendix A. Zig 1.16 New Features

Writes › Book › Learn › Learn Zig ›

Chapter 9. The Optional Type

Section Title 1 The Optional Type 2 Null 3 Unwrapping Optionals 4 Optional Pointers 5 Optionals Versus Errors 6 Exercises

Writes › Book › Learn › Learn Zig ›

Chapter 15. `zig build`

Section Title 1 zig build 2 build.zig 3 Build Steps 4 Build Options 5 Tests 6 Examples 7 Dependencies 8 Cross Builds 9 Exercises

Writes › Book ›

Zig Chapter Title Description 1 Part 1. Introduction and Setup Zig is a programming language for writing fast, small, reliable programs. 2 Part 2. Zig Language Fundamentals A program stores values so it can use them later. In Zig, you store values with two main keywords: 3 Part 3. Control Flow Programs need to make choices. 4 Part 4. Functions Functions are reusable blocks of code. 5 Part 5. Error...

Writes › Book › Zig ›

Part 22. Cross-Platform Development

Section Title 1 Windows Support 2 Linux Support 3 macOS Support 4 WebAssembly 5 ARM and Embedded Targets 6 Cross-Target Debugging 7 Portable APIs 8 Handling Platform Differences 9 Packaging Cross-Platform Apps

Writes › Book › Learn › Learn Zig ›

Chapter 12. Why Allocation Is Explicit

Section Title 1 Why Allocation Is Explicit 2 The Allocator Interface 3 Page Allocator 4 General-Purpose Allocator 5 Arena Allocator 6 Fixed-Buffer Allocator 7 Ownership Rules 8 Exercises

Writes › Book › Learn › Learn Zig ›

Chapter 18. Threads

Section Title 1 Threads 2 Mutexes 3 Atomics 4 Condition Variables 5 Async Status in Zig 0.16 6 Thread Pools 7 Semaphores 8 Designing Concurrent Programs 9 A Parallel File Scanner

Writes › Book › Zig ›

Part 2. Zig Language Fundamentals

Section Title 1 Variables and Constants 2 Primitive Types 3 Integer Types and Overflow 4 Floating Point Numbers 5 Booleans and Comparisons 6 Type Inference 7 Undefined Values 8 Zero Values and Initialization 9 Strings and UTF-8 10 Comments and Documentation 11 Naming Conventions 12 Reserved Keywords

Writes › Book › Zig ›

Part 1. Introduction and Setup

Section Title 1 What Is Zig 2 What Is Zig 3 Why Zig Exists 4 Installing Zig 5 Zig Release Channels and Versioning 6 Your First Zig Program 7 Understanding zig build-exe 8 Zig Compiler as a Toolchain 9 Project Structure 10 Editors, LSP, and Debuggers 11 Reading Zig Error Messages

Writes › Book › Zig ›

Part 11. Zig Builtins

Section Title 1 Understanding @ Builtins 2 @import 3 @sizeOf 4 @alignOf 5 @Type 6 @typeInfo 7 @ptrCast 8 @bitCast 9 @memcpy 10 @intCast 11 @truncate 12 @floatCast 13 @panic 14 @compileError 15 @embedFile 16 Important Builtins in Zig 1.16

Writes › Book › Zig ›

Part 19. Systems Programming

Section Title 1 Memory Mapped Files 2 System Calls 3 Working with the OS 4 Terminal Programming 5 Binary File Formats 6 Endianness 7 Network Protocols 8 Writing a TCP Server 9 Writing a CLI Tool 10 Writing a Small Shell

Writes › Book › Zig ›

Part 7. Arrays, Slices, and Strings

Section Title 1 Fixed Arrays 2 Array Literals 3 Multidimensional Arrays 4 Slices in Detail 5 Slice Lifetimes 6 String Literals 7 Mutable Strings 8 UTF-8 Processing 9 Building Dynamic Strings 10 Efficient Text Processing

Writes › Book › Zig ›

Part 16. Testing and Debugging

Section Title 1 Zig Test Framework 2 Writing Unit Tests 3 Table-Driven Tests 4 Fuzz Testing 5 Debug Builds 6 Stack Traces 7 Assertions 8 Using GDB and LLDB 9 Memory Debugging 10 Benchmarking Code

Writes › Book › Learn › Learn Zig ›

Chapter 2. Names and Declarations

Section Title 1 Names and Declarations 2 const and var 3 Integer Types 4 Floating-Point Types 5 Booleans 6 Characters and Bytes 7 Type Inference 8 Explicit Casts 9 Exercises

Writes › Book › Zig ›

Part 3. Control Flow

Section Title 1 if Expressions 2 switch 3 while Loops 4 for Loops 5 Labels and Block Expressions 6 break and continue 7 Inline Loops 8 Defer and Cleanup 9 Unreachable Code 10 Compile Errors as Safety Checks

Writes › Book › Zig ›

Part 8. Structs, Enums, and Unions

Section Title 1 Struct Definitions 2 Struct Methods 3 Default Field Values 4 Packed Structs 5 Anonymous Structs 6 Enums 7 Tagged Unions 8 Union Safety 9 Modeling State Machines 10 Data-Oriented Design

Writes › Book › Zig ›

Part 24. Reading and Contributing to Zig

Section Title 1 Zig Compiler Architecture 2 Zig Source Tree 3 Understanding Stage2 4 How Parsing Works 5 Semantic Analysis 6 Code Generation 7 LLVM Integration 8 Open Issues and RFCs 9 Contributing to Zig 10 Following Zig Development 11 Appendix A. Zig 1.16 New Features

Writes › Book › Zig ›

Part 6. Pointers and Memory

Section Title 1 Memory Model Basics 2 Single Item Pointers 3 Many Item Pointers 4 Slices 5 Optional Pointers 6 Pointer Arithmetic 7 Alignment 8 Sentinel-Terminated Arrays 9 Stack vs Heap 10 Dangling Pointers 11 Memory Safety in Zig 12 Volatile and Atomic Memory

Writes › Book › Learn › Learn Zig ›

Chapter 13. Files

Section Title 1 Files 2 Reading Bytes 3 Writing Bytes 4 Buffered I/O 5 Standard Input and Output 6 Error Handling in I/O 7 Zig 0.16 I/O Changes 8 Exercises

Writes › Book › Learn › Learn Zig ›

Chapter 14. `std.debug`

Section Title 1 std.debug 2 std.mem 3 std.ArrayList 4 Hash Maps 5 Formatting 6 Filesystem APIs 7 Process APIs 8 Testing Utilities 9 Exercises

Writes › Book › Zig ›

Part 15. Build System and Tooling

Section Title 1 Introduction to build.zig 2 Creating Build Steps 3 Adding Dependencies 4 Build Options 5 Cross Compilation 6 Static and Dynamic Linking 7 Release Modes 8 Running Tests 9 Installing Binaries 10 Packaging Applications 11 Build System Changes in Zig 0.16

Writes › Book › Zig ›

Part 4. Functions

Section Title 1 The Structure of a Function 2 Parameter Syntax 3 The return Keyword 4 Returning a Struct 5 A First Example 6 A First Example 7 What Anonymous Functions Usually Mean 8 A Simple Function 9 A Mental Model 10 What “Exported” Means 11 Zig Generics Use comptime

Writes › Book › Learn › Learn Zig ›

Chapter 11. Generic Functions

Section Title 1 Generic Functions 2 Generic Structs 3 Type Constraints by Use 4 Interfaces by Convention 5 Compile-Time Dispatch 6 Exercises

Writes › Book › Learn › Learn Zig ›

Chapter 8. Error Sets

Section Title 1 Error Sets 2 Error Unions 3 Returning Errors 4 try 5 catch 6 defer and errdefer 7 Designing Error Boundaries 8 Exercises

Writes › Book › Zig ›

Part 14. The Standard Library

Section Title 1 Tour of std 2 Reading Files 3 Writing Files 4 Directories and Paths 5 Formatting and Printing 6 Parsing Numbers and Text 7 Time and Timers 8 Random Number Generation 9 Environment Variables 10 Process Management 11 Compression 12 JSON Support 13 HTTP Client 14 Networking APIs 15 Logging

Writes › Book › Learn › Learn Zig ›

Appendix

Section Title 1 Hello, Zig 2 Appendix A. Zig Syntax Summary 3 Appendix B. Operators and Precedence 4 Appendix C. Builtin Functions 5 Appendix D. Standard Library Map 6 Appendix E. Build System Reference 7 Appendix F. C Interop Reference 8 Appendix G. Common Compiler Errors 9 Appendix H. Zig 0.16 Migration Notes 10 Appendix I. Exercise Answers 11 Appendix J. Index 12 Colophon

Writes › Book › Learn › Learn Zig ›

Chapter 19. Undefined Behavior

Section Title 1 Undefined Behavior 2 Safety Checks 3 Pointer Casts 4 Integer Overflow 5 Volatile Memory 6 Packed Memory 7 FFI Safety 8 Exercises

Writes › Book › Learn › Learn Zig ›

Chapter 20. A Command-Line Parser

Section Title 1 A Command-Line Parser 2 A File Copier 3 A Line Filter 4 A Tiny HTTP Client 5 A Static Library 6 Testing Strategy 7 Benchmarking 8 demo 9 Where to Go From Here 10 Appendix A. Zig Syntax Summary

#zig

Colophon

Appendix J. Index

Appendix I. Exercise Answers

Appendix H. Zig 0.16 Migration Notes

Appendix G. Common Compiler Errors

Appendix F. C Interop Reference

Appendix E. Build System Reference

Appendix D. Standard Library Map

Appendix C. Builtin Functions

Appendix B. Operators and Precedence

Appendix A. Zig Syntax Summary

Appendix A. Zig Syntax Summary

Where to Go From Here

A Parallel File Scanner

demo

Exercises

Designing Concurrent Programs

Benchmarking

FFI Safety

Semaphores

Exercises

Exercises

Testing Strategy

Packed Memory

Thread Pools

Release Modes

ABI and Layout

Exercises

Cross Builds

Dependencies

Examples

Exercises

Testing Utilities

Process APIs

Exercises

Zig 0.16 I/O Changes

Filesystem APIs

Error Handling in I/O

A Static Library

Volatile Memory

Async Status in Zig 0.16

Static and Dynamic Linking

Calling Zig from C

Tests

Formatting

Standard Input and Output

Exercises

Ownership Rules

Fixed-Buffer Allocator

Arena Allocator

Integer Overflow

A Tiny HTTP Client

Condition Variables

libc and Freestanding Builds

Linking Libraries

Build Options

Hash Maps

Buffered I/O

General-Purpose Allocator

Exercises

Compile-Time Dispatch

Interfaces by Convention

A Line Filter

Pointer Casts

Atomics

CPU Architectures

Header Translation

Build Steps

`std.ArrayList`

Writing Bytes

Page Allocator

Type Constraints by Use

Exercises

A File Copier

Safety Checks

Mutexes

Operating Systems

`@cImport`

`build.zig`