book

Learning Zig

Name: Learning Zig
Author: Alex Rios
ISBN: 9781835085127

by Alex Rios

November 2025

Intermediate to advanced

502 pages

10h 8m

English

Packt Publishing

Read now

Unlock full access

Preface
Who this book is forWhat this book coversTo get the most out of this bookGet in touch
Zig Fundamentals
Safety First
Getting the most out of this book – get to know your free benefitsNext-gen readerInteractive AI assistant (beta)DRM-free PDF or ePub version Training your brain to think in ZigSystems programming reimaginedThe genesis of Zig – fixing what’s brokenThe flaws of mainstream languagesThe solution? Obviously, ZigA modern alternative to CSimplicity – focus on what mattersNo hidden control flowCompile-time executionTooling – ready to go, right out of the boxMore than just a languageWhy does Zig have its own build system?A unified approachCross-compilation made easyMaintain with ZigInteroperabilityToo good to be ignoredA new era beginsSafetyWhere to use ZigSummary
Setting Up Your Playground
Installing ZigPlaying it safe or living on the edge: your first Zig dilemmaStable or BoldLinux: the land of choicesWindows: the land of path variables and PowerShellMac: the cult of brewVerifying your installationBTW, I use Arch NixThe ZLS for smarter Zig codingBuilding the ZLS from sourceIntegrating the ZLSUsing the ZLS in VS CodeUsing the ZLS in NeovimInstalling the vim-plug plugin managerFine-tuning the ZLSFinding the right spot for your zls.json fileTaking the ZLS to the next levelDefining a custom check step in your build.zig fileActivating your configurationZig setup: surprise test!SummaryJoin us on Discord!
Your First Zig Program
“Hello, World!”: Your first taste of ZigBringing in the Standard LibraryImporting packageszig runStep 1: Building the executable manuallyStep 2: Running the executableWhy go through this?VariablesShadowingIdentifiersA quick word on primitive typesBasic debuggingStep 1: Building the program in debug modeStep 2: Running the programStep 3: What’s going on?Understanding the byte patternstd.debugMaintaining consistencyLine endings: Keep it simple, keep it LFTabs versus spaces: Pick a side (spoiler: use spaces)Byte order marks: Only at the startThe power of zig fmtBuilding Zig projectsStep 1: Creating your projectStep 2: Your first buildStep 3: Running your programStep 4: What’s inside the source code?Step 5: Too many moving partsSummaryMake it stickAnswers
Control Flow, Loops, and Other Forms of Digital Domination
Technical requirementsMaking choices with if, else, and switch (your code’s moral compass)if as an expressionif with Boolean conditions: The classic that never gets oldif with union typesThe elegant switch: Leveling up decision-makingRepeating actionsIterating over a portion of a collectionAccessing indicesIterating over multiple collections: Because one isn’t challenging enoughUsing loops as expressions with else: Handling disappointment gracefullyBest practices, or how to sleep at nightOptional types: Because life (and code) isn’t always certainWhat is the ?T type?Embracing uncertainty in iterationLabeled switches: When a regular switch just isn’t enoughSummaryTesting your knowledgeJoin us on Discord!
Functions for the Efficient Programmer
Technical requirementsBlocks – keeping your variables on a tight leashShadowing – Zig doesn’t play that gameFunctionsParameters – accepting inputsReturn values – sending outputs back to the callerThe unreachable statement – asserting the impossibleDeferring decisionsSummaryLock it inAnswers
Error Handling
Technical requirementsZig’s error handling philosophyWhat’s an error value?Enums: When you’re tired of magic numbers ruining your dayswitch statements revisited: For when you need even more control flowEnum literals: Saving you a few microseconds of typingNon-exhaustive enums: Keep your options openIntrospection: When you want to play detective in your own codeEnum type information: Dive deeper if you dareUnionsTagged unions: Adding a tag for safetyErrors: Turning failures into manageable eventsError sets: Enumerating the possible mishapsHandling errors with try and catchError unions: Combining errors with valuesHandling error unionsCoercing error setsThe errdefer statement: Cleaning up after errorsWhy Zig embraces error valuesWhy do error sets matter?Error return traces: Breadcrumbs for when it all goes wrongThe anatomy of an error return traceError return traces are better than stack tracesEnabling and using error return tracesWhy you’ll actually love error return tracesSummaryReinforcing your understanding of enums, unions, and errors in ZigAnswersJoin us on Discord!
Testing Your Zig Code
Technical requirementsUnit testing: because debugging is a form of self-tortureWhy bother with unit tests?Understanding the test structureEmbracing failure (in your tests, not in life)std.testing: Zig’s not-so-secret weapon for code confidenceLeveraging the testing allocatorFiltering testsMaking the most of std.testingTest structure: Organizing your tests (so you can find them later)The art of keeping tests closeNaming conventions: because vague names help no oneLeveraging doctests: Kill two birds with one stoneRunning tests: the moment of truth (will It blend?)Test coverageUsing kcov: Step by stepGenerating coverage for testsLimitations and ConsiderationsSummaryTest time!Answers
Data, Memory, and Tools

Organizing Data
Technical requirementsArrays: fixed-size collections of thingsA few good arraysBecause size mattersIterating over arraysModifying arraysCompile-time array magicInitialize arrays to zeroMultidimensional arrays: like arrays, but moreSentinel-terminated arrays: because sometimes you need a flagSlices: dynamic views into arraysStep 1: Arrays and their royal stubbornnessStep 2: Introducing slices (runtime flexibility)Step 3: A more complex scenario – filtering and sub-slicingStep 4: Treating strings as slicesStep 5: Sentinel-terminated slices (because some APIs are stuck in the past)Structs: your own custom data (because you’re special)Step 1: A simple struct (the basics)Step 2: Adding functions to structs (methods, but not really)Step 3: Namespaced declarations and empty structsStep 4: Field parent pointers (fancy reflection)Step 5: Default field values done rightStep 6: Packed structs (memory layout shenanigans)Step 7: Anonymous structs and tuplesSummaryLet’s make this knowledge stick!Join us on Discord!
Memory Management
Technical requirementsStack and heap: The two-headed beast of memoryMemory and processes (at a glance)StackHeapOther sections (we swear they exist)Pointers: The good, the bad, and the ugly (but mostly good)Why bother with pointers?Getting a pointer: & (address of)Explicit mutabilityPointer semanticsCompile-time safetyPointer array accessConverting between pointers and integersvolatilevolatile versus concurrencyCasting pointers: Loot boxes and mystery bytesWhy use @alignCast with @ptrCast?Reinterpreting bitsSingle-item versus many-item pointersSlicing with pointersPointer arithmetic: A loaded gunAllocation: The art of asking for more memory (and getting it)Zig versus mainstream languages: The babysitters and the grown-upsAllocators interfaceAllocators in Zigalloc: Grabbing memory manuallyfree: Return it or sufferresize: Asking politely for morecreate: Single-item allocationdestroy: Free that single itemLifetime considerationsTesting allocators: std.testing.allocatorTesting your equipmentHandling allocation failures: std.testing.failing_allocatorFixedBufferAllocator: Your first real allocatorThe GeneralPurposeAllocator(s): Plural? Yes, plural.The page allocator: The unsung heroThe arena allocator: A playground for memory managementThe elephant in the room: Safety, part 2Zig’s design philosophy: Honest, explicit, and controlledZero-sized types: The phantom menace of memory management (but they have their uses)A type that stores nothingvoid versus anyopaqueIgnoring expressionsShrinking your code with zero-sized typesType conversion (casting): When your data needs a disguiseType coercion: Safe and automaticWhen coercion failsC pointers special casePeer type resolutionSummary
The Standard Library
Technical requirementsCommon data structures: ArrayLists, HashMaps, and other fun things Party Members: ArrayLists in Zig — the art of controlled chaosinit: raising the bannerappend: the delusion of safetyCapacity: the chess gameThe unmanaged hordeInsertions and removals: the dance of deathThe sentinel gambitThe philosophy of painEpilogue: why bother?HashMaps: the tavern brawlers of data structuresKey operations (pun intended)The dark arts of hashingTombstones: the ghosts of hashes pastAdapt or perish: contexts and customizationZig versus the worldBoss fight: test your gearFile I/O: reading, writing, and wrangling files like a boss Opening act: the filesystem dungeonOpening files: negotiating with the file system’s bouncerReading files: from bytes to bragging rightsWriting files: carving your legacy into the diskBinary files: telepathy for machinesBuffered I/O: the blazing-fast optionFile sync: the ritual of flushingFile seeking: time travel for bytesError handling: Zig’s “No BS” policyFile permissions: the guardian spellsHard links: the doppelgänger filesFinal boss challenge: the atomic loggerThe Zig filesystem creedUntapped territories in Zig file operations: the lost scrolls File modes and flags: the fine print of file creationMemory-mapped files: the necromancy of I/ODisk space intel: the scout’s reportSymbolic link creation: traps for the unwaryAdvanced error recovery: the phoenix protocolFormatting and printing: making your output look pretty (or at least legible)Why std.fmt? Precision meets flexibilityCore tools: crafting strings with purposeAdvanced techniques: precision, padding, and personalityCustom formatting: make your types shineQuiz time: spot the mistakeOther utilities: random numbers, time, and more fun stuffRandomness: choose your weapon wiselyTime: raw, unfiltered, and unapologeticWhy no DateTime?Iterators: scalpels versus chainsaws1. std.mem.SplitIterator2. std.mem.TokenIteratorSorting: no training wheels, no regretsThe Zig difference: no magic, no compromisesFinal challengestd.mem utilities: a comprehensive guideCore operationssetMemory manipulationAdvanced utilitiesIteration and splittingChallenge solution: 64-byte chunk processorSummaryJoin us on Discord!
Packing
Technical requirementsThe Zig build system: automating your workflowzig init: your project’s starter kit (with free existential dread)The yin and yang of Zig’s init twinsbuild.zig dissected: what’s in the box?Using zig buildBuildingTestingRunningCustomizing build.zig: from Meh to MVP**Cross-compilation: Zig’s party trick (1 code base, 57 platform-specific bugs)Tier 1: production-ready supportTier 2: community-maintained supportTier 3: experimental or minimal supportTier 4: deprecated or legacy supportUsing the targetWhy do these matter?Release modesOptimizations: Debug versus Release (choose your poison)DebugReleaseSafeReleaseFastReleaseSmallMix and matchUndefined behavior and granular controlCustom optionsThe build teamSteps: the atomic actions of a build pipelineThe taxonomy of stepsThe DAG: Git’s angrier cousinDeclarative syntax: the illusion of simplicityCustom steps: the build system’s escape hatchThe RPG side quest principleThe philosophy beneathModulesCode islandsDependency hoardersConfiguration fetishistsThe circle of (module) life: from declaration to dominationDeclaration: the grand proclamationConfiguration: the fiddling and tweakingIntegration: joining the big leaguesMulti-module mania: when modules collideThe show must go onThe grand finalePop quiz: Are you smarter than a build script?Generating docs: because code should be less cryptic than ancient runesDoc comments: breadcrumbs for future-youGenerating docs: the compiler’s side hustleError set dramaWeaponize the build systemPackage management: because reinventing the wheel is so last centurybuild.zig.zon: your new best friend (or worst enemy, the jury’s still out)zig fetch: your command-line dependency fetcherPutting dependencies to work: from build.zig.zon to @importImportant naming relationshipFrom fingerprint to fortressBeyond the usual suspectsCache: the memory of the compilerCore concepts (how to avoid recompiling the universe)Content-addressable storage (everything has a unique fingerprint)Manifest files (the librarian’s secret notebook)Cache workflow (the dance of hashes)The Zig build cache directoriesReal-world scenarios (proof that it works)Performance and reliability (fast and correct)Why this matters (the “so what?” section)zig build --watch: your new best friend (who doesn’t talk back)Why this is better than the old waySummary
Advanced Zig and Real-World Application
Sophisticated Topics
Technical requirementscomptime: The time machine you didn’t know you neededcomptime basicsType inference: Schrödinger’s integerEvery block, every time: The backbone of comptimeZig’s double identity: Compile time versus runtimeCompile-time Zig: The master plannerRuntime Zig: The speed demonThe golden rule for calling comptime functionsThe type supertype: Compile time’s bouncerCompile-time exclusivityType functions: The type-generating powerhousesBuilding simple typesLeveling up: Creating structsTools of the trade: @typeOf, @typeInfo, and @Type@typeOf: The detective@typeInfo: The magnifying glass@Type: Bringing types to lifeReflection and metaprogramminganytype: The Swiss Army knife of typesCommon pitfalls: When types fight backMistake 1: Using anytype where type is requiredMistake 2: Confusing compile time with runtime contextsMistake 3: The “everything should be anytype” trapMistake 4: Forgetting about type coercion rulesMistake 5: Type parameter naming confusioncomptime budgets: The branch quotaThe override: What is @setEvalBranchQuota()?Threads in Zig: Herding cats with a laser pointerSpawning threads: Welcome to the ThunderdomeSharing data: Mutexes are your bouncersMutexes: The bouncers of your nightclubAtomics: The cheetahs of concurrencyPitfalls: How to summon a segfault demonPerformance considerations: Don’t be a resource hogInteroperability with C: When you need to borrow someone else’s tools (but make them work your way)C: The cockroach of code (and why you’ll learn to love/hate it)ABI@cImport: Your gateway to the C underworldCalling Zig from C: Exporting your chaosPlaying nice with C: Structs, alignment, and the quest for interoperability (RPG edition)Extern structs: Your diplomatic passport to CAlignment: The CPU’s picky preferencesPacked structs: The Tetris champions of memoryBit-aligned pointers: Navigating the bitstreamThe perils of [*c]T: Zig’s C pointer (and why you should (almost) never use it)SummaryJoin us on Discord!
Real-World Zig
Technical requirementsCommand-line tools: automating your life (and annoy your coworkers)FileGuard architecture: building your first real-world applicationThe file monitoring challengeDesign decisions: working smarter, not harderProject structure: breaking it downThe implementation roadmapImplementing file metadata: the foundation of change detectionThe FileMetadata struct: identity, state, and ownershipInitializing file metadata: the birth of a tracking recordMemory management: the circle of lifeCloning metadata: sometimes you need a perfect copyContent hashing: when size and timestamp aren’t enoughCross-platform considerations: the beauty of abstractionPutting it all together: the complete file metadata implementationBuilding a file index: organizing your digital filing cabinetThe FileIndex struct: a tale of two mapsInitializing the index: setting up shopCleanup: leaving no trace behindAdding files: populating your indexLookup operations: finding your filesCloning the index: sometimes you need a perfect copyRemoving files: when it’s time to say goodbyeCounting files: how big is your collection?The power of dual indexing: path and inode lookupsMemory management: the path tracking mystery explainedDirectory traversal: exploring your digital wildernessThe TraversalConfig: your expedition parametersPattern matching: your file-finding filterThe file filter: should we include this file?The main traversal: your digital safariHandling symbolic links: the portals of the filesystemThe traversal dance: how it all works togetherPerformance considerations: traversal isn’t freeChange detection: spot the differences in your digital worldDefining change types: building your detective’s notebookRepresenting changes: the FileChange structThe change journal: collecting your evidenceDetection configuration: customizing your detective workThe main detection algorithm: finding your culpritsDetecting file modifications: the devil in the detailsThe magic of move detection: inodes to the rescueBuilding the command-line interface: making FileGuard user-friendlyCommand-line options: giving users controlParsing arguments: turning text into configurationDisplaying help: guiding lost soulsRunning the monitor: the main event loopReporting changes: making results human-readableError handling: when things go wrongBeyond the basics: professional CLI featuresTying it all together: the main program and beyondBuilding and wrangling dependenciesBuilding and running FileGuard: from code to executableExtending FileGuard: the road to professional useOther project ideas: the sky’s the limit (or at least the memory limit)Community resources: forums, chat rooms, and other dens of iniquity (we mean knowledge)Contributing to Zig: open-source development for the greater good (and your resume)The roadmap: Zig’s future plans (world domination, probably)Zig’s impact: case studies and success stories (from humble beginnings to tech giants)Summary
Unlock Your Book’s Exclusive Benefits
How to unlock these benefits in three easy stepsStep 1Step 2Step 3Need help?
Other Books You May Enjoy
Index

Overview

Discover the Zig programming language, a modern system programming language designed for performance and safety. This book introduces you to Zig's direct control and explicit memory management capabilities, teaching you to write efficient, reliable, and portable software.

What this Book will help me do

Understand and utilize Zig's novel safety and performance features.
Set up development environments and build systems tailored for Zig projects.
Master manual memory management to enhance software reliability.
Leverage Zig's interoperability with C and other libraries for seamless integration.
Develop and distribute cross-platform applications using Zig.

Author(s)

Alex Rios, a seasoned software engineer with extensive experience in high-throughput systems for fintech, telecom, and gaming, shares his pragmatic insights on programming in Zig. Drawing from his diverse background, Alex presents Zig as an innovative tool for systems programming, delivering nuanced examples and deep technical discussions.

Who is it for?

This book is ideal for system programmers seeking practical insights into Zig's capabilities, embedded developers aiming at efficient memory management, and experienced programmers transitioning from other languages like Go or C. Readers should have a basic understanding of programming but can approach this book as their entry into Zig and modern system programming techniques.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781835085127

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills