Zig in Depth

Introduction: Why Zig?

1. The Systems Programming Landscape Today
2. Andrew Kelley’s Vision and the Origin of Zig
3. No Hidden Control Flow: The Core Philosophy
4. Where Zig Fits Among C, C++, Rust, and Go
5. How This Book Is Organized

Chapter 1: Getting Started - Installation, Toolchain, and Your First Program

1. Installing Zig: Official Releases and Building from Source
2. The Zig Compiler Driver: zig build-exe, zig run, zig test
3. Your First Program: A Walkthrough of main.zig
4. Understanding the Zig Build System (build.zig)
5. Project Layout Conventions and the Standard Library

Chapter 2: Types, Variables, and Constants - The Building Blocks

1. Primitive Types: Integers, Floats, Booleans, and the Void Type
2. Variable Declarations: var vs const and Immutability by Default
3. Type Inference and Explicit Typing
4. Integer Overflow Semantics: Safe, Wrapping, Saturating, and Unchecked
5. The Undefined Behavior Problem Zig Eliminates

Chapter 3: Control Flow - Branching, Looping, and the Block Expression

1. If/Else as Expressions: Values Everywhere
2. The Switch Statement: Exhaustive Pattern Matching Without Patterns
3. While Loops: Tags, Break Values, and Control Flow Clarity
4. For Loops: Arrays, Slices, Enumerators, and the New Syntax
5. Block Expressions and Local Scoping

Chapter 4: Pointers, Arrays, and Slices - Memory in Zig

1. Pointer Types: Single (*T) vs Multi ([*]T) Pointers
2. Const Correctness in Pointers: *const T and Nested Const
3. Arrays as First-Class Value Types: Length Is Part of the Type
4. Slices: Fat Pointers, Bounds Checking, and Ownership Semantics
5. How Zig’s Pointer Model Differs from C

Chapter 5: Structs, Enums, and Unions - Composite Types

1. Struct Definitions: Fields, Default Values, and Initialization
2. Methods and the Self Parameter
3. Enums: Values, Tags, Sentinels, and Iteration
4. Unions and Tagged Unions (union(enum)): Safe Variant Types
5. Packed Structs and Extern Structs for Binary Layout Control

Chapter 6: Optionals, Error Sets, and Error Unions - Safety Without Exceptions

1. Optionals: The T? Type and Safe Null Handling
2. Error Sets as Compile-Time Types
3. The try Operator: Propagating Errors Explicitly
4. Error Unions (T!E) and the catch Operator
5. errdefer: Cleanup on Error Return
6. Why Zig Rejects Exceptions: Design Rationale

Chapter 7: Functions, Generics, and Compile-Time Programming - Zig’s Superpower

1. Function Declarations: Parameters, Return Types, and Conventions
2. Inline Functions and Call-Site Inlining
3. The comptime Keyword: When Code Runs at Compile Time
4. Type Parameters and Generic Functions
5. Building Generic Data Structures: A Linked List from Scratch
6. Comptime Blocks and Compile-Time Assertions

Chapter 8: Memory Management - Explicit Allocation, No Garbage Collector

1. The Allocator Parameter: Passing Memory Responsibility Explicitly
2. GeneralPurposeAllocator and the Standard Library Allocators
3. ArenaAllocator: Scope-Based Allocation for Temporary Data
4. FixedBufferAllocator and Stack-Backed Allocation
5. Manual Memory Management Patterns and Common Mistakes
6. Implementing Custom Allocators
7. Summary

Chapter 9: Strings, Formatting, and I/O - Working with Text

1. Strings Are UTF-8 Byte Slices: Encoding Semantics
2. String Comparison, Concatenation, and Allocation-Free Operations
3. Formatting: std.fmt Formatters and Custom Format Implementations
4. File I/O: Readers, Writers, and the Buffering Layer
5. Path Handling and Directory Traversal

Chapter 10: The Build System, Package Management, and C Interop

1. The Build System (build.zig) in Depth: Steps, Options, and Artifacts
2. Cross-Compilation: Zig’s Built-In Multiplatform Story
3. Module System and Package Management
4. Importing C Libraries: Build-System C Translation
5. Exporting to C: FFI in the Other Direction

Chapter 11: Testing, Debugging, and Tooling - Building Reliable Software

1. The Built-In Test Framework: zig test and Test Organization
2. Assertion Macros and Custom Error Messages
3. Debugging with GDB and LLDB
4. Sanitizers: AddressSanitizer, UndefinedBehaviorSanitizer, and ThreadSanitizer
5. Profiling and Performance Analysis Tools

Chapter 12: Concurrency - Threads, Atomics, and Synchronization

1. Threads: std.Thread and the Spawn API
2. Atomic Operations: Load, Store, Compare-and-Swap, and Ordering
3. Mutexes, RWLocks, and Condition Variables
4. Channel-Based Communication Patterns
5. Concurrency Pitfalls and Safe Patterns

Chapter 13: Real-World Projects - Case Studies in Idiomatic Zig

1. Case Study 1: Building a Command-Line JSON Parser
2. Case Study 2: A Simple HTTP Server from Scratch
3. Case Study 3: A Binary Protocol Encoder and Decoder
4. Project Structure Best Practices for Larger Codebases
5. Performance Optimization: Benchmarking, Profiling, and Tuning

Chapter 14: Async I/O and Event-Driven Programming

1. The Problem with Threads: Scaling I/O-Bound Workloads
2. The std.Io Interface: I/O as an Injectable Dependency
3. Juicy Main and the I/O Context
4. Asynchronous Operations: io.async() and Future
5. Concurrent Tasks with Group and Batch
6. Cancellation: Preventing Resource Leaks
7. Evented I/O: io_uring and Performance
8. Async Networking: Building a Scalable HTTP Server
9. Summary of Async I/O Patterns

Chapter 15: Compile-Time Reflection and Advanced Metaprogramming

1. Beyond Generics: What comptime Can Really Do
2. @typeInfo: Reading Type Metadata
3. @field, @typeOf, and Field Access by Name
4. Building a Generic JSON Serializer with Reflection
5. Programmatic Type Construction: @Int, @Struct, @Pointer, and Friends
6. @offsetOf, @ptrToInt, and Layout Inspection
7. Comptime Assertions and Compile-Time Validation
8. Metaprogramming Patterns: Adding Methods to Generated Types
9. When to Use Reflection vs. Explicit Code
10. Summary

Chapter 16: SIMD, Bit Manipulation, and Low-Level Programming

1. Why Low-Level Control Matters
2. Vectors and SIMD: Parallel Operations on Data
3. Bit Manipulation: Working at the Bit Level
4. Endianness: Handling Different Byte Orders
5. Packed Structs: Exact Control of Memory Layout
6. Volatile Access and Memory-Mapped Hardware
7. @bitCast, @ptrToInt, and Low-Level Type Conversions
8. SIMD and Bit Manipulation in Practice: A Substring Search
9. Summary

Chapter 17: WebAssembly Compilation and JavaScript Interop

1. Why Zig for WebAssembly?
2. WASM Target Variants: Choosing the Right Environment
3. Your First WASM Module: Exporting Functions to JavaScript
4. Working with Linear Memory
5. Optimizing WASM Binaries for Size and Speed
6. WASM SIMD: Using @Vector in the Browser
7. Using zig-js: Simplified JavaScript Interop
8. WASI: Server-Side Zig in WebAssembly
9. Summary

Chapter 18: Embedded Systems and Freestanding Environments

1. Why Zig for Embedded Development?
2. Freestanding Targets: No OS, No libc, No Problem
3. Linker Scripts: Defining Memory Layout
4. Startup Code: From Reset to main()
5. Hardware Register Access with Packed Structs
6. Interrupt Handling
7. UART Communication
8. Using the Standard Library in Freestanding Environments
9. Debugging Embedded Zig Programs
10. MicroZig and Embedded Toolchains
11. Summary

Chapter 19: Operating System Integration - Processes, Signals, and Resources

1. The OS Interface Layer: std.os, std.posix, and Platform Abstraction
2. Process Spawning and Management
3. Signal Handling
4. File Descriptors and I/O Multiplexing
5. Environment Variables and Process Arguments
6. Pipes and Process Communication
7. Summary

Chapter 20: Zig as a C Compiler and libc Replacement

1. The Zig Toolchain Beyond Zig Code
2. How zig cc Works Internally
3. Compiling C Code with zig cc
4. Bundled libc Implementations
5. glibc Version Targeting
6. Using zig cc as a Drop-In Replacement
7. Zig libc and the Future of C Interoperability
8. C++ Compilation with zig c++
9. Compiling Mixed Zig and C Projects
10. Summary

Chapter 21: Cross-Compilation Deep Dive

1. Why Zig’s Cross-Compilation Is Different
2. Target Triples: Anatomy of a Cross-Compilation Target
3. Listing and Discovering Targets
4. Practical Cross-Compilation Scenarios
5. Using Cross-Compilation with the Build System
6. Cross-Compiling C Dependencies with zig cc
7. Testing Cross-Compiled Binaries
8. Freestanding and Embedded Targets
9. Summary

Chapter 22: Security, Hardening, and Defensive Programming

1. The Security Posture of Zig Programs
2. Compiler Safety Checks Across Build Modes
3. AddressSanitizer (ASAN): Detecting Memory Errors
4. UndefinedBehaviorSanitizer (UBSAN): Catching Undefined Behavior
5. ThreadSanitizer (TSAN): Detecting Data Races
6. The Fuzzer: Finding Bugs with Smith
7. Defensive Input Validation
8. Memory Protection and Hardening
9. Secure Secrets Handling
10. Supply Chain Security
11. Summary

Chapter 23: Performance Optimization and Benchmarking

1. The Optimization Landscape in Zig
2. Understanding Build Modes and Performance
3. Measuring Performance: Manual Timing
4. Using zBench for Structured Benchmarking
5. Profiling with perf (Linux)
6. Identifying Common Bottlenecks
7. Compiler Inlining and Function Calls
8. Summary

Chapter 24: Building Language Tools with Zig

1. Why Zig Excels for Language Tooling
2. Using the Built-in Tokenizer
3. Writing a Simple Parser
4. Generating Code at Comptime
5. Building a Linter or Static Analyzer
6. Summary

Chapter 25: The std.Io Interface Deep Dive

1. The I/O Overhaul in Zig 0.16
2. The Io Interface
3. File Operations with std.Io
4. Streams: Readers and Writers
5. Mocking I/O for Testing
6. Summary

Conclusion: The Zig Journey Ahead

References