book

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 › 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 › 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 › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Appendix A.1 Sets and Functions

Sets A set is a collection of objects called elements. If $a$ is an element of a set $A$, we write $$ a\in A. $$ If $a$ is not an element of $A$, we write $$ a\notin A. $$ Sets are fundamental throughout mathematics because nearly every mathematical structure can be described in terms of collections and relations between collections. Examples include: $$ \mathbb{N}={1,2,3,\ldots}, $$ $$ \mathbb{Z}={\ldots,-2,-1,0,1,2,\ldots}, $$ and finite...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Future Directions in Number Theory

The Expanding Landscape Modern number theory continues to evolve rapidly. Classical themes such as primes, Diophantine equations, and reciprocity laws remain central, but the subject now interacts deeply with: computation, geometry, physics, probability, topology, cryptography, machine-assisted mathematics. Future developments will likely come not from a single direction, but from increasingly interconnected structures. Number theory has become both more abstract and more computational at the same time. Arithmetic Geometry Arithmetic geometry...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

The Langlands Program

A Grand Unifying Vision The Langlands program is one of the largest and most influential research programs in modern mathematics. Initiated by entity["people","Robert Langlands","Canadian mathematician"] in the late 1960s, it proposes deep correspondences connecting: number theory, representation theory, harmonic analysis, algebraic geometry, arithmetic geometry. At its core, the program predicts that arithmetic information carried by Galois groups corresponds to analytic information carried by automorphic forms and representations. The program is...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

The Birch and Swinnerton-Dyer Conjecture

Elliptic Curves and Rational Points An elliptic curve over $\mathbb{Q}$ may be written in Weierstrass form $$ E:y^2=x^3+ax+b, $$ where $$ 4a^3+27b^2\neq0. $$ The rational points $$ E(\mathbb{Q}) $$ form an abelian group. By the Mordell-Weil theorem, $$ E(\mathbb{Q}) \cong E(\mathbb{Q})_{\mathrm{tors}} \oplus \mathbb{Z}^r. $$ The finite subgroup $$ E(\mathbb{Q})_{\mathrm{tors}} $$ contains torsion points, while $$ r $$ is the rank. The rank measures the number of independent infinite-order rational points....

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

The Riemann Hypothesis

The Zeta Function The Riemann zeta function is one of the central objects in mathematics. For complex numbers $s$ with $$ \operatorname{Re}(s)>1, $$ it is defined by the convergent series $$ \zeta(s)=\sum_{n=1}^{\infty}\frac1{n^s}. $$ It may also be written as the Euler product $$ \zeta(s) = \prod_p \left(1-\frac1{p^s}\right)^{-1}, $$ where the product runs over all primes. This identity connects the zeta function directly to the prime numbers. Analytic Continuation Although the...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Fermat's Last Theorem

The Statement Fermat's Last Theorem states that there are no positive integers $$ x,y,z $$ satisfying $$ x^n+y^n=z^n $$ when $$ n>2. $$ For $n=2$, the equation $$ x^2+y^2=z^2 $$ has many solutions, called Pythagorean triples. For example, $$ 3^2+4^2=5^2. $$ Fermat's Last Theorem says that this phenomenon stops completely for powers greater than $2$. Reduction to Prime Exponents It is enough to prove the theorem when $n$ is prime....

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Open Problems in Number Theory

The Nature of Open Problems Number theory contains some of the oldest and deepest unsolved problems in mathematics. Many are deceptively simple to state. Elementary questions about divisibility, primes, rational points, or polynomial equations often resist centuries of effort. Open problems serve several purposes: they organize research directions, they reveal structural gaps in current theory, they connect different branches of mathematics, they motivate new techniques and conjectures. Modern number theory...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Arithmetic Statistics

Statistics in Arithmetic Arithmetic statistics studies the distribution of arithmetic objects inside large families. Instead of analyzing a single integer, elliptic curve, number field, or modular form, one asks statistical questions: How common are certain properties? What does a typical object look like? Which invariants have limiting distributions? How often do exceptional behaviors occur? This subject combines number theory, probability, algebraic geometry, and random matrix theory. Arithmetic statistics is one...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Probabilistic Models for Primes

Primes as Rare Events Prime numbers are deterministic objects, but many aspects of their distribution resemble random behavior. The prime number theorem states that the number of primes up to $x$ satisfies $$ \pi(x)\sim \frac{x}{\log x}. $$ Equivalently, a large integer near $x$ behaves heuristically as if it were prime with probability $$ \frac1{\log x}. $$ This observation motivates probabilistic models for primes. Such models do not claim that primes...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Random Matrices and Zeta Zeros

Zeros as Spectral Data The Riemann zeta function is defined for $\operatorname{Re}(s)>1$ by $$ \zeta(s)=\sum_{n=1}^{\infty}\frac{1}{n^s}. $$ It admits analytic continuation to most of the complex plane and satisfies a functional equation. Its nontrivial zeros lie in the critical strip $$ 0<\operatorname{Re}(s)<1. $$ The Riemann Hypothesis states that every nontrivial zero has the form $$ s=\frac12+i\gamma. $$ The numbers $\gamma$ may be viewed as spectral data. They behave, in many statistical...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Parity Problem

A Fundamental Limitation of Sieve Methods Sieve methods are extremely effective for estimating how many integers avoid small prime factors. They have produced major results about: almost primes, primes in arithmetic progressions, bounded gaps, additive prime problems. However, classical sieve methods encounter a deep structural obstacle known as the parity problem. Roughly speaking, sieves cannot reliably distinguish integers with: an even number of prime factors, an odd number of prime...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Chen's Theorem

Approximating the Twin Prime Conjecture The Twin Prime Conjecture states that infinitely many primes satisfy $$ p+2\text{ prime}. $$ Despite enormous effort, this remains open. One of the greatest achievements of sieve theory is Chen's theorem, proved by entity["people","Chen Jingrun","Chinese mathematician"] in 1973. Chen showed that infinitely many primes $p$ satisfy $$ p+2 $$ having at most two prime factors. Thus infinitely many numbers of the form $$ (p,p+2) $$...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Probabilistic Algorithms

Randomness as a Computational Resource A probabilistic algorithm uses random choices during its execution. In number theory, this is often a practical advantage rather than a weakness. Many arithmetic problems have deterministic structure but become easier when one samples random residues, random group elements, random curves, or random auxiliary parameters. Randomness is useful because it can avoid worst-case patterns, find witnesses quickly, and replace exhaustive search with high-probability success. Monte...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Bombieri-Vinogradov Theorem

Average Distribution of Primes The Prime Number Theorem for arithmetic progressions states that for $$ (a,q)=1, $$ the primes are asymptotically evenly distributed among residue classes modulo $q$: $$ \pi(x;q,a) \sim \frac{\operatorname{li}(x)}{\varphi(q)}. $$ However, proving strong error terms uniformly for large moduli $q$ is extremely difficult. The Generalized Riemann Hypothesis predicts essentially optimal uniform bounds. Remarkably, the Bombieri-Vinogradov theorem achieves GRH-level strength on average over moduli, without assuming GRH. This...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Geometric Langlands Theory

From Arithmetic to Geometry The classical Langlands program relates: automorphic representations; Galois representations; $L$-functions. Its original setting is arithmetic: number fields, primes, and automorphic forms. Geometric Langlands theory transforms this picture into geometry. Instead of studying number fields, one studies algebraic curves over fields such as $$ \mathbb{C}. $$ Instead of automorphic functions, one studies sheaves and categories. Instead of Galois representations, one studies local systems and flat bundles. The...

Writes › Book › Modern Number Theory › Appendix ›

Hints for Selected Problems

Hints for Problem Set 1. Foundations 1. Sum of Two Even Integers Write the two integers as $$ a=2m,\qquad b=2n. $$ Then factor $2$ from $a+b$. 2. Product of Two Odd Integers Write $$ a=2m+1,\qquad b=2n+1. $$ Expand $ab$, then show it has the form $2k+1$. 3. If $n^2$ Is Even, Then $n$ Is Even Use proof by contrapositive. Assume $n$ is odd. Then write $$ n=2k+1. $$ Show that...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Brun-Titchmarsh Theorem

Primes in Arithmetic Progressions One of the central problems of analytic number theory is understanding how primes distribute among residue classes. For integers $a$ and $q$ with $$ (a,q)=1, $$ define $$ \pi(x;q,a) = #{p\leq x : p\equiv a\pmod q}. $$ The Prime Number Theorem for arithmetic progressions states that $$ \pi(x;q,a) \sim \frac{\operatorname{li}(x)}{\varphi(q)}. $$ However, this asymptotic theorem becomes difficult to use when $q$ grows with $x$. The Brun-Titchmarsh...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Probabilistic Primality

Deterministic and Probabilistic Testing A primality test determines whether an integer is prime. Some algorithms provide absolute certainty. These are deterministic primality tests. Other algorithms allow a small probability of error. These are probabilistic primality tests. In practice, probabilistic methods are often much faster and simpler. For cryptographic applications, an error probability smaller than hardware failure rates is usually acceptable. Modern computational number theory therefore relies heavily on probabilistic primality...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Shimura Varieties

Higher-Dimensional Modular Curves Modular curves parameterize elliptic curves and connect modular forms with arithmetic geometry. Shimura varieties generalize this idea to higher dimensions. They are moduli spaces associated with more general algebraic groups and parameterize richer geometric structures such as: abelian varieties; Hodge structures; additional endomorphisms; level structures. Shimura varieties occupy a central position in the Langlands program because their geometry naturally carries both: automorphic information; Galois information. They are...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Trace Formulas

Generalized Fourier Analysis Fourier analysis decomposes functions into harmonic frequencies. For functions on the circle, the exponential functions $$ e^{2\pi i n x} $$ form the spectral building blocks. Automorphic representation theory requires a vastly more sophisticated version of this idea. The trace formula is the fundamental tool for performing harmonic analysis on nonabelian arithmetic quotients. It relates: spectral information from automorphic representations; geometric information from conjugacy classes and orbital...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Large Sieve

From Arithmetic Progressions to Harmonic Analysis Classical sieve methods estimate how many integers survive congruence restrictions. The large sieve approaches these problems from a different direction. Instead of counting integers directly, the method estimates the average size of exponential sums and character sums over many moduli simultaneously. The large sieve therefore connects: sieve theory, Fourier analysis, harmonic analysis on finite groups, distribution of arithmetic sequences. It became one of the...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Frobenius Automorphisms

Arithmetic Symmetry of Primes One of the deepest ideas in algebraic number theory is that prime numbers possess hidden symmetry inside field extensions. Suppose $$ L/K $$ is a finite Galois extension of number fields with Galois group $$ G=\operatorname{Gal}(L/K). $$ Let $$ \mathfrak p $$ be a prime ideal of $$ \mathcal O_K, $$ and let $$ \mathfrak P $$ be a prime ideal of $$ \mathcal O_L $$...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Decomposition and Inertia Groups

Galois Symmetry and Prime Ideals Let $$ L/K $$ be a finite Galois extension of number fields with Galois group $$ G=\operatorname{Gal}(L/K). $$ Suppose $$ \mathfrak p $$ is a prime ideal of $$ \mathcal O_K, $$ and let $$ \mathfrak P $$ be a prime ideal of $$ \mathcal O_L $$ lying above $\mathfrak p$, meaning $$ \mathfrak P\cap\mathcal O_K=\mathfrak p. $$ The Galois group acts on prime ideals:...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Selberg Sieve

Refining Sieve Methods Brun's sieve introduced the idea of estimating sifted sets through truncated inclusion-exclusion. However, Brun's method often produced bounds that were technically difficult to optimize. entity["people","Atle Selberg","Norwegian mathematician"] developed a more flexible approach known as the Selberg sieve. Instead of truncating inclusion-exclusion directly, Selberg constructed carefully chosen weight functions that minimize error terms. The method became one of the central techniques of modern sieve theory. The Sifting Problem...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Smooth Numbers

Definition A positive integer is called $y$-smooth if all of its prime factors are at most $y$. For example, $$ 72=2^3\cdot 3^2 $$ is $3$-smooth, because its only prime factors are $2$ and $3$. The integer $$ 210=2\cdot3\cdot5\cdot7 $$ is $7$-smooth, but not $5$-smooth. Smooth numbers are integers whose prime factors are small relative to their size. They form a sparse but highly structured subset of the positive integers. The...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Automorphic $L$-Functions

Generalized Zeta Functions The Riemann zeta function $$ \zeta(s) = \sum_{n=1}^\infty \frac1{n^s} = \prod_p \frac1{1-p^{-s}} $$ encodes the arithmetic of prime numbers. Modern number theory studies vast generalizations of this function called automorphic $L$-functions. These functions arise from automorphic representations and modular forms. They unify many classical analytic objects, including: Dirichlet $L$-functions; Dedekind zeta functions; modular $L$-functions; Hasse-Weil $L$-functions. Automorphic $L$-functions lie at the center of the Langlands program. Euler...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Brun Sieve

Sieve Methods Sieve methods are techniques for counting integers that remain after removing residue classes modulo primes. The basic idea is ancient. To find primes up to $x$, one removes multiples of small primes: $$ 2,3,5,7,\ldots $$ The remaining numbers have no small prime factors. This is the idea behind the sieve of Eratosthenes. Modern sieve theory turns this procedure into a quantitative analytic method. It estimates the size of...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Ramification of Primes

Prime Factorization in Extensions In the ordinary integers, every nonzero integer factors uniquely into prime numbers. In algebraic number theory, one studies how ordinary primes behave inside the ring of integers of a number field. Let $$ K/\mathbb{Q} $$ be a number field extension, and let $$ \mathcal O_K $$ be its ring of integers. A rational prime $$ p $$ generates the ideal $$ (p)=p\mathcal O_K. $$ Unlike ordinary...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Random Integers

Arithmetic as a Probabilistic Object Number theory often studies exact statements about individual integers. For example, one may ask whether a given integer is prime, squarefree, smooth, or representable as a sum of squares. Probabilistic number theory asks a different kind of question: what does a typical integer look like? Instead of studying one integer at a time, we study large intervals such as $$ {1,2,\ldots,N} $$ and examine what...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Functoriality

Transfers Between Symmetries The Langlands program predicts that many different arithmetic objects are connected by systematic transfers. These transfers are called functoriality. At a basic level, functoriality says that a relationship between symmetry groups should produce a relationship between automorphic representations. This principle turns scattered identities in number theory into instances of one general mechanism. Class field theory, base change, modularity, and many lifting theorems can all be viewed as...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Schnirelmann Density

Measuring Additive Size In additive number theory, ordinary asymptotic density is often too weak to control additive behavior. For example, a set may have density zero yet still represent all sufficiently large integers after repeated addition. Prime numbers are an important example. To study additive growth more effectively, entity["people","Lev Schnirelmann","Russian mathematician"] introduced a stronger density notion adapted specifically to additive problems. This density became one of the foundational tools of...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Local Fields

Localizing Arithmetic Classical number theory studies arithmetic globally over fields such as $$ \mathbb{Q} $$ or number fields. A local field studies arithmetic near a single prime or near infinity. Instead of considering all divisibility simultaneously, one focuses on one valuation at a time. This local viewpoint simplifies many problems and reveals deep structural phenomena invisible globally. The central examples are: the real numbers $\mathbb{R}$, the complex numbers $\mathbb{C}$, the...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Zero-Knowledge Proofs

Proving Without Revealing A zero-knowledge proof allows one party to convince another that a statement is true without revealing why it is true. This idea appears paradoxical at first. Traditional proofs reveal logical structure and intermediate reasoning. Zero-knowledge proofs instead reveal only the validity of the statement. The subject combines: computational complexity, number theory, algebra, probability, cryptography. Zero-knowledge protocols are now central in privacy-preserving systems, authentication, blockchains, and modern cryptographic...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Galois Representations

Arithmetic Symmetry as Linear Algebra Galois groups encode the symmetries of algebraic equations and field extensions. Unfortunately, absolute Galois groups are usually enormous and extremely complicated. For example, $$ \mathrm{Gal}(\overline{\mathbb{Q}}/\mathbb{Q}) $$ is a profinite group of immense complexity. To study such groups, one translates their abstract symmetry into linear algebra. This leads to Galois representations. A Galois representation converts arithmetic symmetry into matrices acting on vector spaces. Modern number theory...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Additive Bases

Representing Integers by Sums A central question in additive number theory asks whether every integer can be represented as a sum of elements from a fixed set. Let $$ A\subseteq \mathbb N. $$ We say that $A$ is an additive basis if sufficiently large integers can be written as sums of finitely many elements of $A$. The subject studies how additive structure emerges from repeated summation of sets. Basis of...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

$p$-Adic Numbers

A New Arithmetic Geometry The real numbers arise by completing the rational numbers using the ordinary absolute value. The $p$-adic numbers arise by completing the rational numbers using the $p$-adic absolute value. This produces a radically different geometry. In the real numbers, powers of large integers grow without bound: $$ 2^n\to\infty. $$ In the $2$-adic world, $$ 2^n\to0. $$ The geometry is governed not by magnitude but by divisibility. The...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Post-Quantum Cryptography

The Quantum Threat Modern public-key cryptography relies heavily on two computational assumptions: factoring large integers is hard, discrete logarithms are hard. RSA depends on factoring. Diffie-Hellman and elliptic curve cryptography depend on discrete logarithms. Quantum computation changes this landscape dramatically. entity["people","Peter Shor","American mathematician"] discovered algorithms showing that sufficiently powerful quantum computers could solve both problems in polynomial time. A large fault-tolerant quantum computer would therefore break much of current public-key...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

The Langlands Program

A Grand Unification The Langlands program is one of the most ambitious and influential theories in modern mathematics. Proposed by entity["people","Robert Langlands","Canadian mathematician"] in the late 1960s, it predicts deep correspondences between: automorphic representations; Galois representations; $L$-functions; harmonic analysis; arithmetic geometry. At its core lies a unifying philosophy: Arithmetic symmetry and analytic symmetry are manifestations of the same underlying structure. The program generalizes class field theory from abelian extensions to...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Exponential Sums

Oscillation in Number Theory Exponential sums are among the central tools of analytic number theory. They measure cancellation in oscillatory arithmetic expressions and provide quantitative control over additive structure. A typical exponential sum has the form $$ \sum_{n} e^{2\pi i f(n)}, $$ where $f(n)$ is a real-valued arithmetic function. Because complex exponentials oscillate around the unit circle, large cancellation often occurs. Understanding this cancellation is fundamental in problems involving primes,...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Valuations and Absolute Values

Measuring Arithmetic Size In ordinary analysis, the absolute value $$ |x| $$ measures the size of a real number. In number theory, one studies more general notions of size that reflect arithmetic divisibility rather than geometric distance. These generalized size functions are called valuations or absolute values. They allow arithmetic to be studied analytically and lead naturally to $p$-adic numbers, local fields, and modern arithmetic geometry. Ordinary Absolute Value The...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Dedekind Domains

Arithmetic Beyond Unique Factorization Ordinary integers satisfy several remarkable properties simultaneously: every ideal is principal, every nonzero element factors uniquely into primes, every nonzero ideal factors uniquely into prime ideals. When algebraic number theory developed, mathematicians discovered that many rings of algebraic integers lose some of these properties. Unique factorization of elements may fail, and ideals need not be principal. Nevertheless, rings of integers still possess enough structure to support...

Writes › Book › Modern Number Theory › Appendix ›

Suggested Projects and Explorations

Project 1. Prime Number Experiments Goals Study empirical properties of prime numbers through computation. Possible Tasks Implement the sieve of Eratosthenes. Plot the prime counting function $$ \pi(x). $$ Compare $$ \pi(x) $$ with $$ \frac{x}{\log x}. $$ Investigate prime gaps. Search for twin primes. Compute distributions of primes modulo small integers. Extensions Study the Chebyshev functions. Experiment with probabilistic prime models. Compare actual prime counts with logarithmic integral approximations....

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Lattice Cryptography

Cryptography from Lattice Problems Lattice cryptography is a family of cryptographic systems based on the presumed hardness of computational problems on high-dimensional lattices. A lattice is a discrete set of points in Euclidean space generated by integer combinations of basis vectors: $$ L=\mathbb{Z}b_1+\cdots+\mathbb{Z}b_n. $$ The security of lattice cryptography comes from the difficulty of problems such as finding short vectors, finding close lattice points, or recovering hidden linear structure in...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Circle Method

Additive Representation Problems Many problems in additive number theory ask whether an integer can be represented in the form $$ n=a_1+a_2+\cdots+a_k, $$ where the variables satisfy arithmetic restrictions. Examples include: Goldbach-type problems, Waring's problem, representations by quadratic forms, additive problems involving primes. The Hardy-Littlewood circle method is one of the most powerful techniques for studying such questions. The method transforms arithmetic counting problems into problems of harmonic analysis on the...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Automorphic Representations

From Functions to Representations Classical modular form theory begins with analytic functions satisfying symmetry conditions. Modern theory shifts perspective. Instead of studying individual functions directly, one studies the representations generated by these functions under group actions. This transition from functions to representations is one of the defining conceptual advances of twentieth-century mathematics. Automorphic representations provide the natural language for: automorphic forms; Hecke operators; $L$-functions; the Langlands program. They unify harmonic...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Principal Ideals

Ideals Generated by One Element Let $R$ be a commutative ring. An ideal $I\subseteq R$ is called principal if there exists an element $\alpha\in R$ such that $$ I=(\alpha). $$ This notation means $$ (\alpha)={\alpha r:r\in R}. $$ Thus a principal ideal consists of all multiples of a single element. In the ordinary integers, $$ (n)=n\mathbb{Z} $$ is the set of all multiples of $n$. For example, $$ (6)={\dots,-12,-6,0,6,12,\dots}. $$...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Waring's Problem

Sums of Powers Waring's problem asks whether every sufficiently large positive integer can be written as a sum of a bounded number of fixed powers. For example, one may ask whether every large integer can be written as a sum of squares, $$ n=x_1^2+x_2^2+\cdots+x_k^2, $$ or as a sum of cubes, $$ n=x_1^3+x_2^3+\cdots+x_k^3. $$ Here the exponent is fixed, while the number of summands is allowed to depend on that...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Pairing-Based Cryptography

Bilinear Pairings Pairing-based cryptography uses special maps defined on elliptic curve groups. A pairing is a function $$ e:G_1\times G_2\to G_T, $$ where $G_1$, $G_2$, and $G_T$ are finite groups, usually of the same large prime order. The key property is bilinearity. For all integers $a,b$ and group elements $P\in G_1$, $Q\in G_2$, $$ e([a]P,[b]Q)=e(P,Q)^{ab}. $$ This identity makes pairings useful in cryptography. It allows multiplicative relations among hidden exponents...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Automorphic Forms

Beyond Modular Forms Modular forms are functions on the upper half-plane satisfying symmetry conditions under the modular group $$ SL_2(\mathbb{Z}). $$ They encode deep arithmetic information and connect complex analysis with number theory. Automorphic forms generalize this idea. Instead of studying functions invariant under subgroups of $$ SL_2(\mathbb{Z}), $$ one studies functions on much more general groups and symmetric spaces. This broader theory unifies: modular forms; representation theory; harmonic analysis;...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Discriminants

Measuring Arithmetic Complexity The discriminant is one of the most important invariants of a number field. It measures how the arithmetic of the field differs from ordinary rational arithmetic. Roughly speaking, the discriminant detects: linear dependence among embeddings, ramification of primes, geometric density of the ring of integers, arithmetic complexity of the field. It appears throughout algebraic number theory, arithmetic geometry, and analytic number theory. Discriminant of a Polynomial Let...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Goldbach Problems

Additive Questions About Primes Goldbach-type problems ask whether integers can be represented as sums of primes. They are among the oldest and most famous problems in additive number theory. The guiding question is simple: $$ n=p_1+p_2+\cdots+p_k, $$ where the $p_i$ are prime numbers. Such questions connect two different aspects of primes. Multiplicatively, primes are the building blocks of integers. Additively, they appear to behave like a dense enough set to...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Elliptic Curve Cryptography

From Finite Fields to Elliptic Curves Elliptic curve cryptography is a public-key cryptographic framework based on the arithmetic of elliptic curves over finite fields. Classical Diffie-Hellman uses exponentiation in a finite cyclic group. Elliptic curve cryptography replaces this with scalar multiplication on an elliptic curve group. Instead of computing $$ g^n, $$ one computes $$ [n]P. $$ Here $P$ is a point on an elliptic curve, and $[n]P$ means adding...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

The Modularity Theorem

From Elliptic Curves to Modular Forms For centuries, elliptic curves and modular forms were studied as separate objects. Elliptic curves arose from algebraic equations and Diophantine problems. Modular forms arose from complex analysis and modular symmetry. The modularity theorem revealed that these two theories are fundamentally the same. Every elliptic curve over $\mathbb{Q}$ corresponds to a modular form. This theorem is one of the deepest achievements of twentieth-century mathematics and...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Units and Dirichlet Unit Theorem

Multiplicative Invertibility Let $K$ be a number field and let $$ \mathcal O_K $$ be its ring of integers. An element $$ u\in\mathcal O_K $$ is called a unit if it has a multiplicative inverse inside $\mathcal O_K$. That is, there exists $$ v\in\mathcal O_K $$ such that $$ uv=1. $$ The set of all units forms a multiplicative group denoted $$ \mathcal O_K^\times. $$ Units generalize the familiar invertible...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Class Groups

Measuring Failure of Unique Factorization In ordinary integers, every ideal is generated by a single element: $$ I=(n). $$ This property is closely related to unique factorization. In rings of integers of number fields, not every ideal is principal. The obstruction to principality is measured by the class group. The class group is one of the central invariants of algebraic number theory. It measures how far a ring of integers...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Diffie-Hellman Key Exchange

The Key Exchange Problem Secure communication requires two parties to share secret information. In classical symmetric cryptography, both parties must already possess the same secret key before communication begins. This raises a practical problem: how can two people agree on a secret key over an insecure channel? The Diffie-Hellman key exchange solves this problem. It allows two parties to create a shared secret even when an attacker can observe all...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Sumsets

Addition of Sets Additive number theory studies arithmetic structure through addition of integers and subsets of integers. Given two subsets $$ A,B\subseteq \mathbb Z, $$ their sumset is defined by $$ A+B = {a+b : a\in A,\ b\in B}. $$ Thus the sumset contains every integer obtainable as a sum of one element from $A$ and one element from $B$. Sumsets measure additive structure and form one of the central...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Elliptic Curves and Modularity

Elliptic Curves as Arithmetic Objects An elliptic curve is simultaneously: an algebraic curve; a complex torus; an abelian group; an arithmetic object. These curves lie at the center of modern number theory. They appear in: Diophantine equations; cryptography; modular forms; Galois representations; the Langlands program. One of the deepest discoveries of twentieth-century mathematics is that elliptic curves over $\mathbb{Q}$ are governed by modular forms. This relationship is called modularity. Algebraic...

Writes › Book › Modern Number Theory › Appendix ›

Problem Sets

Problem Set 1. Foundations Prove that the sum of two even integers is even. Prove that the product of two odd integers is odd. Prove that if $n^2$ is even, then $n$ is even. Prove by induction that $$ 1+2+\cdots+n=\frac{n(n+1)}{2}. $$ Prove by induction that $$ 1^2+2^2+\cdots+n^2=\frac{n(n+1)(2n+1)}{6}. $$ Prove that every integer $n\ge2$ has a prime divisor. Prove that there are infinitely many primes. Show that if $a\mid b$ and...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Generalized Riemann Hypothesis

Extending the Riemann Hypothesis The classical Riemann Hypothesis concerns the zeros of the Riemann zeta function $$ \zeta(s). $$ However, modern number theory studies many other $L$-functions, especially Dirichlet $L$-functions $$ L(s,\chi). $$ These functions possess analytic continuation, Euler products, and functional equations analogous to those of the zeta function. The Generalized Riemann Hypothesis (GRH) extends Riemann’s conjecture to this broader family. Statement of GRH Let $$ \chi $$ be...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Ideals and Prime Ideals

Motivation from Factorization Failure In ordinary integers, every number factors uniquely into primes. In many rings of algebraic integers, this property fails. For example, in $$ \mathbb{Z}[\sqrt{-5}], $$ one has $$ 6=2\cdot3=(1+\sqrt{-5})(1-\sqrt{-5}), $$ with genuinely different factorizations. This failure makes divisibility difficult to control if one works only with elements. The key insight of modern algebraic number theory is that factorization becomes unique again when one replaces elements by ideals....

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Unique Factorization Failure

Unique Factorization in the Integers One of the central properties of the ordinary integers is unique factorization. Every nonzero integer can be written as a product of prime numbers, and this factorization is unique up to order and signs. For example, $$ 60=2^2\cdot3\cdot5. $$ No essentially different prime factorization exists. This theorem, called the fundamental theorem of arithmetic, underlies much of classical number theory. When arithmetic is extended to algebraic...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Norm and Trace

Two Fundamental Invariants Let $K$ be a number field of degree $$ [K:\mathbb{Q}]=n. $$ Each element $\alpha\in K$ has two fundamental rational invariants: its norm and its trace. These generalize familiar operations from quadratic fields. The norm behaves like a product of conjugates. The trace behaves like a sum of conjugates. If the embeddings of $K$ into $\mathbb{C}$ are $$ \sigma_1,\sigma_2,\ldots,\sigma_n, $$ then the norm and trace are defined by...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

RSA Cryptosystem

Public-Key Cryptography Classical cryptography uses a shared secret key. Both sender and receiver must know the same secret information in advance. Public-key cryptography introduced a radically different idea: encryption uses a public key, decryption uses a private key. Anyone may encrypt messages using the public key, but only the holder of the private key can decrypt them. The RSA cryptosystem, introduced by entity["people","Ron Rivest","American cryptographer"], entity["people","Adi Shamir","Israeli cryptographer"], and entity["people","Leonard...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Modular Curves

Geometry of Modular Symmetry The modular group acts on the upper half-plane by fractional linear transformations: $$ z\mapsto \frac{az+b}{cz+d}. $$ This action identifies points related by modular symmetry. Taking the quotient produces geometric spaces called modular curves. Although constructed analytically, modular curves are fundamentally arithmetic objects. They simultaneously encode: complex analysis; algebraic geometry; elliptic curves; modular forms; Galois actions. Modern arithmetic geometry treats modular curves as one of the most...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Nonvanishing Results

Importance of Nonvanishing A central theme in analytic number theory is determining when an $L$-function is nonzero at a particular point. Nonvanishing results are important because zeros of $L$-functions encode arithmetic information. If an $L$-function vanishes unexpectedly, strong cancellation occurs inside the associated arithmetic data. The classical example is Dirichlet’s theorem on primes in arithmetic progressions, whose proof depends critically on the fact that $$ L(1,\chi)\neq0 $$ for every nonprincipal...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Symbolic and Numeric Computation

Computation in Modern Number Theory Modern number theory relies heavily on computation. Two broad computational paradigms dominate the subject: symbolic computation, numeric computation. Symbolic computation manipulates exact mathematical expressions such as integers, polynomials, algebraic numbers, and formal power series. Numeric computation approximates mathematical quantities using floating-point arithmetic and analytic methods. Both approaches are essential. Symbolic methods preserve exactness, while numerical methods allow efficient approximation of quantities too complicated for exact...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Primes in Arithmetic Progressions

Arithmetic Progressions An arithmetic progression is a sequence of the form $$ a,\ a+q,\ a+2q,\ a+3q,\ \ldots, $$ where $a$ and $q$ are fixed integers with $$ q>0. $$ A fundamental question in number theory asks: Are there infinitely many primes in a given arithmetic progression? For example: primes congruent to $1\pmod4$, primes congruent to $3\pmod4$, primes congruent to $1\pmod3$. Some progressions obviously contain only finitely many primes. For instance,...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Hecke Operators

Symmetries of Modular Forms Modular forms already possess symmetry under the modular group. Yet a deeper arithmetic structure emerges through another family of operators: the Hecke operators. These operators act linearly on spaces of modular forms and reveal hidden multiplicative structure in Fourier coefficients. The theory of Hecke operators transformed modular forms from analytic curiosities into arithmetic objects connected with: prime numbers; $L$-functions; elliptic curves; Galois representations; automorphic forms. Modern...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Ring of Integers

Integers Inside a Number Field In ordinary arithmetic, the integers $$ \mathbb{Z} $$ form the fundamental arithmetic structure inside the rational numbers $\mathbb{Q}$. For a number field $K$, the analogous object is its ring of integers, denoted $$ \mathcal O_K. $$ The ring of integers consists of all algebraic integers contained in $K$: $$ \mathcal O_K = {\alpha\in K:\alpha \text{ is an algebraic integer}}. $$ This ring generalizes ordinary integers...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Dirichlet $L$-Functions

Generalizing the Zeta Function The Riemann zeta function $$ \zeta(s) = \sum_{n=1}^{\infty}\frac1{n^s} $$ studies primes globally, without distinguishing residue classes modulo $q$. To study primes in arithmetic progressions, entity["people","Peter Gustav Lejeune Dirichlet","German mathematician"] introduced a family of functions built from Dirichlet characters. These are the Dirichlet $L$-functions. They are among the most important objects in analytic number theory and provide the analytic foundation for Dirichlet’s theorem on primes in arithmetic...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Algorithms for Elliptic Curves

Elliptic Curves as Computational Objects Elliptic curves occupy a central position in modern number theory, arithmetic geometry, and cryptography. An elliptic curve over a field $K$ is typically given by a Weierstrass equation $$ y^2=x^3+ax+b, $$ where $$ 4a^3+27b^2\neq0. $$ The nonvanishing condition ensures smoothness. Elliptic curves are simultaneously: algebraic curves, abelian groups, arithmetic objects, cryptographic platforms. Because of this rich structure, many efficient computational algorithms have been developed for...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Cusp Forms

Vanishing at the Cusps Modular forms satisfy strong symmetry conditions under the modular group. Among them, cusp forms form the deepest and most arithmetic subclass. A cusp form is a modular form that vanishes at every cusp of the modular curve. While Eisenstein series reflect the “continuous” part of modular form theory, cusp forms behave more discretely and mysteriously. Their Fourier coefficients encode subtle arithmetic information and are closely connected...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Algorithms for Modular Forms

Modular Forms as Computable Objects Modular forms are highly structured analytic functions with deep arithmetic properties. Although their definitions involve complex analysis and group actions, modular forms are also computable objects. Modern computational number theory studies algorithms for: computing Fourier expansions, evaluating Hecke operators, determining eigenforms, constructing modular curves, computing associated $L$-functions, constructing Galois representations. These algorithms are essential in arithmetic geometry, cryptography, and modern algebraic number theory. Fourier Expansions...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Eisenstein Series

The Simplest Modular Forms Among all modular forms, Eisenstein series are the most explicit and computationally accessible. They arise naturally by summing simple rational functions over lattice points in the plane. Despite their elementary definition, they encode deep arithmetic information. Their Fourier coefficients involve divisor sums, their products generate large parts of the algebra of modular forms, and their analytic properties connect modular form theory with zeta functions and $L$-functions....

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Orthogonality Relations

Characters as Harmonic Functions Dirichlet characters behave analogously to exponential functions in Fourier analysis. Just as complex exponentials separate frequencies, characters separate residue classes modulo $q$. The key mechanism behind this separation is orthogonality. Orthogonality relations allow sums over characters to isolate specific congruence conditions. They are among the most important computational tools in analytic number theory. Characters Modulo $q$ Fix a positive integer $q$. Let $$ \chi \pmod q...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Number Fields

Fields Generated by Algebraic Numbers A number field is a finite extension of the rational numbers. Concretely, it is a field $K$ satisfying $$ \mathbb{Q}\subseteq K\subseteq \mathbb{C} $$ and such that $K$ has finite dimension as a vector space over $\mathbb{Q}$. The simplest examples are obtained by adjoining an algebraic number $\alpha$ to $\mathbb{Q}$. The resulting field is denoted $$ \mathbb{Q}(\alpha). $$ It is the smallest field containing both $\mathbb{Q}$...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Modular Forms

Analytic Functions with Arithmetic Symmetry Modular forms are among the central objects of modern number theory. At first sight, they are simply holomorphic functions on the upper half-plane satisfying special transformation rules under the modular group. Yet these functions encode profound arithmetic information. Their Fourier coefficients appear in: partition formulas; counting problems; elliptic curves; $L$-functions; Galois representations. The proof of entity["people","Andrew Wiles","British mathematician"] of entity["historical_event","Fermat's Last Theorem","1994 proof by Andrew...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Lattice Reduction

Lattices A lattice is a discrete additive subgroup of Euclidean space. More concretely, let $$ b_1,\ldots,b_n\in\mathbb{R}^m $$ be linearly independent vectors. The lattice generated by these vectors is $$ L=\mathbb{Z}b_1+\cdots+\mathbb{Z}b_n. $$ Thus a lattice consists of all integer linear combinations $$ a_1b_1+\cdots+a_nb_n, \qquad a_i\in\mathbb{Z}. $$ The vectors $$ b_1,\ldots,b_n $$ form a basis of the lattice. A lattice may have many different bases. Some bases are nearly orthogonal and contain...

Writes › Book › Modern Number Theory › Appendix ›

Chronology of Number Theory

Ancient Mathematics Period Development c. 1800 BCE Babylonian arithmetic tables and quadratic problems c. 1650 BCE Egyptian arithmetic in the Rhind Papyrus c. 500 BCE Early Greek studies of ratios and integers c. 300 BCE entity["people","Euclid","ancient Greek mathematician"] writes Elements, including Euclidean algorithm and infinitude of primes c. 250 BCE Study of perfect numbers and geometric arithmetic Classical and Late Ancient Era Period Development c. 250 CE entity["people","Diophantus","ancient Greek mathematician"]...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Dirichlet Characters

Motivation The Riemann zeta function studies prime numbers globally, without distinguishing congruence classes. However, many arithmetic questions concern primes satisfying conditions such as $$ p\equiv a\pmod q. $$ For example: Are there infinitely many primes congruent to $1\pmod4$? How are primes distributed modulo $q$? Do different residue classes contain approximately the same number of primes? To study such questions analytically, entity["people","Peter Gustav Lejeune Dirichlet","German mathematician"] introduced Dirichlet characters. These functions...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Modular Functions

Functions Invariant Under Modular Symmetry The modular group acts on the upper half-plane by fractional linear transformations: $$ z\mapsto \frac{az+b}{cz+d}. $$ Modular forms transform predictably under this action. A modular function is even more symmetric: it remains invariant. These functions play a central role in complex analysis, algebraic geometry, and number theory. They provide coordinates on modular curves and encode deep arithmetic information. The most important example is the $j$-invariant,...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Minimal Polynomials

Algebraic Dependence Over $\mathbb{Q}$ An algebraic number is a complex number that satisfies some nonzero polynomial equation with rational coefficients. Thus $\alpha\in\mathbb{C}$ is algebraic if there exists a nonzero polynomial $$ f(x)\in\mathbb{Q}[x] $$ such that $$ f(\alpha)=0. $$ Among all such polynomials, one is distinguished: the monic polynomial of least degree. This polynomial is called the minimal polynomial of $\alpha$ over $\mathbb{Q}$. The minimal polynomial records the simplest exact algebraic...

Writes › Book › Modern Number Theory › Appendix ›

Index of Definitions

Foundations Definition Location Natural Number 1.1 Integer 1.2 Absolute Value 1.5 Mathematical Induction 1.6 Strong Induction 1.7 Recursive Definition 1.8 Divisibility Definition Location Divisibility 2.1 Prime Number 2.2 Composite Number 2.3 Greatest Common Divisor 2.5 Least Common Multiple 2.6 Coprime Integers 2.10 Prime Factorization Definition Location Prime Factorization 3.1 Canonical Prime Decomposition 3.2 Prime Counting Function 12.1 Prime Gap 12.7 Congruences Definition Location Congruence Modulo $n$ 4.1 Residue Class 4.2...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Connections with Prime Distribution

Prime Numbers and Analytic Structure The Riemann zeta function was introduced through the series $$ \zeta(s) = \sum_{n=1}^{\infty}\frac1{n^s}, $$ but its true importance comes from its connection with prime numbers. Through Euler’s product formula, $$ \zeta(s) = \prod_p \left(1-\frac1{p^s}\right)^{-1}, $$ the arithmetic structure of the primes becomes encoded inside an analytic function. Analytic properties of $\zeta(s)$ therefore translate into information about prime distribution. This principle forms the foundation of analytic...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Integer Factorization

The Factorization Problem Integer factorization asks for the prime decomposition of a positive integer. Given $$ n>1, $$ we seek primes $$ p_1,\ldots,p_r $$ and positive exponents $$ e_1,\ldots,e_r $$ such that $$ n=p_1^{e_1}\cdots p_r^{e_r}. $$ The fundamental theorem of arithmetic guarantees that this decomposition exists and is unique up to the order of the factors. Computationally, however, finding the factors may be difficult. This distinction between existence and efficient...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Euler Products

From Sums to Products Euler products are one of the central ideas of analytic number theory. They express infinite sums over integers as infinite products over primes. The basic principle comes from unique prime factorization. Since every positive integer decomposes uniquely into primes, multiplicative information about integers can often be reorganized prime by prime. The simplest and most important example is the Euler product for the Riemann zeta function: $$...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Dirichlet Series

Infinite Series Attached to Arithmetic Functions An arithmetic function $f(n)$ can be encoded into an infinite series of the form $$ \sum_{n=1}^{\infty}\frac{f(n)}{n^s}, $$ where $s$ is usually a real or complex variable. Such a series is called a Dirichlet series. Dirichlet series are fundamental because they transform arithmetic information into analytic information. Multiplicative structure becomes product structure, and divisor sums become ordinary multiplication of series. General Form A Dirichlet series...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Modular Groups

Fractional Linear Transformations Modular forms begin with the action of certain matrix groups on the complex upper half-plane. Let $$ \mathbb{H} = {z\in\mathbb{C}:\operatorname{Im}(z)>0}. $$ The upper half-plane is a natural domain for complex analysis and hyperbolic geometry. A matrix $$ \gamma= \begin{pmatrix} a & b\ c & d \end{pmatrix} $$ with real entries and determinant $ad-bc\neq0$ acts on $z\in\mathbb{H}$ by $$ \gamma z = \frac{az+b}{cz+d}. $$ This is called a...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Algebraic Integers

Beyond the Ordinary Integers The ordinary integers $$ \mathbb{Z}={\dots,-2,-1,0,1,2,\dots} $$ form the basic arithmetic system of number theory. However, many Diophantine equations naturally lead to larger number systems. For example, the equation $$ x^2+1=0 $$ has no solution in $\mathbb{Z}$ or $\mathbb{R}$, but it has solutions in the complex numbers: $$ x=\pm i. $$ Similarly, Pell equations lead naturally to expressions involving $$ \sqrt D. $$ To study arithmetic systematically...

Writes › Book › Modern Number Theory › Appendix ›

Index of Theorems

Elementary Number Theory Theorem Location Division Algorithm 2.4 Euclidean Algorithm 2.7 Extended Euclidean Algorithm 2.8 Bézout Identity 2.9 Euclid’s Lemma 3.1 Fundamental Theorem of Arithmetic 3.1 Infinitude of Primes 3.4 Chinese Remainder Theorem 4.7 Euler’s Theorem 5.3 Möbius Inversion Formula 5.7 Diophantine Equations Theorem Location Solvability of Linear Diophantine Equations 6.1 Classification of Primitive Pythagorean Triples 6.2 Pell Equation Structure Theorem 6.3 Fermat Two-Squares Theorem 6.4 Rational Point Criterion for...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Primality Testing

The Problem of Recognizing Primes A prime number is an integer greater than $1$ whose only positive divisors are $$ 1 \quad\text{and}\quad p. $$ Prime numbers are the fundamental building blocks of arithmetic because every integer factors uniquely into primes. One of the oldest computational problems in number theory is therefore: Given an integer $n$, determine whether $n$ is prime. This is the primality testing problem. For small integers, direct...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Global Class Field Theory

The Classification Problem One of the central goals of algebraic number theory is to classify field extensions of a number field $$ K. $$ Galois theory reduces this problem to understanding Galois groups. Among all extensions, the abelian extensions are the first major class that admits a complete description. Global class field theory provides this description. It explains all finite abelian extensions of a number field in terms of arithmetic...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Explicit Formulae

From Zeros to Prime Numbers One of the deepest ideas in analytic number theory is that the zeros of the zeta function determine the distribution of prime numbers. This relationship is expressed through explicit formulae, which connect arithmetic counting functions with sums over zeta zeros. These formulas make precise the principle that fluctuations in prime distribution arise from oscillations produced by complex zeros. Chebyshev Functions The most natural setting for...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Diophantine Approximation

Approximating Real Numbers by Rational Numbers Diophantine approximation studies how closely real numbers can be approximated by rational numbers. Given a real number $\alpha$, one seeks rational fractions $$ \frac pq $$ such that $$ \left| \alpha-\frac pq \right| $$ is very small. The subject lies between number theory, analysis, and geometry. It investigates how arithmetic structure constrains approximation quality. Rational Numbers and Density The rational numbers are dense in...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Average Orders of Arithmetic Functions

Irregular Arithmetic Functions Arithmetic functions often fluctuate strongly from one integer to the next. For example, $$ \tau(p)=2 $$ for every prime $p$, while $$ \tau(360)=24. $$ Similarly, $$ \varphi(p)=p-1 $$ for primes, but $$ \varphi(2^k)=2^{k-1}. $$ Because of this irregular behavior, exact formulas for individual integers are often difficult to analyze globally. Instead of studying precise values, number theory frequently studies average behavior. Average Order Let $f(n)$ be an...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Möbius Inversion

Recovering a Function from Divisor Sums Many arithmetic functions are defined through sums over divisors. For example, $$ \sigma(n)=\sum_{d\mid n} d $$ and $$ \tau(n)=\sum_{d\mid n}1. $$ A natural question arises: if a function $F(n)$ is defined by summing another function $f(n)$ over the divisors of $n$, can one recover $f$ from $F$? Möbius inversion gives the answer. Statement of Möbius Inversion Suppose $f$ and $F$ are arithmetic functions satisfying...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Pell Equations via Continued Fractions

Pell Equations Revisited Recall that a Pell equation has the form $$ x^2-Dy^2=1, $$ where $D$ is a positive nonsquare integer. $$ x^2-Dy^2=1 $$ Earlier we saw that such equations possess infinitely many integer solutions. Continued fractions provide the systematic method for finding them. The key fact is that the continued fraction expansion of $$ \sqrt D $$ is periodic. This periodicity produces rational approximations $$ \frac pq $$ for...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Riemann Hypothesis

Statement of the Conjecture The Riemann zeta function has nontrivial zeros inside the critical strip $$ 0<\operatorname{Re}(s)<1. $$ The Riemann Hypothesis asserts that every nontrivial zero lies on the critical line $$ \operatorname{Re}(s)=\frac12. $$ Thus if $$ \zeta(\rho)=0 $$ and $\rho$ is nontrivial, then $$ \rho=\frac12+it $$ for some real number $t$. This conjecture was proposed by entity["people","Bernhard Riemann","German mathematician"] in his 1859 memoir on prime numbers. It is widely...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Fast Integer Arithmetic

Arithmetic Complexity Modern computational number theory depends fundamentally on efficient arithmetic with large integers. Elementary school algorithms for addition and multiplication are sufficient for small numbers, but modern applications involve integers with hundreds, thousands, or millions of digits. Examples include: cryptography, primality testing, integer factorization, computational algebra, symbolic computation. The efficiency of arithmetic algorithms therefore becomes a central concern. The cost of arithmetic operations is measured asymptotically in terms of...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Local Class Field Theory

From Global Arithmetic to Local Arithmetic Global class field theory studies finite abelian extensions of number fields such as $$ \mathbb{Q} \quad\text{or}\quad \mathbb{Q}(\sqrt d). $$ Its central result is that abelian Galois groups are controlled by arithmetic objects built from ideals and ideles. Local class field theory develops the corresponding theory for local fields: $$ \mathbb{Q}_p, \qquad \mathbb{R}, \qquad \mathbb{C}, $$ and finite extensions of $\mathbb{Q}_p$. The local theory is...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Dirichlet Convolution

Combining Arithmetic Functions Arithmetic functions can be added and multiplied pointwise, but number theory has another product that is better adapted to divisibility. Let $f$ and $g$ be arithmetic functions. Their Dirichlet convolution is the arithmetic function $f*g$ defined by $$ (f*g)(n)=\sum_{d\mid n} f(d)g\left(\frac nd\right). $$ The sum runs over all positive divisors $d$ of $n$. This operation combines the values of $f$ and $g$ over the divisor structure of...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Convergents

Successive Rational Approximations The convergents of a continued fraction are the rational numbers obtained by truncating the expansion at finite stages. If $$ \alpha=[a_0;a_1,a_2,a_3,\dots], $$ then the $n$-th convergent is $$ \frac{p_n}{q_n} = [a_0;a_1,\dots,a_n]. $$ Convergents are among the best possible rational approximations to $\alpha$. They encode the arithmetic structure of the continued fraction expansion. First Examples Consider $$ \sqrt2=[1;\overline2]. $$ Its convergents are $$ 1, \frac32, \frac75, \frac{17}{12}, \frac{41}{29},...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Zeros of the Zeta Function

The Equation $\zeta(s)=0$ The zeros of the Riemann zeta function are the complex numbers $s$ satisfying $$ \zeta(s)=0. $$ These zeros are among the most important objects in mathematics because they govern the fine structure of prime distribution. The study of zeta zeros lies at the center of analytic number theory, connecting complex analysis, harmonic analysis, probability, spectral theory, and arithmetic. Trivial Zeros The functional equation $$ \zeta(s) = 2^s\pi^{s-1}...

Writes › Book › Modern Number Theory › Appendix ›

Notation Index

Number Systems Symbol Meaning $\mathbb{N}$ natural numbers $\mathbb{Z}$ integers $\mathbb{Q}$ rational numbers $\mathbb{R}$ real numbers $\mathbb{C}$ complex numbers $\mathbb{F}_p$ finite field with $p$ elements $\mathbb{Q}_p$ field of $p$-adic numbers $\mathbb{Z}_p$ ring of $p$-adic integers Sets and Logic Symbol Meaning $x\in A$ $x$ belongs to $A$ $x\notin A$ $x$ does not belong to $A$ $A\subseteq B$ $A$ is a subset of $B$ $A\cup B$ union $A\cap B$ intersection $A\setminus B$ set...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Trace Formula

Spectral Decomposition and Arithmetic One of the central ideas of modern analysis is that functions may be decomposed spectrally into elementary pieces. Fourier analysis decomposes periodic functions into exponential waves: $$ e^{2\pi i nx}. $$ Representation theory generalizes this philosophy to noncommutative groups. For arithmetic groups and adelic groups, the corresponding decomposition is governed by automorphic representations. The trace formula is a tool that compares: spectral information from representations, geometric...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Hilbert Class Fields

Failure of Unique Factorization One of the central discoveries of algebraic number theory is that unique factorization may fail in rings of algebraic integers. For example, in the ring $$ \mathbb{Z}[\sqrt{-5}], $$ the number $6$ factors in two essentially different ways: $$ 6=2\cdot3 $$ and $$ 6=(1+\sqrt{-5})(1-\sqrt{-5}). $$ None of these factors are associates, and all are irreducible. Thus unique factorization breaks down. Dedekind resolved this difficulty by replacing factorization...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Functional Equation

Symmetry of the Zeta Function The defining series of the zeta function, $$ \zeta(s) = \sum_{n=1}^{\infty}\frac1{n^s}, $$ converges only in the half-plane $$ \operatorname{Re}(s)>1. $$ Analytic continuation extends the function to the entire complex plane except for a pole at $s=1$. However, the continuation alone does not reveal the deep internal symmetry of the zeta function. This symmetry is expressed by the functional equation, discovered by entity["people","Bernhard Riemann","German mathematician"]. The...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Rational Approximations

Approximating Irrational Numbers Many important numbers are irrational: $$ \sqrt2,\qquad \pi,\qquad e. $$ Since irrational numbers cannot be written exactly as fractions, one seeks rational approximations $$ \frac pq $$ that are close to the target number. The central question is: How well can irrational numbers be approximated by rational numbers? Continued fractions provide the most systematic answer to this problem. Measuring Approximation Error Suppose $\alpha$ is a real number...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Completely Multiplicative Functions

Multiplicative and Completely Multiplicative Functions An arithmetic function is a function defined on the positive integers. Such a function $$ f:\mathbb{N}\to\mathbb{C} $$ is called multiplicative if $$ f(ab)=f(a)f(b) $$ whenever $$ \gcd(a,b)=1. $$ It is called completely multiplicative if the same identity holds for all positive integers $a$ and $b$, without assuming coprimality: $$ f(ab)=f(a)f(b). $$ Thus complete multiplicativity is stronger than multiplicativity. Basic Examples The constant function $$ f(n)=1...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Liouville Function

Prime Factors with Multiplicity The Liouville function is an arithmetic function denoted by $$ \lambda(n). $$ It is defined using the total number of prime factors of $n$, counted with multiplicity. If $$ n=p_1^{\alpha_1}p_2^{\alpha_2}\cdots p_r^{\alpha_r} $$ is the canonical prime factorization of $n$, define $$ \Omega(n)=\alpha_1+\alpha_2+\cdots+\alpha_r. $$ Then the Liouville function is $$ \lambda(n)=(-1)^{\Omega(n)}. $$ Thus $\lambda(n)$ is $1$ when $n$ has an even number of prime factors counted with...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Analytic Continuation

Beyond the Region of Convergence The defining series of the Riemann zeta function is $$ \zeta(s) = \sum_{n=1}^{\infty}\frac1{n^s}, $$ which converges absolutely only when $$ \operatorname{Re}(s)>1. $$ At first sight, this seems to restrict the zeta function to the right half-plane. However, many important arithmetic phenomena occur outside this region. The central idea of analytic continuation is that a function initially defined on one domain may extend uniquely to a...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Reciprocity Maps

Reciprocity in Arithmetic One of the oldest themes in number theory is reciprocity: the phenomenon that solvability conditions for one prime are controlled by arithmetic involving another prime. The classical example is quadratic reciprocity, discovered by entity["people","Carl Friedrich Gauss","German mathematician"]. It describes when a prime number $p$ is a quadratic residue modulo another prime $q$. For odd primes $p$ and $q$, $$ \left(\frac{p}{q}\right) \left(\frac{q}{p}\right) = (-1)^{\frac{(p-1)(q-1)}4}. $$ At first sight,...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Infinite Continued Fractions

Irrational Numbers and Infinite Expansions Finite continued fractions correspond exactly to rational numbers. When the Euclidean algorithm never terminates, the continued fraction becomes infinite. An infinite continued fraction has the form $$ [a_0;a_1,a_2,a_3,\ldots], $$ where $$ a_0\in\mathbb{Z}, \qquad a_i\in\mathbb{Z}_{>0} \text{ for } i\ge1. $$ Such expressions represent irrational numbers. For example, $$ \sqrt2=[1;2,2,2,\ldots]. $$ $$ \sqrt{2}=[1;2,2,2,\ldots] $$ Infinite continued fractions provide one of the most natural arithmetic descriptions of irrational...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Functoriality

The Central Principle of the Langlands Program Functoriality is the unifying mechanism of the Langlands program. It predicts systematic relationships between automorphic representations attached to different algebraic groups. The principle may be summarized informally as follows: homomorphisms between symmetry groups should produce transfers between automorphic representations. This idea organizes vast families of correspondences and explains many identities between $L$-functions. Functoriality is considered one of the deepest conjectural structures in modern...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Euler Totient Function

Counting Coprime Residues Euler's totient function is an arithmetic function denoted by $$ \varphi(n). $$ For a positive integer $n$, it counts the integers $a$ satisfying $$ 1\le a\le n $$ and $$ \gcd(a,n)=1. $$ Thus $$ \varphi(n)=#{a:1\le a\le n,\ \gcd(a,n)=1}. $$ For example, the integers from $1$ to $10$ that are coprime to $10$ are $$ 1,3,7,9. $$ Therefore $$ \varphi(10)=4. $$ The totient function measures how many residue...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Euler Product Formula

Arithmetic Structure of the Zeta Function The defining series of the Riemann zeta function is $$ \zeta(s) = \sum_{n=1}^{\infty}\frac1{n^s}, \qquad \operatorname{Re}(s)>1. $$ At first sight, this appears to be merely an analytic object: an infinite series over the positive integers. Its true arithmetic significance emerges through the Euler product formula, which expresses the same function as a product over primes. This identity is one of the foundational results of analytic...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Abelian Extensions

Field Extensions and Commutative Symmetry A central goal of algebraic number theory is to understand field extensions of a given base field, especially extensions of the rational numbers $$ \mathbb{Q}. $$ Galois theory associates to every finite Galois extension $$ L/K $$ a group of symmetries: $$ \mathrm{Gal}(L/K). $$ The structure of this group reflects the arithmetic complexity of the extension. Among all extensions, the simplest and most important are...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Finite Continued Fractions

From Division to Expansion A finite continued fraction is an expression of the form $$ a_0+\frac{1}{a_1+\frac{1}{a_2+\cdots+\frac{1}{a_n}}}, $$ where $$ a_0\in\mathbb{Z} $$ and $$ a_1,a_2,\ldots,a_n\in\mathbb{Z}_{>0}. $$ It is usually written compactly as $$ [a_0;a_1,a_2,\ldots,a_n]. $$ Finite continued fractions are another way to write rational numbers. They arise directly from the Euclidean algorithm. First Examples Consider $$ [2;3]. $$ This means $$ 2+\frac13=\frac73. $$ Now consider $$ [1;2,2]. $$ Then $$ [1;2,2]...

Writes › Book › Modern Number Theory › Appendix ›

Glossary

A Abelian Group A group $G$ is abelian if $$ ab=ba $$ for all $a,b\in G$. Examples include $(\mathbb{Z},+)$ and $(\mathbb{Q}^{\times},\cdot)$. Absolute Value For a real number $x$, $$ |x|= \begin{cases} x & x\ge0, \ -x & x<0. \end{cases} $$ For a complex number $z=a+bi$, $$ |z|=\sqrt{a^2+b^2}. $$ Adeles The adele ring combines all completions of a global field into a single topological ring. Adeles unify archimedean and nonarchimedean arithmetic....

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Definition of the Zeta Function

Infinite Series and Prime Numbers One of the central objects of analytic number theory is the Riemann zeta function. It connects infinite series, prime numbers, complex analysis, and arithmetic structure into a single analytic framework. The zeta function begins with the series $$ \sum_{n=1}^{\infty}\frac1{n^s}, $$ where $s$ is a complex variable. This function first appeared in the work of entity["people","Leonhard Euler","Swiss mathematician"] during the study of infinite series. Later, entity["people","Bernhard...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Euclidean Algorithm Revisited

Division and Remainders The Euclidean algorithm is one of the oldest and most important algorithms in mathematics. It computes the greatest common divisor of two integers using repeated division. Given integers $a$ and $b$ with $$ a>b>0, $$ the division algorithm states that there exist unique integers $q$ and $r$ such that $$ a=bq+r, \qquad 0\le r<b. $$ $$ a=bq+r $$ The Euclidean algorithm repeatedly applies this decomposition. For example,...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Adeles and Ideles

Simultaneous Arithmetic at All Places The rational numbers may be studied through their completions: $$ \mathbb{R}, \qquad \mathbb{Q}_2, \qquad \mathbb{Q}_3, \qquad \mathbb{Q}_5, \ldots $$ Each completion captures arithmetic near one place: $\mathbb{R}$ describes archimedean behavior; $\mathbb{Q}_p$ describes behavior near the prime $p$. Modern number theory seeks a framework in which all completions are considered simultaneously. Adeles and ideles provide this framework. They unify local and global arithmetic into a single...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Möbius Function

Definition The Möbius function is an arithmetic function denoted by $$ \mu(n). $$ It is defined from the prime factorization of $n$. For $n=1$, $$ \mu(1)=1. $$ For $n>1$, write $$ n=p_1^{\alpha_1}p_2^{\alpha_2}\cdots p_r^{\alpha_r}. $$ Then $$ \mu(n)= \begin{cases} 0, & \text{if some } \alpha_i\ge2,\ (-1)^r, & \text{if every } \alpha_i=1. \end{cases} $$ Thus $\mu(n)$ detects whether $n$ is squarefree, and if it is squarefree, records the parity of the number...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Langlands Program

A Vast Web of Correspondences The Langlands program is a broad collection of conjectures connecting number theory, representation theory, harmonic analysis, and algebraic geometry. Its central idea is that two very different kinds of objects should secretly encode the same arithmetic information. On one side are Galois representations, which come from field extensions, algebraic varieties, and étale cohomology. On the other side are automorphic representations, which come from harmonic analysis...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Twin Prime Heuristics

Twin Primes A pair of primes $$ (p,p+2) $$ is called a twin prime pair. Examples include $$ (3,5),\quad (5,7),\quad (11,13),\quad (17,19). $$ The Twin Prime Conjecture states that infinitely many such pairs exist. Despite enormous numerical evidence and major advances in sieve theory, the conjecture remains unproved. The goal of twin prime heuristics is to estimate how frequently such pairs should occur. Naive Probability Model The Prime Number Theorem...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Computational Aspects

Quadratic Residues as Computational Objects Quadratic residue theory is not only a theoretical subject. It also plays a major role in computational number theory, cryptography, primality testing, and algorithm design. Many arithmetic algorithms reduce to questions of the form: $$ x^2\equiv a\pmod n. $$ $$ x^2\equiv a\pmod n $$ Typical computational tasks include: deciding whether $a$ is a quadratic residue modulo $n$, finding square roots modulo primes, computing Legendre or...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Local-Global Principles

From Local Information to Global Solutions A central problem in number theory is determining whether an equation possesses rational or integral solutions. For example: $$ x^2+y^2=z^2, $$ $$ x^3+y^3=z^3, $$ or more generally, $$ f(x_1,\ldots,x_n)=0. $$ Such equations are called Diophantine equations. Directly finding rational solutions is often extremely difficult. A powerful strategy is to study the equation locally, meaning over completions of the rational numbers: $$ \mathbb{R}, \qquad \mathbb{Q}_2,...

Writes › Book › Modern Number Theory › Appendix ›

Appendix J. Historical Notes and Bibliography

J.1 Why History Matters Number theory is one of the oldest parts of mathematics, but modern number theory is not a single ancient subject carried forward unchanged. It is a layered discipline. Elementary divisibility, Diophantine equations, algebraic number theory, analytic number theory, modular forms, arithmetic geometry, and computational number theory arose at different times from different problems. Historical study helps explain why the subject has its present shape. The concepts...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Divisor Functions

Counting and Summing Divisors Divisor functions measure the positive divisors of an integer. They are among the first examples of arithmetic functions, because their values depend directly on the prime factorization of the input. For a positive integer $n$, the most basic divisor functions are $$ \tau(n)=#{d\in\mathbb{N}:d\mid n} $$ and $$ \sigma(n)=\sum_{d\mid n} d. $$ The function $\tau(n)$ counts the positive divisors of $n$. The function $\sigma(n)$ sums them. For...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Applications to Computation

Modular Arithmetic as Computation Modular arithmetic is not only a theoretical language for divisibility. It is also one of the main tools of computation with integers. A congruence $$ a\equiv b\pmod n $$ allows a large integer $a$ to be replaced by a smaller representative $b$ without losing information modulo $n$. This is useful because many computations depend only on remainders. For example, instead of carrying the large number $$...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Prime Gaps

Consecutive Prime Differences Let $$ p_n $$ denote the $n$-th prime number. The difference $$ g_n=p_{n+1}-p_n $$ is called the $n$-th prime gap. For example, $$ 2,3,5,7,11,13 $$ produce the gaps $$ 1,2,2,4,2. $$ Prime gaps measure how irregularly primes are distributed among the integers. Average Size of Prime Gaps The Prime Number Theorem implies that primes near $x$ have average density approximately $$ \frac1{\log x}. $$ Thus the average...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Adelic Methods

Local and Global Arithmetic Number theory studies arithmetic simultaneously at two levels: global arithmetic over number fields such as $\mathbb{Q}$, local arithmetic over completions such as $\mathbb{R}$ and $\mathbb{Q}_p$. Historically, these settings were studied separately. Adelic methods unify them into a single framework. The central idea is that arithmetic objects should be analyzed through all completions of a field at once. This philosophy lies at the heart of modern automorphic...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Higher Reciprocity Laws

Beyond Quadratic Reciprocity Quadratic reciprocity describes when one prime is a square modulo another prime. A natural question is whether similar laws exist for higher powers. For example, one may ask: when is $a$ a cube modulo $p$? when is $a$ a fourth power modulo $p$? when does $$ x^n\equiv a\pmod p $$ have a solution? These questions lead to higher reciprocity laws, which generalize quadratic reciprocity to higher powers....

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Hensel’s Lemma

Lifting Solutions from Modular Arithmetic One of the central ideas of number theory is that congruences modulo powers of a prime often approximate genuine arithmetic solutions. Suppose a polynomial equation has a solution modulo $p$. Can this solution be refined to a solution modulo $p^2$, then modulo $p^3$, and eventually to a solution in the field of $p$-adic numbers? Hensel’s lemma answers this question. It is one of the foundational...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Fast Modular Exponentiation

The Problem Modular arithmetic often requires computing powers such as $$ a^k \pmod n. $$ If $k$ is large, direct multiplication is inefficient. For example, computing $$ 7^{1000}\pmod{13} $$ by multiplying $7$ one thousand times is unnecessary. Fast modular exponentiation computes powers by repeatedly squaring and reducing modulo $n$. The method is efficient because it uses the binary expansion of the exponent. Repeated Squaring The basic idea is that powers...

Writes › Book › Modern Number Theory › Appendix ›

Appendix I. Computational Tools

I.1 Computation in Modern Number Theory Computation has become an essential part of number theory. Classical arithmetic relied mainly on symbolic reasoning and hand calculations. Modern arithmetic combines rigorous proof with large-scale computation, algorithmic experimentation, symbolic algebra, and numerical analysis. Computational methods are now central in: primality testing, integer factorization, cryptography, modular forms, elliptic curves, lattice reduction, arithmetic geometry, experimental mathematics. Large computations frequently guide conjectures before proofs are discovered....

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Short Intervals

Prime Distribution on Small Scales The Prime Number Theorem describes the average distribution of primes up to a large number $x$: $$ \pi(x)\sim \frac{x}{\log x}. $$ From this, one expects that an interval of length $h$ near $x$ should contain roughly $$ \frac{h}{\log x} $$ primes. Thus the quantity $$ \pi(x+h)-\pi(x) $$ should approximately equal $$ \frac{h}{\log x}. $$ The study of such questions is called the theory of primes...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Automorphic Representations

From Automorphic Forms to Representations Classically, number theory studied special analytic functions such as modular forms. These functions satisfy strong symmetry conditions under actions of arithmetic groups. Modern theory reformulates these objects representation-theoretically. Instead of studying individual functions directly, one studies the spaces generated by their symmetries. The resulting objects are called automorphic representations. This shift from functions to representations is one of the major conceptual advances of twentieth-century mathematics....

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Completion of Fields

Incompleteness of the Rational Numbers The rational numbers form a field rich enough for arithmetic, yet insufficient for many limiting processes. Consider the sequence of decimal approximations to $\sqrt2$: $$ 1,\quad 1.4,\quad 1.41,\quad 1.414,\quad\ldots $$ The terms become arbitrarily close to one another, but the sequence does not converge inside $\mathbb{Q}$, because $$ \sqrt2\notin\mathbb{Q}. $$ Thus the rational numbers contain “holes.” The process of filling these holes leads to the...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Chinese Remainder Theorem

Independent Congruence Conditions The Chinese remainder theorem describes when several congruence conditions can be combined into one congruence. Its cleanest form occurs when the moduli are pairwise coprime. Suppose $$ n_1,n_2,\ldots,n_r $$ are positive integers satisfying $$ \gcd(n_i,n_j)=1 $$ whenever $$ i\ne j. $$ Then the congruences $$ x\equiv a_1\pmod{n_1}, $$ $$ x\equiv a_2\pmod{n_2}, $$ $$ \cdots $$ $$ x\equiv a_r\pmod{n_r} $$ have a unique solution modulo $$ N=n_1n_2\cdots n_r....

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Error Terms

Measuring the Accuracy of Prime Approximations The Prime Number Theorem states that $$ \pi(x)\sim \operatorname{li}(x), $$ or equivalently, $$ \pi(x)\sim \frac{x}{\log x}. $$ These asymptotic formulas describe the main growth of the prime counting function. However, they do not explain how large the difference between the approximation and the true value may be. To study the precision of prime estimates, one introduces error terms. Basic Error Functions The two standard...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Representation Theory Background

Symmetry and Linear Actions Representation theory studies abstract algebraic objects by expressing them as linear transformations of vector spaces. The guiding principle is simple: complicated algebraic structures become more understandable when realized concretely as matrices. If $G$ is a group and $V$ is a vector space over a field $k$, a representation of $G$ on $V$ is a homomorphism $$ \rho:G\to\operatorname{GL}(V), $$ where $$ \operatorname{GL}(V) $$ is the group of...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

$p$-Adic Numbers

Beyond the Real Numbers The real numbers arise by completing the rational numbers with respect to the ordinary absolute value. This completion produces a field suited to Euclidean geometry and classical analysis. Number theory reveals another completion process based on divisibility by a prime number $p$. The resulting fields are the $p$-adic numbers. While real analysis measures magnitude geometrically, $p$-adic analysis measures arithmetic proximity. Two numbers are close $p$-adically when...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Gauss Sums

Characters and Exponential Sums Gauss sums arise from combining multiplicative and additive structures modulo a prime. They form one of the fundamental tools of analytic and algebraic number theory. Let $p$ be an odd prime and let $$ \chi(a)=\left(\frac{a}{p}\right) $$ be the quadratic character modulo $p$. Thus $$ \chi(a)= \begin{cases} 1 & \text{if } a \text{ is a quadratic residue modulo } p,\ -1 & \text{if } a \text{ is...

Writes › Book › Modern Number Theory › Appendix ›

Appendix H. Category Theory Basics

H.1 Motivation Category theory studies mathematical structures through objects and maps between them. Instead of looking only at what objects are made of, it studies how they relate to other objects. This viewpoint appears naturally in modern number theory. Groups, rings, fields, modules, schemes, varieties, sheaves, and representations all form categories. Many deep constructions are best understood as maps preserving structure. Category theory provides a common language for algebra, topology,...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Weil Conjectures

Counting Points over Finite Fields One of the central problems in arithmetic geometry is understanding the number of solutions of polynomial equations over finite fields. Let $$ X $$ be an algebraic variety over the finite field $$ \mathbb{F}_q. $$ For each integer $n\geq1$, one may count the points of $X$ defined over the extension field $$ \mathbb{F}_{q^n}. $$ These numbers, $$ #X(\mathbb{F}_{q^n}), $$ contain deep arithmetic information. Examples quickly...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Absolute Values

Measuring Size in Arithmetic The ordinary absolute value on the real numbers measures magnitude: $$ |x|= \begin{cases} x,&x\ge0,\ -x,&x<0. \end{cases} $$ This function allows us to define distance, $$ d(x,y)=|x-y|, $$ and therefore notions such as convergence, continuity, and completeness. In number theory, however, there are many different ways to measure the size of numbers. The ordinary absolute value is only one possibility. The theory of absolute values provides a...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Quadratic Reciprocity

The Central Problem The theory of quadratic residues asks a fundamental question: Given distinct odd primes $p$ and $q$, when does the congruence $$ x^2\equiv q\pmod p $$ have a solution? Equivalently, when is $$ \left(\frac{q}{p}\right)=1? $$ At first glance, the residue behavior of $q$ modulo $p$ and the residue behavior of $p$ modulo $q$ appear unrelated. The law of quadratic reciprocity reveals a remarkable symmetry between them. This theorem...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Systems of Congruences

Several Congruences at Once A system of congruences asks for an integer satisfying several congruence conditions simultaneously. For example, $$ x\equiv2\pmod3 $$ and $$ x\equiv3\pmod5 $$ form a system. A solution is an integer $x$ that satisfies both congruences. Testing small values, we find $$ 8\equiv2\pmod3 $$ and $$ 8\equiv3\pmod5. $$ Thus $$ x=8 $$ is one solution. Since congruence conditions repeat periodically, there are infinitely many integer solutions, but...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Modular Inverses

Division in Modular Arithmetic In ordinary arithmetic, division by a nonzero number means multiplication by its reciprocal. Modular arithmetic is more delicate. A residue class may or may not have a multiplicative inverse. Let $a$ and $n$ be integers with $n\ge2$. A modular inverse of $a$ modulo $n$ is an integer $b$ satisfying $$ ab\equiv1\pmod n. $$ When such a $b$ exists, we write $$ b\equiv a^{-1}\pmod n. $$ This...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Linear Congruences

Definition A linear congruence is a congruence of the form $$ ax\equiv b\pmod n, $$ where $a,b\in\mathbb{Z}$, $n\in\mathbb{N}$, and $x$ is the unknown integer. This congruence means that $$ n\mid(ax-b). $$ Equivalently, there exists an integer $y$ such that $$ ax-b=ny. $$ Rearranging gives the linear Diophantine equation $$ ax-ny=b. $$ Thus solving a linear congruence is closely related to solving a linear equation in two integer variables. First Examples...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Arithmetic Modulo $n$

Modular Arithmetic Arithmetic modulo $n$ is arithmetic performed on residue classes modulo $n$. Instead of distinguishing all integers separately, we identify integers that have the same remainder after division by $n$. Thus, modulo $n$, every integer is represented by one of $$ 0,1,2,\ldots,n-1. $$ For example, modulo $5$, $$ 7\equiv2\pmod5, \qquad 13\equiv3\pmod5. $$ So in arithmetic modulo $5$, the integer $7$ behaves like $2$, and the integer $13$ behaves like...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Residue Classes

From Congruence to Classes Congruence modulo $n$ groups integers according to their remainders after division by $n$. If two integers have the same remainder, they are congruent modulo $n$. For example, $$ 17\equiv2\pmod5 $$ because $$ 17-2=15 $$ and $$ 5\mid15. $$ The integers congruent to $2$ modulo $5$ form the set $$ {\ldots,-8,-3,2,7,12,17,\ldots}. $$ This set is called a residue class modulo $5$. Definition Let $n\in\mathbb{N}$. For an integer...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Congruence Relations

Motivation Ordinary equality compares integers exactly. In many arithmetic problems, however, only the remainder after division matters. For example, the integers $$ 17 \quad\text{and}\quad 5 $$ leave the same remainder when divided by $12$: $$ 17=12\cdot1+5, \qquad 5=12\cdot0+5. $$ From the viewpoint of remainders modulo $12$, these integers behave identically. This observation leads to the notion of congruence. Definition of Congruence Let $a,b\in\mathbb{Z}$, and let $n\in\mathbb{N}$. We say that $a$...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Distribution Heuristics of Primes

The Problem of Distribution The infinitude of primes guarantees that primes continue indefinitely, but it says nothing about how frequently primes occur. At first glance, primes appear irregular: $$ 2,3,5,7,11,13,17,19,23,29,\ldots $$ Some gaps are small: $$ 11,13. $$ Others are larger: $$ 23,29. $$ As integers grow, the pattern becomes increasingly difficult to predict. The study of how primes are distributed among the integers is one of the central themes...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Euler's Proof

From Euclid to Euler Euclid proved that there are infinitely many primes by contradiction. Euler discovered a very different proof based on infinite series and products. His argument connects prime numbers with the harmonic series $$ \sum_{n=1}^{\infty}\frac1n. $$ This series diverges: $$ 1+\frac12+\frac13+\frac14+\cdots=\infty. $$ Euler observed that the harmonic series can be decomposed multiplicatively using prime factorization. This insight became one of the foundational ideas of analytic number theory. The...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Euclid's Proof

The Classical Argument Euclid's proof of the infinitude of primes is one of the earliest examples of a general argument in number theory. It does not depend on computation, experimentation, or knowledge of large primes. It proves that no finite list of primes can ever be complete. Suppose we are given finitely many primes: $$ p_1,p_2,\ldots,p_k. $$ We do not yet assume that these are all primes. We merely ask...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Infinitude of Primes

The Basic Question Prime numbers are the building blocks of the positive integers. Once unique prime factorization is known, a natural question arises: are there only finitely many primes, or do primes continue forever? The answer is that there are infinitely many primes. This result is one of the oldest theorems in number theory. Its proof is short, but the idea is powerful: any finite list of primes can be...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Arithmetic Functions from Factorization

Functions on Positive Integers An arithmetic function is a function whose domain is the positive integers. It assigns a value to each integer $$ n\in\mathbb{N}. $$ Typical examples include the number of positive divisors of $n$, the sum of positive divisors of $n$, and the number of integers less than or equal to $n$ that are coprime to $n$. Prime factorization makes many arithmetic functions computable. Once we know $$...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Canonical Prime Decomposition

Standard Form of an Integer Unique prime factorization says that every integer $n>1$ can be written as a product of primes. The canonical prime decomposition is the ordered and exponentiated version of this factorization. For every integer $n>1$, there exist distinct primes $$ p_1<p_2<\cdots<p_r $$ and positive integers $$ \alpha_1,\alpha_2,\ldots,\alpha_r $$ such that $$ n=p_1^{\alpha_1}p_2^{\alpha_2}\cdots p_r^{\alpha_r}. $$ This expression is canonical because the primes are written in increasing order and...

Writes › Book › Modern Number Theory › Appendix ›

Appendix G. Linear Algebra Review

G.1 Vector Spaces A vector space over a field $F$ is a set $V$ equipped with addition and scalar multiplication satisfying the usual algebraic rules. The scalars belong to $F$, while the vectors belong to $V$. Examples: $$ \mathbb{R}^n,\qquad \mathbb{C}^n,\qquad \mathbb{Q}^n. $$ Polynomial spaces such as $$ F[x] $$ are also vector spaces over $F$. In number theory, vector spaces appear in: modular forms, representation theory, cohomology, field extensions, lattice...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Logarithmic Integral

Definition The logarithmic integral is the function $$ \operatorname{li}(x) = \int_2^x \frac{dt}{\log t}. $$ It plays a central role in prime number theory because it gives a remarkably accurate approximation to the prime counting function $$ \pi(x). $$ The Prime Number Theorem may be written in the form $$ \pi(x)\sim \operatorname{li}(x). $$ Although the simpler approximation $$ \frac{x}{\log x} $$ captures the correct order of growth, the logarithmic integral incorporates...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Étale Cohomology

The Need for a New Cohomology Theory Classical topology studies geometric spaces using invariants such as homology and cohomology. Over the complex numbers, algebraic varieties can often be viewed as topological spaces, and topological methods become available. However, arithmetic geometry studies varieties over fields such as $$ \mathbb{Q},\qquad \mathbb{F}_p,\qquad \mathbb{Q}_p, $$ where ordinary topology is insufficient or meaningless. For example, a variety over a finite field has only finitely many...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Ramification

Primes in Field Extensions One of the central ideas of algebraic number theory is that prime numbers may behave differently after passing to a larger field. In the ordinary integers $\mathbb{Z}$, every nonzero integer factors uniquely into prime numbers. In a number field $K$, the role of prime numbers is played by prime ideals in the ring of integers $\mathcal{O}_K$. When extending fields, $$ \mathbb{Q}\subseteq K, $$ a prime number...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Prime Number Theorem

Statement of the Theorem The Prime Number Theorem describes the asymptotic distribution of prime numbers. It states that $$ \pi(x)\sim \frac{x}{\log x} $$ as $x\to\infty$. Equivalently, $$ \lim_{x\to\infty}\frac{\pi(x)\log x}{x}=1. $$ Thus the density of primes near a large number $x$ is approximately $$ \frac1{\log x}. $$ The theorem gives a precise quantitative form to the observation that primes become less frequent as numbers grow larger. Logarithmic Integral Form A more...

Writes › Book › Modern Number Theory › Appendix ›

Appendix F. Measure and Integration

F.1 Motivation Measure theory extends the ideas of length, area, volume, and integration to more general settings. In number theory, measure appears in probability, harmonic analysis, ergodic theory, automorphic forms, adelic groups, and equidistribution. Classical integration over intervals is not sufficient for modern analytic methods. One needs integration on abstract spaces such as compact groups, local fields, and quotient spaces. Measure theory provides a rigorous framework for averaging arithmetic objects....

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Euler Criterion

Detecting Quadratic Residues Euler criterion gives an efficient way to decide whether an integer is a square modulo an odd prime. Let $p$ be an odd prime and let $a$ be an integer not divisible by $p$. Then $a$ is either a quadratic residue modulo $p$ or a quadratic nonresidue modulo $p$. The criterion states that this distinction is detected by the power $$ a^{(p-1)/2}. $$ More precisely, $$ a^{(p-1)/2}\equiv...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Arithmetic Surfaces

From Curves to Surfaces Arithmetic geometry often studies families of algebraic curves varying over arithmetic bases. The most important base is $$ \operatorname{Spec}(\mathbb{Z}), $$ whose points correspond to prime numbers together with the generic point associated to $\mathbb{Q}$. When a curve is extended from a field to the ring of integers, the resulting object typically becomes two-dimensional. Such objects are called arithmetic surfaces. An arithmetic surface is, roughly, a two-dimensional...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Cyclotomic Fields

Roots of Unity One of the most important classes of number fields arises from the solutions of the equation $$ x^n=1. $$ The solutions are called the $n$-th roots of unity. In the complex numbers, these roots are $$ 1,\zeta_n,\zeta_n^2,\ldots,\zeta_n^{n-1}, $$ where $$ \zeta_n=e^{2\pi i/n}. $$ Geometrically, these numbers lie equally spaced around the unit circle in the complex plane. For example, the fourth roots of unity are $$ 1,\quad...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Chebyshev Bounds

Motivation The prime counting function $$ \pi(x) $$ measures the number of primes not exceeding $x$. Numerical evidence suggests that $$ \pi(x)\approx \frac{x}{\log x}, $$ but proving such a statement is difficult. Before the Prime Number Theorem was established, Pafnuty Chebyshev obtained strong upper and lower bounds showing that the order of growth of $\pi(x)$ is indeed approximately $x/\log x$. These estimates were among the first major successes of analytic...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Jacobi Symbol

Motivation The Legendre symbol $$ \left(\frac{a}{p}\right) $$ is defined only when the denominator is an odd prime. In many problems, however, one must work modulo an odd composite integer. The Jacobi symbol extends the notation of the Legendre symbol to this broader setting. Let $$ n>1 $$ be an odd integer with prime factorization $$ n=p_1^{e_1}p_2^{e_2}\cdots p_r^{e_r}. $$ For any integer $a$, the Jacobi symbol is defined by $$ \left(\frac{a}{n}\right)...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Legendre Symbol

Definition Let $p$ be an odd prime and let $a\in\mathbb{Z}$. The Legendre symbol is defined by $$ \left(\frac{a}{p}\right) = \begin{cases} ;;;0 & \text{if } p\mid a,\ ;;;1 & \text{if } a \text{ is a quadratic residue modulo } p,\ -1 & \text{if } a \text{ is a quadratic nonresidue modulo } p. \end{cases} $$ genui{"math_block_widget_always_prefetch_v2":{"content":"\left(\frac{a}{p}\right)"} } Thus the Legendre symbol encodes whether the congruence $$ x^2\equiv a\pmod p $$ has...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Squares Modulo $n$

Quadratic Congruences A quadratic congruence is a congruence involving a square. The basic form is $$ x^2\equiv a\pmod n, $$ where $a,n\in\mathbb{Z}$ and $n>1$. $$ x^2\equiv a\pmod n $$ The problem is to determine whether there exists an integer $x$ satisfying the congruence. If such an $x$ exists, then $a$ is called a quadratic residue modulo $n$. Otherwise, $a$ is called a quadratic nonresidue modulo $n$. Quadratic congruences form the...

Writes › Book › Modern Number Theory › Appendix ›

Appendix E. Topology Background

E.1 Motivation Topology studies continuity, convergence, connectedness, and geometric structure in an abstract setting. In number theory, topology appears naturally in real analysis, complex analysis, $p$-adic analysis, algebraic geometry, adelic theory, and automorphic forms. The real numbers carry a geometric topology derived from distance. The $p$-adic numbers carry a very different topology derived from divisibility. Modern number theory frequently moves between these worlds. Topology provides the language needed to describe...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Curves over Fields

Algebraic Curves An algebraic curve is a geometric object whose dimension is one. Curves are among the oldest and most important objects in number theory and algebraic geometry. Classically, a curve is defined by a polynomial equation in two variables: $$ f(x,y)=0. $$ Examples include: $$ y=x^2, $$ $$ x^2+y^2=1, $$ and $$ y^2=x^3-x. $$ Over a field $k$, such equations define subsets of affine or projective space whose coordinates...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Finite Fields

Fields with Finitely Many Elements The familiar fields $$ \mathbb{Q},\quad \mathbb{R},\quad \mathbb{C} $$ contain infinitely many elements. In number theory and algebra, however, fields with only finitely many elements play an equally fundamental role. A finite field is a field containing finitely many elements. Such fields arise naturally in modular arithmetic, algebraic geometry, coding theory, and cryptography. The simplest examples come from arithmetic modulo a prime number. Prime Fields Let...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Prime Counting Function

Counting Prime Numbers One of the oldest questions in number theory asks how prime numbers are distributed among the positive integers. Since primes become less frequent as numbers grow larger, mathematicians seek functions that measure their density. The central object is the prime counting function $$ \pi(x), $$ defined by $$ \pi(x)=#{p\leq x : p \text{ is prime}}. $$ Thus $\pi(x)$ counts the number of primes not exceeding $x$. For...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Unique Prime Factorization

Statement of the Theorem The fundamental theorem of arithmetic states that every integer $n>1$ can be written as a product of prime numbers, and that this product is unique up to the order of the factors. Thus every integer $n>1$ has a representation $$ n=p_1p_2\cdots p_k, $$ where each $p_i$ is prime. The same factorization is often written by grouping equal primes: $$ n=p_1^{\alpha_1}p_2^{\alpha_2}\cdots p_r^{\alpha_r}, $$ where $$ p_1<p_2<\cdots<p_r $$...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Geometry of Diophantine Problems

From Equations to Shapes A Diophantine equation is first an arithmetic object. It asks for solutions in integers or rational numbers. But every polynomial equation also defines a geometric object. For example, $$ x^2+y^2=25 $$ defines a circle in the plane. The Diophantine problem asks for the lattice points on this circle, meaning the points $(x,y)$ with integer coordinates. Thus the same equation has two interpretations: Viewpoint Object of Study...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Coprime Integers

Definition Two integers $a$ and $b$, not both zero, are called coprime if their greatest common divisor is $1$: $$ \gcd(a,b)=1. $$ They are also called relatively prime. Coprimality means that $a$ and $b$ have no common positive divisor except $1$. For example, $$ \gcd(8,15)=1, $$ so $8$ and $15$ are coprime. The integers themselves need not be prime. Both $8$ and $15$ are composite, but they share no prime...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Bezout Identities

Linear Combinations Let $a$ and $b$ be integers. An integer of the form $$ ax+by $$ where $$ x,y\in\mathbb{Z} $$ is called an integer linear combination of $a$ and $b$. For example, if $a=18$ and $b=30$, then $$ 2a-b=2\cdot18-30=6 $$ is a linear combination of $18$ and $30$. Linear combinations are important because divisibility behaves well under addition and subtraction. If an integer $d$ divides both $a$ and $b$, then...

Writes › Book › Modern Number Theory › Appendix ›

Appendix D. Real and Complex Analysis Review

D.1 Real Numbers The real numbers $\mathbb{R}$ extend the rational numbers $\mathbb{Q}$ by filling gaps such as $$ \sqrt{2},\quad \pi,\quad e. $$ They form an ordered field. This means addition, multiplication, and order are compatible. For example, if $$ a<b, $$ then $$ a+c<b+c. $$ If $$ 0<c, $$ then $$ ac<bc. $$ The real numbers are also complete: every nonempty set of real numbers that is bounded above has...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Morphisms and Fibers

Maps Between Geometric Objects Geometry is not only concerned with spaces themselves, but also with maps between spaces. In algebraic geometry and arithmetic geometry, these maps are called morphisms. A morphism describes how one variety or scheme is transformed into another while preserving algebraic structure. For affine varieties, morphisms arise from polynomial functions. If $$ X\subseteq \mathbb{A}^n,\qquad Y\subseteq \mathbb{A}^m, $$ a morphism $$ f:X\to Y $$ is given by polynomial...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Galois Groups

Symmetry of Polynomial Roots A polynomial equation may possess several roots related by hidden algebraic symmetries. Consider $$ f(x)=x^2-2. $$ Its roots are $$ \sqrt{2} \qquad \text{and} \qquad -\sqrt{2}. $$ These roots can be exchanged without affecting any rational number. Indeed, the transformation $$ \sqrt{2}\mapsto -\sqrt{2} $$ preserves all algebraic relations involving rational coefficients. For example, $$ (\sqrt{2})^2=2 $$ remains true after the substitution. Such transformations are called automorphisms of...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Abel Summation

Motivation In analytic number theory, one often studies sums of the form $$ \sum_{n\leq x} a_n f(n), $$ where $a_n$ is an arithmetic sequence and $f(x)$ is a smooth function. Direct estimation of such sums is frequently difficult. Abel summation transforms the problem into one involving partial sums of the coefficients $a_n$. This method is the discrete analogue of integration by parts. It is one of the basic tools connecting...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Rational and Integral Points

Polynomial Equations and Arithmetic Geometry A central problem in number theory is to study solutions of polynomial equations whose coordinates belong to a specified number system. Two important cases are: integral points, where the coordinates are integers, rational points, where the coordinates are rational numbers. For example, the equation $$ x^2+y^2=1 $$ has infinitely many rational solutions, such as $$ \left(\frac35,\frac45\right), $$ but only finitely many integral solutions: $$ (\pm1,0),\qquad...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Extended Euclidean Algorithm

From GCDs to Linear Combinations The Euclidean algorithm computes the greatest common divisor of two integers. The extended Euclidean algorithm does more. It also expresses the gcd as an integer linear combination of the original two integers. For integers $a$ and $b$, not both zero, it finds integers $x$ and $y$ such that $$ \gcd(a,b)=ax+by. $$ This identity is called Bézout's identity. For example, $$ \gcd(30,18)=6, $$ and $$ 6=30-18....

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Euclidean Algorithm

The Problem of Computing GCDs The greatest common divisor of two integers can be found by listing divisors, but this method becomes inefficient for large numbers. For example, finding $$ \gcd(1071,462) $$ by listing all divisors would be tedious. The Euclidean algorithm gives a fast and systematic method. It reduces a gcd problem to smaller gcd problems by repeated division with remainder. Basic Principle The key identity is $$ \gcd(a,b)=\gcd(b,r),...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Exponential Diophantine Equations

Equations Involving Powers An exponential Diophantine equation is a Diophantine equation in which one or more unknowns appear as exponents. Typical examples include $$ 2^x+3^y=z^2, $$ $$ x^n+y^n=z^n, $$ and $$ a^x-b^y=c. $$ Unlike linear or quadratic equations, exponential equations usually grow extremely rapidly. This rapid growth often implies that only finitely many integer solutions exist. Exponential Diophantine equations are among the most difficult problems in number theory because ordinary...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Catalan-Type Equations

Exponential Diophantine Equations A Catalan-type equation is a Diophantine equation involving powers whose values differ by a small amount. The classical example is $$ x^a-y^b=1, $$ where $$ x,y,a,b>1 $$ are integers. $$ x^a-y^b=1 $$ This equation asks whether two perfect powers can differ by exactly $1$. For example, $$ 3^2-2^3=9-8=1. $$ This gives the solution $$ (x,a,y,b)=(3,2,2,3). $$ A natural question arises: are there any others? Consecutive Perfect Powers...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Least Common Multiples

Common Multiples Let $a$ and $b$ be nonzero integers. An integer $m$ is called a common multiple of $a$ and $b$ if $$ a\mid m $$ and $$ b\mid m. $$ For example, the positive multiples of $6$ are $$ 6,12,18,24,30,36,\ldots $$ and the positive multiples of $8$ are $$ 8,16,24,32,40,48,\ldots $$ Their positive common multiples begin with $$ 24,48,72,\ldots $$ The smallest positive common multiple is $24$. Hence $$...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Convergence Methods

Infinite Processes in Analysis Analytic number theory studies infinite sums, products, and integrals. Before such expressions can be manipulated safely, one must understand the meaning of convergence. A sequence $(a_n)$ converges to $L$ if $$ \lim_{n\to\infty} a_n=L. $$ Similarly, an infinite series $$ \sum_{n=1}^{\infty} a_n $$ converges if its partial sums $$ S_N=\sum_{n=1}^{N} a_n $$ approach a finite limit as $N\to\infty$. Many techniques in analytic number theory depend on estimating...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Sums of Squares

Representation Problems One of the oldest questions in number theory asks which integers can be written as sums of squares. Typical examples are $$ 5=1^2+2^2, $$ $$ 25=3^2+4^2, $$ and $$ 50=1^2+7^2. $$ Such problems are called representation problems because they ask how integers may be represented by quadratic forms. The simplest equation of this type is $$ x^2+y^2=n, $$ where $n$ is a fixed positive integer and $x,y\in\mathbb{Z}$. $$...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Greatest Common Divisors

Common Divisors Let $a$ and $b$ be integers, not both zero. An integer $d$ is called a common divisor of $a$ and $b$ if $$ d\mid a $$ and $$ d\mid b. $$ For example, the positive divisors of $18$ are $$ 1,2,3,6,9,18, $$ and the positive divisors of $30$ are $$ 1,2,3,5,6,10,15,30. $$ Their common positive divisors are $$ 1,2,3,6. $$ The largest of these is $6$. Hence $$...

Writes › Book › Modern Number Theory › Appendix ›

Appendix C. Abstract Algebra Review

C.1 Algebraic Structures Abstract algebra studies sets equipped with operations. In number theory, these structures organize arithmetic behavior. The integers $\mathbb{Z}$ form a set with addition and multiplication. The residue classes modulo $n$, written $\mathbb{Z}/n\mathbb{Z}$, form a finite arithmetic system. Rational numbers, real numbers, complex numbers, finite fields, number fields, rings of integers, ideals, and elliptic curves all carry algebraic structure. The purpose of abstraction is to isolate the laws...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Euler Products

Series with Multiplicative Structure Euler products arise when an infinite series has coefficients controlled by multiplication. The simplest and most important example is the zeta series $$ \sum_{n=1}^{\infty}\frac{1}{n^s}, $$ where $s$ is a real number greater than $1$. This condition ensures absolute convergence. The key observation is that every positive integer factors uniquely into primes: $$ n=p_1^{a_1}p_2^{a_2}\cdots p_k^{a_k}. $$ Thus a sum over all positive integers can sometimes be decomposed...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Pell Equations

Quadratic Diophantine Equations A Pell equation is a Diophantine equation of the form $$ x^2-Dy^2=1, $$ where $D$ is a positive integer that is not a perfect square. $$ x^2-Dy^2=1 $$ The unknowns $x$ and $y$ are required to be integers. Equations of this type occupy a central position in classical number theory because they possess infinitely many solutions and exhibit deep algebraic structure. For example, when $$ D=2, $$...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

The Division Algorithm

Statement of the Algorithm The division algorithm is one of the basic structural facts about the integers. It says that any integer can be divided by a positive integer with a unique quotient and remainder. Let $a\in\mathbb{Z}$ and let $b\in\mathbb{N}$. Then there exist unique integers $q$ and $r$ such that $$ a=bq+r, $$ where $$ 0\le r<b. $$ The integer $q$ is called the quotient, and $r$ is called the...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Schemes

Motivation for Schemes Classical algebraic geometry studies varieties defined by polynomial equations. This theory works well over algebraically closed fields, especially over $\mathbb{C}$. However, many arithmetic questions require a more flexible framework. For example, number theory naturally involves rings such as $$ \mathbb{Z},\qquad \mathbb{Z}/n\mathbb{Z},\qquad \mathbb{Z}_p, $$ which are not fields. Classical varieties are insufficient for describing geometric structures over such rings. Scheme theory extends algebraic geometry from fields to arbitrary...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Splitting Fields

Polynomials and Their Roots A central problem in algebra is to determine where a polynomial factors completely into linear terms. Consider the polynomial $$ f(x)=x^2-2. $$ Over the rational numbers $\mathbb{Q}$, this polynomial cannot be factored further, since $\sqrt{2}\notin\mathbb{Q}$. Over the real numbers $\mathbb{R}$, however, $$ x^2-2=(x-\sqrt{2})(x+\sqrt{2}). $$ Thus the factorization of a polynomial depends on the field in which it is considered. In general, a polynomial may fail to...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Infinite Products

From Sums to Products An infinite product has the form $$ \prod_{n=1}^{\infty} a_n = a_1a_2a_3\cdots, $$ where each $a_n$ is a real or complex number. As with infinite series, the meaning of the expression is defined by finite approximations. The $N$-th partial product is $$ P_N=\prod_{n=1}^{N}a_n. $$ The infinite product converges to $L$ if $$ \lim_{N\to\infty} P_N=L $$ exists and $L\neq 0$. The nonzero condition is important. If the product...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Pythagorean Triples

Right Triangles and Integer Solutions A Pythagorean triple is a triple of positive integers $$ (a,b,c) $$ satisfying the equation $$ a^2+b^2=c^2. $$ This equation arises from the Pythagorean theorem in Euclidean geometry. If a right triangle has legs of lengths $a$ and $b$, and hypotenuse $c$, then $$ a^2+b^2=c^2 $$ A classical example is $$ (3,4,5), $$ since $$ 3^2+4^2=9+16=25=5^2. $$ Other examples include $$ (5,12,13),\qquad (8,15,17),\qquad (7,24,25). $$...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Composite Numbers

Definition of Composite Numbers A positive integer $n>1$ is called composite if it is not prime. Equivalently, $n$ is composite if there exist integers $a$ and $b$ such that $$ n=ab, $$ with $$ 1<a<n, \qquad 1<b<n. $$ Thus a composite number can be factored into smaller positive integers. For example, $$ 4=2\cdot2, \qquad 6=2\cdot3, \qquad 12=3\cdot4. $$ Hence $4$, $6$, and $12$ are composite numbers. A composite integer therefore...

Writes › Book › Modern Number Theory › Appendix ›

Appendix B. Proof Techniques

B.1 The Nature of Mathematical Proof A mathematical proof is a logically complete argument establishing the truth of a statement from accepted assumptions, definitions, and previously proved results. In number theory, proofs often combine algebraic manipulation, divisibility arguments, congruences, induction, and structural reasoning. A proof must justify every essential step. Numerical examples may suggest a statement, but they do not establish it universally. The distinction between observation and proof is...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Prime Numbers

Definition of Prime Numbers Prime numbers are the fundamental building blocks of arithmetic. A positive integer $p>1$ is called prime if its only positive divisors are $$ 1 \quad\text{and}\quad p. $$ Thus a prime number cannot be factored into smaller positive integers. For example, $$ 2,3,5,7,11,13 $$ are prime numbers. The integer $2$ is prime because its positive divisors are only $$ 1 \quad\text{and}\quad 2. $$ Similarly, $13$ is prime...

Writes › Book › Modern Number Theory › Appendix ›

Appendix

A.1 Sets A set is a collection of objects, called its elements. If $x$ is an element of a set $A$, we write $x \in A$. If $x$ is not an element of $A$, we write $x \notin A$. Examples: $$ \mathbb{N}={1,2,3,\ldots} $$ $$ \mathbb{Z}={\ldots,-2,-1,0,1,2,\ldots} $$ $$ \mathbb{Q}=\left{\frac{a}{b}:a,b\in\mathbb{Z}, b\ne 0\right} $$ In number theory, sets usually describe domains of arithmetic objects: integers, primes, residue classes, ideals, rational points, or solutions...

Writes › Book › Modern Number Theory › Chapter 5. Arithmetic Geometry and Modern Directions ›

Chapter 5. Arithmetic Geometry and Modern Directions

Polynomial Equations and Geometry Arithmetic geometry studies solutions of polynomial equations by combining algebra, geometry, and number theory. Its basic objects are spaces defined by polynomial equations. These spaces are called varieties. Let $k$ be a field, such as $\mathbb{Q}$, $\mathbb{R}$, $\mathbb{C}$, or a finite field $\mathbb{F}_p$. The affine $n$-space over $k$ is $$ \mathbb{A}^n(k)=k^n. $$ Its points are ordered $n$-tuples $$ (a_1,\ldots,a_n), $$ where each $a_i\in k$. A polynomial...

Writes › Book › Modern Number Theory › Chapter 4. Algebraic Number Theory ›

Chapter 4. Algebraic Number Theory

Fields Inside Larger Fields A field is a number system in which addition, subtraction, multiplication, and division by nonzero elements are always possible. The rational numbers $\mathbb{Q}$, the real numbers $\mathbb{R}$, the complex numbers $\mathbb{C}$, and the finite fields $\mathbb{F}_p$ are basic examples. A field extension occurs when one field is contained inside another. Definition. Let $K$ and $L$ be fields. We say that $L$ is a field extension of...

Writes › Book › Modern Number Theory › Chapter 3. Analytic Number Theory ›

Chapter 3. Analytic Number Theory

The Basic Series The harmonic series is the infinite series $$ 1+\frac12+\frac13+\frac14+\frac15+\cdots. $$ In summation notation, it is written as $$ \sum_{n=1}^{\infty}\frac1n. $$ This is one of the first infinite series that appears in analysis, but it is also central in number theory. Its terms become smaller and tend to zero: $$ \lim_{n\to\infty}\frac1n=0. $$ However, this condition alone does not guarantee that the infinite sum has a finite value. The...

Writes › Book › Modern Number Theory › Chapter 2. Classical Number Theory ›

Chapter 2. Classical Number Theory

Equations in Integers A Diophantine equation is an equation whose solutions are required to be integers. The unknowns are not allowed to range over the real numbers or complex numbers unless explicitly stated. This restriction changes the nature of the problem. For example, the equation $$ 2x+3y=1 $$ has many real solutions, but number theory asks for integer solutions. One such solution is $$ x=-1,\qquad y=1, $$ since $$ 2(-1)+3(1)=1....

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Divisibility Relations

Exact Division Division of integers does not always produce an integer. For example, $$ 12/3=4 $$ is an integer, while $$ 14/3 $$ is not. Number theory is mainly concerned with exact division, where one integer divides another without leaving a remainder. Let $a,b\in\mathbb{Z}$, with $a\ne0$. We say that $a$ divides $b$, and write $$ a\mid b, $$ if there exists an integer $q$ such that $$ b=aq. $$ The...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Historical Development of Number Systems

Numbers Before Mathematics The idea of number arose long before formal mathematics. Early civilizations used numbers for counting objects, measuring land, recording trade, and tracking time. The earliest number systems were concrete rather than abstract. A shepherd might count sheep using stones or marks on wood. Numbers represented physical collections rather than independent mathematical objects. Over time, arithmetic became increasingly symbolic and abstract. The development of number systems reflects the...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Growth of Integers

Size and Growth The integers extend infinitely in both directions: $$ \cdots,-3,-2,-1,0,1,2,3,\cdots $$ In number theory, one usually studies the size of an integer through its absolute value. The size of $n$ is measured by $$ |n|. $$ For positive integers, this is simply $n$. For negative integers, it removes the sign: $$ |-n|=n. $$ Growth concerns how quantities behave as $n$ becomes large. Many arithmetic questions are not about...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Recursive Definitions

Definitions by Recursion Many mathematical objects are defined recursively. A recursive definition specifies: one or more initial values, a rule for constructing later values from earlier ones. The natural numbers themselves arise recursively through the successor operation: $$ 1,2,3,\ldots $$ where each number is obtained from the preceding one by adding $1$. Recursive definitions are fundamental in number theory because arithmetic processes often proceed step by step. Sequences, algorithms, and...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Strong Induction

From Ordinary Induction to Strong Induction Ordinary induction proves a statement $P(n)$ by showing that truth passes from one case to the next: $$ P(k)\Longrightarrow P(k+1). $$ This is enough for many arguments. In number theory, however, the proof of $P(k+1)$ often requires more than the immediately preceding case. It may require several earlier cases, or even all earlier cases. Strong induction is designed for this situation. Instead of assuming...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Mathematical Induction

The Need for Induction Many statements in number theory concern all natural numbers. For example, one may wish to prove that $$ 1+2+\cdots+n=\frac{n(n+1)}{2} $$ for every $n\in\mathbb{N}$. It is not enough to check the formula for several values of $n$. Checking $$ n=1,2,3,4,5 $$ shows only that the formula holds in those cases. A proof must show that it holds for every natural number. Mathematical induction is the standard method...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Absolute Value and Distance

Magnitude and Sign The order relation distinguishes positive and negative integers, but in many situations the sign of a number is less important than its magnitude. For example, the integers $$ 5 \quad\text{and}\quad -5 $$ have opposite signs, yet both lie at the same distance from zero on the number line. This observation leads to the concept of absolute value. The absolute value of an integer $a$ is denoted by...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Order Relations

Ordered Structure of the Integers The integers are not merely a collection of numbers equipped with arithmetic operations. They also possess an order structure. Given two integers $a$ and $b$, one can determine whether $a$ is less than, equal to, or greater than $b$. The order relation on the integers is written using the symbols $$ <,\quad >,\quad \le,\quad \ge. $$ If $$ a<b, $$ we say that $a$ is...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Arithmetic Operations

Operations as Rules An arithmetic operation is a rule that combines numbers to produce another number. The most basic operations on integers are addition, subtraction, multiplication, and division. Addition and multiplication are always possible inside the integers. If $$ a,b\in\mathbb{Z}, $$ then $$ a+b\in\mathbb{Z} $$ and $$ ab\in\mathbb{Z}. $$ Subtraction is also always possible because the integers contain additive inverses: $$ a-b=a+(-b). $$ Division is different. The quotient $a/b$ need...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

The Integers

Limitations of the Natural Numbers The natural numbers are sufficient for counting and addition, but they are not sufficient for subtraction. For example, $$ 7-3=4 $$ is a natural number, while $$ 3-7 $$ is not contained in $\mathbb{N}$. To make subtraction universally possible, mathematics enlarges the number system by introducing the integers. The set of integers is denoted by $$ \mathbb{Z}={\ldots,-3,-2,-1,0,1,2,3,\ldots}. $$ The symbol $\mathbb{Z}$ comes from the German...

Writes › Book › Modern Number Theory › Chapter 1. Foundations of Arithmetic ›

Chapter 1. Foundations of Arithmetic

Counting and Quantity The natural numbers arise from the basic act of counting. When we count objects in a collection, we assign successive numbers: $$ 1,2,3,4,\ldots $$ These numbers are called the natural numbers. The standard notation for the set of natural numbers is $$ \mathbb{N}={1,2,3,4,\ldots}. $$ Some authors include $0$ in $\mathbb{N}$, while others begin with $1$. In this text, we shall usually write $$ \mathbb{N}_0={0,1,2,3,\ldots} $$ when zero...

Writes › Book › Auto Diff › Appendix ›

Differentiation of Large Stateful Systems

Automatic differentiation works naturally on pure mathematical functions: $$ y = f(x). $$ The function receives inputs, computes outputs, and produces no persistent side effects. Most theoretical treatments of AD assume this model. Large real systems rarely behave this way. Operating systems, databases, distributed services, simulations, robotics stacks, game engines, browsers, network services, and long-running machine learning pipelines all contain substantial mutable state. Their behavior depends not only on explicit...

Writes › Book › Auto Diff › Chapter 21. Major AD Systems ›

Differentiation of Large Stateful Systems

Automatic differentiation works naturally on pure mathematical functions: $$ y = f(x). $$ The function receives inputs, computes outputs, and produces no persistent side effects. Most theoretical treatments of AD assume this model. Large real systems rarely behave this way. Operating systems, databases, distributed services, simulations, robotics stacks, game engines, browsers, network services, and long-running machine learning pipelines all contain substantial mutable state. Their behavior depends not only on explicit...

Writes › Book › Auto Diff › Chapter 22. Open Problems ›

Chapter 22. Open Problems

Automatic differentiation works naturally on pure mathematical functions: $$ y = f(x). $$ The function receives inputs, computes outputs, and produces no persistent side effects. Most theoretical treatments of AD assume this model. Large real systems rarely behave this way. Operating systems, databases, distributed services, simulations, robotics stacks, game engines, browsers, network services, and long-running machine learning pipelines all contain substantial mutable state. Their behavior depends not only on explicit...

Writes › Book › Auto Diff › Chapter 20. Building an AD Engine ›

Production Deployment

Production Deployment A minimal automatic differentiation engine can compute correct gradients on small programs. A production system must survive long-running workloads, large tensors, distributed execution, hardware failures, user-defined operators, and adversarial numerical conditions. Production deployment transforms AD from a mathematical mechanism into infrastructure. The core derivative rules usually remain small. Most complexity appears in: execution management memory behavior observability reproducibility interoperability fault handling scalability A production AD system is therefore...

Writes › Book › Auto Diff › Chapter 18. Advanced Topics ›

Unified Differentiable Infrastructure

Unified Differentiable Infrastructure Automatic differentiation began as a numerical technique for computing gradients of scalar functions. Modern systems use differentiation far more broadly. A single computation may now include: Component Example neural networks representation learning optimization layers constrained decisions simulators physical dynamics databases retrieval and aggregation probabilistic models uncertainty differential equations continuous dynamics rendering systems graphics and vision distributed systems large-scale training Gradients must propagate through all of them. Unified...

Writes › Book › Auto Diff › Chapter 16. Sparse and Structured Differentiation ›

Chapter 16. Sparse and Structured Differentiation

Sparse and structured differentiation studies how to compute derivatives without materializing dense derivative objects. Many real systems have enormous Jacobians and Hessians, but most entries are zero, repeated, blocked, low rank, or constrained by graph structure. A dense Jacobian for a function $$ f : \mathbb{R}^n \to \mathbb{R}^m $$ has $mn$ entries. If $m$ and $n$ are large, storing or computing the full matrix is often impossible. Automatic differentiation usually...

Writes › Book › Auto Diff › Chapter 13. Optimization and Machine Learning ›

Physics-Informed Models

Physics-Informed Models Physics-informed models combine data fitting with equations from physics or applied mathematics. The model is trained not only to match observed samples, but also to satisfy known laws such as conservation equations, differential equations, boundary conditions, or constitutive relations. A common setting is a neural network approximation to an unknown function: $$ u_\theta(x,t) $$ where $x$ is a spatial coordinate, $t$ is time, and $\theta$ are trainable parameters....

Writes › Book › Auto Diff › Chapter 12. AD in Modern Programming Languages ›

Effect Systems and Mutation

Effect Systems and Mutation Automatic differentiation is easiest to define for pure functions. A pure function behaves like a mathematical mapping: it consumes inputs, produces outputs, and has no observable side effects. Real programs are rarely this simple. They mutate arrays, allocate memory, read state, launch kernels, perform I/O, sample random values, and synchronize across devices. An effect system describes these behaviors explicitly. It tracks what a computation does in...

Writes › Book › Auto Diff › Chapter 11. Compiler and Runtime Design ›

Ahead-of-Time vs Just-in-Time Differentiation

Ahead-of-Time vs Just-in-Time Differentiation Automatic differentiation can be performed before a program runs, while it runs, or in a staged phase between the two. The two main compiler-oriented models are ahead-of-time differentiation and just-in-time differentiation. Ahead-of-time differentiation, or AOT differentiation, generates derivative code before execution. Just-in-time differentiation, or JIT differentiation, generates derivative code during execution, usually after seeing concrete input types, shapes, or runtime configuration. Both models treat AD as...

Writes › Book › Auto Diff › Chapter 6. Reverse Mode Automatic Differentiation ›

Case Studies

Case Studies This section studies reverse mode automatic differentiation through concrete examples. Each case has the same structure: evaluate the primal computation forward; seed the output adjoint; propagate adjoints backward; collect input or parameter gradients. The examples move from scalar expressions to neural network layers and iterative programs. Case Study 1: Scalar Expression Consider $$ y = \log(1 + x^2). $$ Decompose the computation: $$ v_1 = x^2, $$ $$...

Writes › Book › Auto Diff › Chapter 4. Core Theory of Automatic Differentiation ›

Tangent Propagation

Forward mode automatic differentiation computes derivatives by propagating tangent values alongside ordinary values. The ordinary value is called the primal. The derivative value is called the tangent. For every program variable $v$, forward mode tracks: $$ (v,\dot v) $$ The dot notation means “the change in $v$ induced by a chosen change in the input.” If the input changes in direction $\dot x$, then every later value changes according to...

Writes › Book › Auto Diff › Chapter 2. Mathematical Foundations ›

Taylor Expansions

Taylor Expansions Differentiation describes how a function changes locally. A Taylor expansion extends this idea by approximating a function with a polynomial around a point. Automatic differentiation is fundamentally a first-order method in most applications, but higher-order AD is closely connected to Taylor expansions. Forward mode can be generalized to propagate higher-order coefficients, and many derivative identities become clearer through the Taylor viewpoint. Local Polynomial Approximation Let $$ f :...

Writes › Book › Auto Diff › Appendix ›

Comparative Architecture Analysis

Comparative Architecture Analysis The systems in this chapter show that automatic differentiation is not one implementation technique. It is a family of program transformations. Each system chooses a different representation of the program, a different execution model, and a different boundary between user code, compiler code, and runtime code. ADIFOR and Tapenade treat AD as source transformation. TensorFlow and PyTorch treat AD as graph or tape execution over tensor primitives....

Writes › Book › Auto Diff › Chapter 21. Major AD Systems ›

Comparative Architecture Analysis

Comparative Architecture Analysis The systems in this chapter show that automatic differentiation is not one implementation technique. It is a family of program transformations. Each system chooses a different representation of the program, a different execution model, and a different boundary between user code, compiler code, and runtime code. ADIFOR and Tapenade treat AD as source transformation. TensorFlow and PyTorch treat AD as graph or tape execution over tensor primitives....

Writes › Book › Auto Diff › Chapter 20. Building an AD Engine ›

Testing Derivatives

Testing Derivatives An automatic differentiation engine is only useful if its derivatives are correct. A small mistake in a backward rule can silently corrupt optimization, training, or scientific computation. Derivative testing therefore belongs at the center of AD system design. A correct primal computation with incorrect gradients is usually worse than a runtime error. Numerical optimization may still appear to progress while converging to meaningless results. Derivative testing should validate:...

Writes › Book › Auto Diff › Chapter 19. Theory and Foundations ›

Differentiation as Functorial Transformation

Differentiation as Functorial Transformation The preceding sections described automatic differentiation through algebraic, categorical, logical, and denotational models. These viewpoints converge on one central idea: Differentiation preserves structure. A program is built by composing smaller computations. Automatic differentiation works because the derivative of the whole computation can be constructed from derivatives of the parts, in the same compositional order for forward mode and in the dual order for reverse mode. This...

Writes › Book › Auto Diff › Chapter 18. Advanced Topics ›

Verified Differentiation

Verified Differentiation Automatic differentiation systems are usually trusted because they implement mathematically established rules such as the chain rule, product rule, and linearization of elementary operations. However, practical AD systems are large compiler and runtime systems containing: Component Complexity graph transformations compiler correctness tensor kernels numerical precision mutation handling state consistency checkpointing recomputation logic custom gradients user-defined semantics distributed execution synchronization correctness A small mistake may silently produce incorrect gradients....

Writes › Book › Auto Diff › Chapter 17. Numerical and Systems Concerns ›

Distributed Gradient Computation

Distributed Gradient Computation Distributed gradient computation appears when a differentiable program no longer fits comfortably on one device or one machine. The reason may be model size, data volume, sequence length, simulation resolution, or throughput requirements. At that point, automatic differentiation becomes a distributed systems problem. The derivative rules remain local. The execution is no longer local. A distributed AD system must compute gradients while coordinating: partitioned tensors, replicated parameters,...

Writes › Book › Auto Diff › Chapter 15. Differentiable Systems Architecture ›

Summary

Summary Differentiable systems architecture extends automatic differentiation beyond isolated functions and neural network layers. The central idea is to treat larger systems as compositions of differentiable, partially differentiable, or optimization-aware components. A system may include: Component Differentiable Role Pipeline Propagates task loss through many stages Database Makes retrieval, ranking, and aggregation trainable Renderer Sends image loss back into geometry, pose, lighting, and material parameters Physics engine Sends trajectory loss back...

Writes › Book › Auto Diff › Chapter 14. Scientific Computing Applications ›

Probabilistic Programming

Probabilistic Programming Probabilistic programming represents uncertainty using executable probabilistic models. A probabilistic program defines a distribution rather than only a deterministic computation. Automatic differentiation is important because most modern probabilistic inference methods rely on gradients of probability densities, likelihoods, or variational objectives. A probabilistic model typically defines: $$ x \sim p(x \mid \theta), $$ where: Symbol Meaning $x$ latent variables $\theta$ model parameters $p$ probability distribution Given observations $y$, inference...

Writes › Book › Auto Diff › Chapter 13. Optimization and Machine Learning ›

Reinforcement Learning

Reinforcement Learning Reinforcement learning studies learning systems that act in an environment. Unlike supervised learning, the training signal is not a target label for each input. The model chooses actions, the environment responds, and rewards may arrive later. A reinforcement learning problem is usually described as a Markov decision process. At time $t$, the agent observes a state $s_t$, chooses an action $a_t$, receives a reward $r_t$, and moves to...

Writes › Book › Auto Diff › Chapter 12. AD in Modern Programming Languages ›

Type Systems for Differentiation

Type Systems for Differentiation Automatic differentiation interacts deeply with type systems because differentiation changes the structure of computation. A derivative operator maps one function into another function with different inputs, outputs, and intermediate behavior. A type system can describe these transformations explicitly, reject invalid programs, and encode mathematical structure directly into the language. In small AD systems, differentiation is often treated as a runtime feature. In larger differentiable programming systems,...

Writes › Book › Auto Diff › Chapter 11. Compiler and Runtime Design ›

Kernel Fusion

Kernel Fusion Kernel fusion combines several small operations into one larger executable unit. In tensor programs, a kernel is a unit of work launched on a device such as a CPU, GPU, or TPU. A simple expression may produce many kernels if each primitive operation is executed separately. y = exp(x) z = y + 1 w = log(z) A naive runtime may execute three kernels: kernel 1: y =...

Writes › Book › Auto Diff › Chapter 10. Matrix and Tensor Differentiation ›

GPU Tensor Kernels

GPU Tensor Kernels Modern automatic differentiation systems are fundamentally tensor compiler systems. Their performance depends less on mathematical differentiation rules than on how efficiently tensor kernels execute on accelerators. GPU tensor kernels are the computational substrate of modern deep learning, scientific computing, and differentiable simulation. Reverse-mode AD amplifies the importance of kernel efficiency because every forward operation usually induces at least one backward operation. The challenge is therefore not only:...

Writes › Book › Auto Diff › Chapter 8. Higher-Order Differentiation ›

Complexity of Higher Orders

Complexity of Higher Orders Higher-order automatic differentiation faces a fundamental problem: derivative structure grows combinatorially with order. For a function $$ f : \mathbb{R}^n \to \mathbb{R}, $$ the first derivative is a vector, the second derivative is a matrix, and higher derivatives become tensors. The size growth is severe: Order Object Dense size 1 gradient $n$ 2 Hessian $n^2$ 3 third-order tensor $n^3$ 4 fourth-order tensor $n^4$ This growth is...

Writes › Book › Auto Diff › Chapter 7. Dual Numbers and Algebraic Structures ›

Differential Lambda Calculus

Differential Lambda Calculus Automatic differentiation is deeply connected to functional programming and lambda calculus. Programs can be viewed as mathematical functions, and differentiation can be treated as a transformation on programs themselves. Differential lambda calculus extends ordinary lambda calculus with explicit notions of infinitesimal variation, linear approximation, and derivative propagation. This provides a formal foundation for differentiable programming languages. Ordinary Lambda Calculus Lambda calculus is a minimal formal system for...

Writes › Book › Auto Diff › Chapter 6. Reverse Mode Automatic Differentiation ›

Reverse Mode in Deep Learning

Reverse Mode in Deep Learning Reverse mode automatic differentiation is the mathematical and systems basis of backpropagation. In deep learning, the objective is usually a scalar loss depending on many parameters. This is exactly the setting where reverse mode is most efficient. A neural network training step can be written as $$ L(\theta) = \ell(F(x;\theta), y), $$ where $x$ is an input batch, $y$ is the target, $F$ is the...

Writes › Book › Auto Diff › Chapter 5. Forward Mode Automatic Differentiation ›

Case Studies

Case Studies Forward mode automatic differentiation appears in many numerical systems where directional derivatives, local sensitivities, or small parameter sets are important. This chapter examines concrete applications and analyzes why forward mode fits their computational structure. The emphasis is not merely on using derivatives, but on how tangent propagation integrates with the execution model of each system. Sensitivity Analysis in Scientific Computing Many scientific simulations depend on a small set...

Writes › Book › Auto Diff › Chapter 4. Core Theory of Automatic Differentiation ›

Summary and Synthesis

Automatic differentiation is a method for computing derivatives by transforming programs into derivative-propagating computations. It does not approximate derivatives numerically and does not manipulate symbolic expressions globally. Instead, it applies the chain rule locally across primitive operations. This chapter established the operational foundations of AD: local derivative propagation elementary derivative rules forward accumulation reverse accumulation mixed-mode composition computational complexity floating point exactness program transformation Together, these ideas define the modern...

Writes › Book › Auto Diff › Appendix ›

Tinygrad

Tinygrad Tinygrad is a small deep learning framework centered around a minimal reverse-mode automatic differentiation engine. It was created by entity["people","George Hotz","Tinygrad creator"] as an experiment in reducing machine learning infrastructure to a compact and understandable core. Unlike large frameworks such as entity["company","Google","Mountain View, CA, USA"] TensorFlow or entity["company","Meta","Menlo Park, CA, USA"] PyTorch, Tinygrad emphasizes simplicity over ecosystem breadth. Its importance is educational and architectural rather than industrial scale. Tinygrad...

Writes › Book › Auto Diff › Chapter 21. Major AD Systems ›

Tinygrad

Tinygrad Tinygrad is a small deep learning framework centered around a minimal reverse-mode automatic differentiation engine. It was created by entity["people","George Hotz","Tinygrad creator"] as an experiment in reducing machine learning infrastructure to a compact and understandable core. Unlike large frameworks such as entity["company","Google","Mountain View, CA, USA"] TensorFlow or entity["company","Meta","Menlo Park, CA, USA"] PyTorch, Tinygrad emphasizes simplicity over ecosystem breadth. Its importance is educational and architectural rather than industrial scale. Tinygrad...

Writes › Book › Auto Diff › Chapter 20. Building an AD Engine ›

Performance Benchmarking

Performance Benchmarking Performance benchmarking measures whether an automatic differentiation engine is fast, memory-efficient, and scalable under realistic workloads. It also protects the engine from regressions. Without benchmarks, small implementation changes can silently increase allocation count, tape size, kernel launch count, or backward latency. A benchmark should answer concrete questions: How fast is the forward pass? How fast is the backward pass? How much memory is retained? How many allocations occur?...

Writes › Book › Auto Diff › Chapter 19. Theory and Foundations ›

Denotational Models

Denotational Models Operational semantics explains how automatic differentiation executes. Denotational semantics explains what differentiable programs mean. A denotational model assigns mathematical objects to programs: numbers, functions, spaces, morphisms, domains, linear maps. The meaning of a program becomes independent of: execution order, implementation strategy, compiler structure, hardware behavior. For automatic differentiation, denotational semantics answers a central question: What mathematical object does a differentiable program denote? This question becomes increasingly important for:...

Writes › Book › Auto Diff › Chapter 18. Advanced Topics ›

Differentiable Programming Languages

Differentiable Programming Languages Automatic differentiation began as a transformation applied to numerical programs. A differentiable programming language instead treats differentiation as a native semantic operation of the language itself. In such systems, derivatives are not external utilities layered on top of programs. They become part of the programming model. The language may support constructs such as: grad(f) jacobian(f) vjp(f) jvp(f) as ordinary language operators. The goal is deeper integration between:...

Writes › Book › Auto Diff › Chapter 17. Numerical and Systems Concerns ›

GPU and TPU Execution

GPU and TPU Execution Modern automatic differentiation systems are built around accelerator hardware. GPUs and TPUs provide enormous throughput for tensor operations, making large-scale differentiable computation practical. Reverse-mode AD, deep learning, differentiable simulation, and large tensor algebra all depend heavily on these architectures. Accelerators are not merely faster CPUs. They expose fundamentally different execution models: massive parallelism, hierarchical memory systems, SIMD or SIMT execution, high-throughput tensor units, asynchronous scheduling, and...

Writes › Book › Auto Diff › Chapter 15. Differentiable Systems Architecture ›

Hybrid Symbolic-Numeric Systems

Hybrid Symbolic-Numeric Systems A hybrid symbolic-numeric system combines discrete symbolic reasoning with continuous numerical computation. In the context of automatic differentiation, it means a pipeline where some components operate over symbols, rules, logic, programs, graphs, or queries, while other components operate over tensors, vectors, probabilities, or differentiable functions. The basic form is: $$ x \rightarrow S(x) \rightarrow N(S(x)) \rightarrow L $$ where $S$ is a symbolic transformation, $N$ is a...

Writes › Book › Auto Diff › Chapter 14. Scientific Computing Applications ›

Robotics and Control

Robotics and Control Robotics and control systems interact with the physical world through sensing, estimation, planning, and actuation. Automatic differentiation is important because modern control pipelines increasingly depend on optimization, simulation, system identification, and differentiable models. A robotic system is often represented as a dynamical system: $$ x_{t+1}=f(x_t,u_t,\theta), $$ where: Symbol Meaning $x_t$ system state $u_t$ control input $\theta$ physical or model parameters A controller chooses actions $$ u_t =...

Writes › Book › Auto Diff › Chapter 13. Optimization and Machine Learning ›

Meta-Learning

Meta-Learning Meta-learning studies systems that improve how they learn. Instead of only optimizing model parameters for one task, a meta-learning method optimizes some part of the learning process itself: an initialization, an optimizer, a loss function, a data-selection rule, a representation, or an adaptation procedure. A standard supervised learning problem learns parameters $\theta$ for one dataset. A meta-learning problem considers a distribution over tasks: $$ \tau \sim p(\tau). $$ Each...

Writes › Book › Auto Diff › Chapter 12. AD in Modern Programming Languages ›

AD in Swift

AD in Swift Swift became an important experiment in language-integrated automatic differentiation because it attempted to make differentiation a core compiler feature rather than a library layered on top of the language. The central idea was that differentiable functions should participate in the type system, compilation pipeline, optimization passes, and language semantics directly. This differs from many runtime-based systems. Instead of tracing operations dynamically or overloading tensor types externally, the...

Writes › Book › Auto Diff › Chapter 11. Compiler and Runtime Design ›

Memory Planning

Memory Planning Memory planning determines where values are stored, how long they remain alive, and when storage can be reused. For automatic differentiation, memory planning is a central systems problem because reverse mode often requires large numbers of intermediate values from the forward pass. A simple mathematical expression may appear small: y = sin(x * x) but a deep neural network, PDE solver, or simulation may produce millions of intermediate...

Writes › Book › Auto Diff › Chapter 10. Matrix and Tensor Differentiation ›

Sparse Tensor Derivatives

Sparse Tensor Derivatives Most real computational problems are sparse. Large matrices and tensors often contain mostly zeros, structured blocks, or local interactions. Sparse representations reduce memory usage and computational cost by storing only the nonzero structure. Automatic differentiation must preserve sparsity whenever possible. If differentiation destroys sparsity structure, the resulting gradients can become prohibitively expensive. Sparse differentiation therefore has two goals: Compute correct derivatives. Preserve structural sparsity through the derivative...

Writes › Book › Auto Diff › Chapter 9. Differentiation of Control Flow ›

Exception Handling and Undefined Regions

Exception Handling and Undefined Regions Programs do not only branch between valid computations. They also fail, stop early, raise exceptions, return sentinel values, or enter undefined numerical regions. These behaviors matter for automatic differentiation because a derivative only has meaning where the primal computation itself has a well-defined value. A mathematical function may be partial: $$ f : D \to Y $$ where $D$ is the subset of inputs for...

Writes › Book › Auto Diff › Chapter 8. Higher-Order Differentiation ›

Perturbation Confusion

Perturbation Confusion Perturbation confusion is a correctness bug that appears in nested automatic differentiation, especially nested forward mode. It happens when two derivative computations accidentally use the same infinitesimal perturbation. Forward mode is often explained with dual numbers: $$ x + \epsilon \dot{x}, $$ where $$ \epsilon^2 = 0. $$ The symbol $\epsilon$ marks the tangent part of the computation. In a single forward-mode pass, this works cleanly. In nested...

Writes › Book › Auto Diff › Chapter 7. Dual Numbers and Algebraic Structures ›

Differential Lambda Calculus

Differential Lambda Calculus Automatic differentiation is deeply connected to functional programming and lambda calculus. Programs can be viewed as mathematical functions, and differentiation can be treated as a transformation on programs themselves. Differential lambda calculus extends ordinary lambda calculus with explicit notions of infinitesimal variation, linear approximation, and derivative propagation. This provides a formal foundation for differentiable programming languages. Ordinary Lambda Calculus Lambda calculus is a minimal formal system for...

Writes › Book › Auto Diff › Chapter 6. Reverse Mode Automatic Differentiation ›

Checkpointing

Checkpointing Checkpointing is a technique for reducing the memory cost of reverse mode automatic differentiation by selectively storing intermediate states and recomputing missing values during the backward pass. It addresses the central problem of reverse mode: The backward pass needs information from the forward pass, but storing all intermediate values may exceed available memory. Checkpointing balances memory usage against recomputation cost. Basic Idea Suppose a forward computation produces a sequence...

Writes › Book › Auto Diff › Chapter 5. Forward Mode Automatic Differentiation ›

Sparse Forward Methods

Sparse Forward Methods Many real-world Jacobians are sparse. Most derivative entries are zero because outputs depend only on small subsets of inputs. Forward mode automatic differentiation can exploit this structure to reduce: runtime, memory usage, tangent dimensionality, cache pressure, bandwidth cost. Sparse forward methods are techniques for propagating only the derivative information that actually matters. Sparse Jacobians Suppose $$ f : \mathbb{R}^n \to \mathbb{R}^m. $$ The Jacobian is $$ J_f(x)...

Writes › Book › Auto Diff › Chapter 4. Core Theory of Automatic Differentiation ›

AD as Program Transformation

Automatic differentiation can be understood as a transformation from one program into another program. The original program computes values. The transformed program computes values and derivatives. This view is important because real AD systems operate on code, traces, graphs, or compiler intermediate representations. They are not merely applying calculus rules on paper. They rewrite computation. From Mathematical Function to Program A mathematical function may be written as: $$ f(x)=\sin(x^2+3x) $$...

Writes › Book › Auto Diff › Chapter 3. Programs as Mathematical Objects ›

Differentiable Subprograms

Differentiable Subprograms A differentiable subprogram is a program fragment that can participate in derivative propagation as a coherent unit. Instead of differentiating an entire application monolithically, AD systems decompose computation into smaller callable pieces with well-defined derivative behavior. A simple example is: def square(x): return x * x Mathematically: $$ f(x) = x^2. $$ Its derivative is: $$ f'(x) = 2x. $$ An AD system can either inline the body...

Writes › Book › Auto Diff › Chapter 21. Major AD Systems ›

Enzyme

Enzyme Enzyme is a compiler-based automatic differentiation system for LLVM and MLIR. Instead of differentiating source code directly, or recording tensor operations at runtime, Enzyme works on compiler intermediate representation. This design gives Enzyme a distinct position among AD systems. ADIFOR and Tapenade transform source programs. PyTorch records a dynamic tape. JAX traces array programs. Zygote transforms Julia IR. Enzyme differentiates low-level optimized IR produced by many frontends. The project...

Writes › Book › Auto Diff › Appendix ›

Enzyme

Enzyme Enzyme is a compiler-based automatic differentiation system for LLVM and MLIR. Instead of differentiating source code directly, or recording tensor operations at runtime, Enzyme works on compiler intermediate representation. This design gives Enzyme a distinct position among AD systems. ADIFOR and Tapenade transform source programs. PyTorch records a dynamic tape. JAX traces array programs. Zygote transforms Julia IR. Enzyme differentiates low-level optimized IR produced by many frontends. The project...

Writes › Book › Auto Diff › Chapter 20. Building an AD Engine ›

Custom Gradients

Custom Gradients A custom gradient gives the user direct control over the backward rule of an operation. The forward computation still produces an ordinary value, but the derivative no longer has to be inferred from the primitive operations used internally. This is useful when the default AD result is mathematically correct but computationally poor, numerically unstable, too memory-hungry, or simply not the derivative the user wants the system to use....

Writes › Book › Auto Diff › Chapter 19. Theory and Foundations ›

Formal Verification

Formal Verification Automatic differentiation systems are trusted infrastructure. Scientific computing, machine learning, optimization, simulation, and control systems depend on gradients being correct. Yet AD implementations are complicated: compiler transformations, graph rewrites, mutation handling, checkpointing, floating-point arithmetic, higher-order differentiation, distributed execution. A small semantic error may silently produce incorrect gradients. Formal verification studies how to prove that: differentiation rules are correct, transformed programs preserve semantics, gradients satisfy mathematical definitions, AD compilers...

Writes › Book › Auto Diff › Chapter 18. Advanced Topics ›

Quantum Differentiation

Quantum Differentiation Quantum computation introduces a computational model fundamentally different from classical programs. A classical program evolves deterministic or probabilistic states through ordinary arithmetic and control flow. A quantum program evolves complex-valued amplitudes through unitary transformations and measurement operators. Automatic differentiation in quantum systems studies how outputs of quantum computations change with respect to parameters. This includes gradients of expectation values, variational quantum circuits, quantum control systems, and hybrid quantum-classical...

Writes › Book › Auto Diff › Chapter 17. Numerical and Systems Concerns ›

Parallelism

Parallelism Automatic differentiation is usually described as a transformation of programs or computational graphs. In real systems, it is also a parallel execution problem. Large differentiable programs contain millions or billions of operations, and modern hardware exposes thousands of concurrent execution lanes. Efficient AD must therefore expose, schedule, and control parallel work. Parallelism affects both performance and numerical behavior. It changes operation ordering, memory movement, reduction structure, and sometimes even...

Writes › Book › Auto Diff › Chapter 15. Differentiable Systems Architecture ›

Differentiable Operating Systems

Differentiable Operating Systems A differentiable operating system is an execution environment whose resource-management decisions can be optimized using gradients or gradient-like feedback. Instead of treating scheduling, memory placement, caching, and I/O as fixed policies, the system exposes parts of those policies as trainable components. The goal is not to replace an operating system kernel with a neural network. The goal is to make selected system decisions measurable, optimizable, and responsive...

Writes › Book › Auto Diff › Chapter 14. Scientific Computing Applications ›

Signal Processing

Signal Processing Signal processing studies how information is represented, transformed, filtered, compressed, reconstructed, and estimated from signals. A signal may be a time series, an image, an audio waveform, a radar return, a sensor stream, or a multidimensional field. Automatic differentiation is useful because many signal processing systems can be written as differentiable programs: $$ x \to T_\theta(x) \to y \to L(y) $$ where $x$ is an input signal, $T_\theta$...

Writes › Book › Auto Diff › Chapter 13. Optimization and Machine Learning ›

Implicit Layers

Implicit Layers An implicit layer defines its output as the solution of an equation, not as a fixed sequence of explicit operations. Instead of computing $$ z = f_\theta(x) $$ by applying a known list of layers, an implicit layer defines $z$ through a condition: $$ F(z, x, \theta) = 0. $$ The value $z$ is found by a solver. The solver may use Newton iterations, fixed-point iteration, conjugate gradients,...

Writes › Book › Auto Diff › Chapter 12. AD in Modern Programming Languages ›

AD in Julia

AD in Julia Julia was designed for high-performance technical computing. It combines interactive syntax with a compiler capable of specializing code aggressively based on types. This makes it a strong environment for automatic differentiation because AD systems can operate close to ordinary mathematical code while still generating optimized machine code. Unlike Python, where tensor operations are often dispatched into external runtimes, Julia programs are commonly written directly in the host...

Writes › Book › Auto Diff › Chapter 11. Compiler and Runtime Design ›

Staging and Partial Evaluation

Staging and Partial Evaluation Staging is the separation of a program into phases. In an automatic differentiation system, the most common phases are: trace time compile time run time A staged system does not execute every part of the user program in the same way. Some parts run immediately in the host language. Other parts are captured into an intermediate representation. That captured representation may then be differentiated, optimized, compiled,...

Writes › Book › Auto Diff › Chapter 10. Matrix and Tensor Differentiation ›

Singular Value Decomposition

Singular Value Decomposition The singular value decomposition (SVD) is one of the most important matrix factorizations in numerical linear algebra. It appears in dimensionality reduction, least squares, low-rank approximation, spectral regularization, recommendation systems, scientific computing, and modern machine learning. For automatic differentiation, SVD is both powerful and difficult. Singular values are comparatively stable. Singular vectors are not. The derivative formulas expose this instability directly. Definition For a matrix $$ A...

Writes › Book › Auto Diff › Chapter 9. Differentiation of Control Flow ›

Differentiating Stateful Systems

Differentiating Stateful Systems A stateful system is a program whose output depends not only on its explicit inputs, but also on stored state. The state may live in variables, objects, arrays, files, random number generators, caches, mutable buffers, optimizers, simulators, databases, or external services. In pure mathematical notation, a function has the form: $$ y = f(x) $$ A stateful computation has the form: $$ (y, s') = F(x, s)...

Writes › Book › Auto Diff › Chapter 8. Higher-Order Differentiation ›

Efficient Higher-Order Methods

Efficient Higher-Order Methods Higher-order derivatives contain rich geometric information, but naïve computation quickly becomes impractical. For a function $$ f : \mathbb{R}^n \to \mathbb{R}, $$ the size of derivative objects grows rapidly: Derivative Size gradient $n$ Hessian $n^2$ third-order tensor $n^3$ fourth-order tensor $n^4$ Even when computation is mathematically possible, explicit tensor construction is often infeasible. Efficient higher-order methods therefore focus on three goals: Goal Strategy avoid explicit tensors operator...

Writes › Book › Auto Diff › Chapter 7. Dual Numbers and Algebraic Structures ›

Category-Theoretic View

Category-Theoretic View Automatic differentiation can be described operationally through dual numbers and computational graphs. It can also be described abstractly using category theory. This perspective treats differentiation as a structural transformation between compositional systems. Instead of focusing on coordinates, variables, or symbolic expressions, category theory focuses on: objects morphisms composition functorial structure The central idea is that differentiation preserves composition. Automatic differentiation becomes a compositional lifting process. Categories A category...

Writes › Book › Auto Diff › Chapter 6. Reverse Mode Automatic Differentiation ›

Memory-Time Tradeoffs

Memory-Time Tradeoffs Reverse mode automatic differentiation is computationally efficient for scalar-output functions, but it has a major systems cost: it needs information from the forward pass during the backward pass. The reverse pass cannot usually compute derivatives from the output value alone. It needs intermediate primal values, shapes, branches, and sometimes full solver or kernel state. The system must either store this information or recompute it. This creates the central...

Writes › Book › Auto Diff › Chapter 5. Forward Mode Automatic Differentiation ›

Efficient Seeding Strategies

Efficient Seeding Strategies Forward mode automatic differentiation computes Jacobian-vector products: $$ J_f(x)v. $$ The seed vector $$ v $$ determines which derivative information propagates through the program. Choosing good seeds is therefore central to efficiency. A naive approach computes one Jacobian column at a time using basis vectors: $$ e_1, e_2, \ldots, e_n. $$ This always works, but it may waste computation when the Jacobian has structure. Efficient seeding strategies...

Writes › Book › Auto Diff › Chapter 4. Core Theory of Automatic Differentiation ›

Numerical Exactness up to Floating Point

Automatic differentiation computes derivatives exactly with respect to the executed floating point program. This distinguishes AD from numerical differentiation, which approximates derivatives using perturbations. The phrase “exact up to floating point” has a precise meaning: AD does not introduce truncation error AD does not approximate derivatives by finite differences AD propagates analytically correct local derivatives all remaining error comes from ordinary floating point arithmetic Automatic differentiation therefore inherits the numerical...

Writes › Book › Auto Diff › Chapter 3. Programs as Mathematical Objects ›

Purity and Side Effects

Purity and Side Effects A pure computation is easier to differentiate because every output is determined only by its explicit inputs. There is no hidden state, no external mutation, and no dependence on execution history outside the function call. For example: y = f(x) is pure when the same x always produces the same y , and the call changes nothing outside itself. An impure computation may read or write...

Writes › Book › Auto Diff › Chapter 2. Mathematical Foundations ›

Dual Spaces and Pushforwards

Dual Spaces and Pushforwards Forward mode and reverse mode propagate different kinds of objects. Forward mode propagates tangent vectors. These represent small changes in values. Reverse mode propagates cotangent vectors. These represent sensitivities of an output with respect to values. The distinction is more than notation. It explains why forward mode computes Jacobian-vector products, while reverse mode computes vector-Jacobian products. Tangent Vectors Suppose $$ f : \mathbb{R}^n \to \mathbb{R}^m $$...

Writes › Book › Auto Diff › Chapter 1. Introduction ›

Applications Across Science and Engineering

Applications Across Science and Engineering Automatic differentiation became important because derivatives are required everywhere numerical models are optimized, controlled, calibrated, or analyzed. Once a system can compute derivatives automatically, entire classes of algorithms become practical at large scale. The same mathematical mechanism appears across many fields: $$ \text{compute value} \quad \rightarrow \quad \text{compute sensitivity}. $$ The value may be a loss, simulation result, likelihood, energy, trajectory, or prediction. The derivative...

Writes › Book › Auto Diff › Appendix ›

Zygote

Zygote Zygote is a source-to-source reverse-mode automatic differentiation system for the Julia programming language. It was designed to differentiate high-level Julia code directly, without requiring a separate graph-building runtime or explicit tracing API. Its central idea is that differentiation should operate on ordinary language semantics rather than on a restricted tensor graph. A Julia function is treated as a differentiable program transformation target. Differentiating Julia Functions In Zygote, gradients are...

Writes › Book › Auto Diff › Chapter 21. Major AD Systems ›

Zygote

Zygote Zygote is a source-to-source reverse-mode automatic differentiation system for the Julia programming language. It was designed to differentiate high-level Julia code directly, without requiring a separate graph-building runtime or explicit tracing API. Its central idea is that differentiation should operate on ordinary language semantics rather than on a restricted tensor graph. A Julia function is treated as a differentiable program transformation target. Differentiating Julia Functions In Zygote, gradients are...

Writes › Book › Auto Diff › Chapter 20. Building an AD Engine ›

Operator Libraries

Operator Libraries An automatic differentiation engine becomes useful only after it supports a sufficiently rich set of primitive operations. The collection of these primitives is the operator library. The operator library defines: which computations are differentiable how derivatives propagate what tensor semantics exist how shapes and dtypes behave which kernels execute on which devices In a minimal engine, the operator library may contain fewer than ten scalar operations. In a...

Writes › Book › Auto Diff › Chapter 19. Theory and Foundations ›

Program Equivalence

Program Equivalence Automatic differentiation transforms programs. A fundamental semantic question therefore arises: When do two programs have the same derivative behavior? Program equivalence studies when two computations should be considered identical. In differentiable systems this becomes more subtle because: two programs may compute the same values but different derivatives, two programs may produce equivalent derivatives through different computational structures, floating-point behavior may preserve primal equivalence while changing gradient behavior, mutation...

Writes › Book › Auto Diff › Chapter 18. Advanced Topics ›

Probabilistic Automatic Differentiation

Probabilistic Automatic Differentiation Classical automatic differentiation computes derivatives of deterministic programs. A probabilistic program instead describes random variables, probability distributions, and stochastic transformations. The output is not a single value but a distribution, expectation, likelihood, or sampled trajectory. Probabilistic automatic differentiation studies how derivatives propagate through such systems. This includes: Problem Example differentiating expectations stochastic optimization differentiating sampling procedures variational inference differentiating probabilistic programs Bayesian learning differentiating Monte Carlo estimators...

Writes › Book › Auto Diff › Chapter 17. Numerical and Systems Concerns ›

Determinism and Reproducibility

Determinism and Reproducibility Automatic differentiation systems are often assumed to be deterministic. Given identical inputs, identical parameters, and identical code, many users expect identical gradients and identical optimization trajectories. In practice, this assumption frequently fails. Modern differentiable systems execute across: massively parallel hardware, distributed accelerators, asynchronous communication networks, mixed precision arithmetic, optimized compiler pipelines, stochastic training procedures. Small numerical differences accumulate over millions or billions of operations. Two executions of...

Writes › Book › Auto Diff › Chapter 15. Differentiable Systems Architecture ›

Differentiable Compilers

Differentiable Compilers A differentiable compiler is a compilation system that supports gradient propagation through compilation decisions, generated programs, or execution behavior. Instead of treating compilation as a purely symbolic transformation, the compiler becomes part of an optimization process. The core structure is: $$ P \mapsto C(P; \theta) \mapsto E \mapsto L $$ where: Symbol Meaning $P$ Program or computation graph $C$ Compiler transformation $\theta$ Compiler parameters or policies $E$ Executed...

Writes › Book › Auto Diff › Chapter 14. Scientific Computing Applications ›

Computational Finance

Computational Finance Computational finance uses numerical models to price contracts, measure risk, and optimize portfolios. Automatic differentiation is useful because most financial computations depend on many inputs: interest rates, volatilities, correlations, prices, credit spreads, liquidity parameters, and model calibration variables. The central object is usually a value function $$ V = F(x,\theta), $$ where $x$ is market data and $\theta$ is a model parameter vector. The derivative $$ \frac{\partial V}{\partial...

Writes › Book › Auto Diff › Chapter 13. Optimization and Machine Learning ›

Attention Mechanisms

Attention Mechanisms Attention is a sequence operation that lets each position read information from other positions. Instead of compressing the whole past into one recurrent hidden state, attention builds a context-dependent representation by comparing queries with keys and mixing values. Given an input sequence represented as a matrix $$ X \in \mathbb{R}^{T \times d_{\text{model}}}, $$ we construct three projections: $$ Q = XW_Q, \qquad K = XW_K, \qquad V =...

Writes › Book › Auto Diff › Chapter 12. AD in Modern Programming Languages ›

AD in Rust

AD in Rust Rust is an attractive language for automatic differentiation because it combines low-level performance with strong static guarantees. It gives the programmer control over memory layout and allocation, while the type system tracks ownership, borrowing, lifetimes, mutation, and thread safety. These properties are useful for building AD systems that are fast, safe, and explicit about state. Rust also makes AD harder in some places. Operator overloading is available...

Writes › Book › Auto Diff › Chapter 11. Compiler and Runtime Design ›

Tracing Systems

Tracing Systems Tracing is an implementation strategy where an AD system observes a program while it runs and records the operations that occur. The result of tracing is a trace: a simplified program, tape, graph, or intermediate representation that represents one execution of the original program. A normal function may look like this: def f(x): y = x * x z = sin(y) return z When executed with trace-aware values,...

Writes › Book › Auto Diff › Chapter 10. Matrix and Tensor Differentiation ›

Eigenvalue Problems

Eigenvalue Problems Eigenvalue problems are fundamental in numerical analysis, optimization, physics, graph methods, control theory, and machine learning. They are also among the most subtle operations in automatic differentiation. The main difficulty is that eigenvectors are not stable objects. Small perturbations in the matrix can produce large changes in eigenvectors when eigenvalues are close or repeated. The derivative formulas reveal this instability directly. Eigenvalues and Eigenvectors For a square matrix...

Writes › Book › Auto Diff › Chapter 9. Differentiation of Control Flow ›

Non-Smooth Programs

Non-Smooth Programs A non-smooth program contains operations where the derivative is undefined, discontinuous, set-valued, or unstable under small perturbations. These programs arise naturally in optimization, machine learning, geometry, combinatorics, simulation, and systems code. Examples include: absolute value maximum and minimum clipping sorting thresholding indexing quantization branching discrete sampling collision detection contact mechanics Automatic differentiation can still execute on such programs, but the returned gradients require careful interpretation. Smoothness and Classical...

Writes › Book › Auto Diff › Chapter 8. Higher-Order Differentiation ›

Taylor Mode AD

Taylor Mode AD Taylor mode automatic differentiation computes derivatives by propagating truncated Taylor series through a program. Instead of tracking only values and first derivatives, Taylor mode tracks entire local polynomial expansions. For a scalar function $$ f(x), $$ expanded around point $x_0$, $$ f(x_0 + h) = f(x_0) + f'(x_0)h + \frac{f''(x_0)}{2!}h^2 + \frac{f^{(3)}(x_0)}{3!}h^3 + \cdots $$ Taylor mode computes these coefficients automatically. This gives direct access to higher-order...

Writes › Book › Auto Diff › Chapter 7. Dual Numbers and Algebraic Structures ›

Differential Algebras

Differential Algebras Dual numbers and hyper-dual numbers are special cases of a broader algebraic structure called a differential algebra. This framework abstracts differentiation away from specific coordinate formulas and treats derivatives as algebraic operators acting on computational expressions. Automatic differentiation can be understood as evaluation inside differential algebras. This viewpoint unifies: dual numbers truncated polynomial systems higher-order differentiation symbolic differentiation tangent propagation under a common algebraic structure. Algebra and Differentiation...

Writes › Book › Auto Diff › Chapter 6. Reverse Mode Automatic Differentiation ›

Wengert Lists

Wengert Lists A Wengert list is a linear representation of a computation in which every intermediate result is assigned to a unique variable. It is one of the earliest and most influential formulations of automatic differentiation. The central idea is simple: decompose a computation into elementary operations; assign each intermediate result a new identifier; record operations in execution order. This transforms a program into a sequence of explicit data dependencies....

Writes › Book › Auto Diff › Chapter 5. Forward Mode Automatic Differentiation ›

Higher-Dimensional Tangent Spaces

Higher-Dimensional Tangent Spaces So far, forward mode has propagated a single tangent direction: $$ x \mapsto (x, \dot{x}), $$ where $$ \dot{x} \in \mathbb{R}. $$ This computes one directional derivative: $$ J_f(x)v. $$ However, many applications require several directional derivatives simultaneously. Instead of propagating one tangent scalar, we can propagate an entire tangent vector space. Each variable becomes $$ x \mapsto (x, \dot{x}), \qquad \dot{x} \in \mathbb{R}^k. $$ Now every...

Writes › Book › Auto Diff › Chapter 4. Core Theory of Automatic Differentiation ›

Computational Complexity

Automatic differentiation is fundamentally a computational technique. Its practical importance comes from the fact that derivatives can often be computed with asymptotic cost close to the original function evaluation. This section studies the computational complexity of automatic differentiation: operation count memory usage asymptotic scaling dimensional dependence graph structure effects The central result is that derivative computation is usually much cheaper than symbolic differentiation and much more accurate than numerical differentiation....

Writes › Book › Auto Diff › Chapter 3. Programs as Mathematical Objects ›

Memory and State

Memory and State Automatic differentiation operates on computations, but computations execute inside a memory model. Variables occupy storage locations, arrays are mutated, buffers are reused, and values may outlive the operations that created them. Differentiation therefore depends not only on algebraic structure, but also on program state. A simple mathematical expression: $$ y = x^2 + 1 $$ contains no explicit memory model. A program implementation does. tmp = x...

Writes › Book › Auto Diff › Chapter 2. Mathematical Foundations ›

Linearization

Linearization Linearization is the operation of replacing a nonlinear function by its best local linear approximation at a chosen point. Automatic differentiation can be understood as a machine for computing this local linear approximation, or products involving it, for programs. Let $$ f : \mathbb{R}^n \to \mathbb{R}^m $$ At a point $x$, the value of the function is $$ y = f(x) $$ If the input is perturbed by a...

Writes › Book › Auto Diff › Chapter 1. Introduction ›

Historical Development

Historical Development Automatic differentiation developed from a simple observation: a numerical computation already contains the structure needed to compute its derivative. The program evaluates elementary operations in a definite order. If each elementary operation has a derivative rule, then the chain rule can be applied along the same order, either forward or backward. This idea appeared before modern machine learning, before tensor libraries, and before contemporary compiler infrastructure. Its roots...

Writes › Book › Auto Diff › Chapter 21. Major AD Systems ›

JAX

JAX JAX is an automatic differentiation and array programming system for Python. It combines NumPy-like syntax with composable program transformations. Its core transformations include differentiation, vectorization, just-in-time compilation, and parallelization. The important design point is that JAX treats numerical Python functions as transformable objects. A function can be differentiated with grad , batched with vmap , compiled with jit , and distributed with pmap or related sharding APIs. Functional Numerical...

Writes › Book › Auto Diff › Appendix ›

JAX

JAX JAX is an automatic differentiation and array programming system for Python. It combines NumPy-like syntax with composable program transformations. Its core transformations include differentiation, vectorization, just-in-time compilation, and parallelization. The important design point is that JAX treats numerical Python functions as transformable objects. A function can be differentiated with grad , batched with vmap , compiled with jit , and distributed with pmap or related sharding APIs. Functional Numerical...

Writes › Book › Auto Diff › Chapter 20. Building an AD Engine ›

Memory Management

Memory Management Memory management is the main systems problem in reverse mode automatic differentiation. The derivative rules are usually small. The hard part is deciding which primal values, intermediate tensors, gradients, graph nodes, and tape records must stay alive until the backward pass finishes. A minimal engine can ignore most of this at first. It can allocate every intermediate value and keep everything until Backward returns. That design is correct,...

Writes › Book › Auto Diff › Chapter 19. Theory and Foundations ›

Lambda Calculus and AD

Lambda Calculus and AD Automatic differentiation becomes substantially more difficult once programs contain higher-order functions. A first-order numerical program computes values: $$ f : \mathbb{R}^n \to \mathbb{R}^m. $$ A higher-order program computes functions, consumes functions, or returns functions: $$ F : (X \to Y) \to Z. $$ Ordinary AD systems built around tapes and computational graphs work well for first-order programs, but higher-order functions introduce semantic complications: closures, lexical environments,...

Writes › Book › Auto Diff › Chapter 18. Advanced Topics ›

Neural ODEs

Neural ODEs Classical neural networks apply a finite sequence of transformations: $$ h_{k+1} = f_k(h_k,\theta_k). $$ Depth corresponds to the number of layers. A neural ordinary differential equation (Neural ODE) replaces this discrete stack with continuous dynamics: $$ \frac{dz(t)}{dt} = f_\theta(z(t), t). $$ Instead of evaluating a finite composition, the model integrates a differential equation from an initial state to a final time. The output is $$ z(t_1), $$ obtained...

Writes › Book › Auto Diff › Chapter 17. Numerical and Systems Concerns ›

Gradient Vanishing and Explosion

Gradient Vanishing and Explosion Gradient-based optimization relies on propagating derivative information through many layers, time steps, or computational transformations. In deep systems, these gradients often become extremely small or extremely large during reverse propagation. These two pathologies are known as: vanishing gradients, exploding gradients. They are among the most important stability problems in automatic differentiation and deep learning. The phenomenon is fundamentally mathematical. Reverse mode propagates products of Jacobians backward...

Writes › Book › Auto Diff › Chapter 15. Differentiable Systems Architecture ›

Differentiable Search and Retrieval

Differentiable Search and Retrieval Differentiable search and retrieval systems integrate information access into gradient-based learning. Instead of treating retrieval as an external symbolic operation, the retrieval process becomes part of the computational graph. The system computes: $$ q \mapsto R(q) \mapsto y \mapsto L $$ where: Symbol Meaning $q$ Query representation $R(q)$ Retrieved information $y$ Downstream output $L$ Objective function Automatic differentiation propagates gradients backward through retrieval behavior, allowing the...

Writes › Book › Auto Diff › Chapter 14. Scientific Computing Applications ›

Molecular Simulation

Molecular Simulation Molecular simulation models the behavior of atoms and molecules using physical interaction laws. Automatic differentiation is important because many molecular methods require gradients of energy functions with respect to particle coordinates, force-field parameters, or quantum variables. A molecular system is typically described by particle positions $$ x = (x_1,\ldots,x_N), $$ where each particle position $$ x_i \in \mathbb{R}^3. $$ The system energy is $$ E(x,\theta), $$ where $\theta$...

Writes › Book › Auto Diff › Chapter 13. Optimization and Machine Learning ›

Sequence Models

Sequence Models Sequence models process ordered data. The input is not one independent vector, but a series: $$ x_1, x_2, \ldots, x_T. $$ Examples include text tokens, audio frames, video frames, time-series samples, event logs, trajectories, and program tokens. The model must represent both local content and position-dependent context. A sequence model usually computes hidden states: $$ h_t = f_\theta(x_t, h_{t-1}) $$ or contextual states: $$ h_t = f_\theta(x_1,\ldots,x_T,t). $$...

Writes › Book › Auto Diff › Chapter 12. AD in Modern Programming Languages ›

AD in Python

AD in Python Python became the dominant language for modern machine learning and differentiable computing because it combines a simple programming model with access to high-performance native libraries. Most Python automatic differentiation systems therefore follow a hybrid architecture: Layer Role Python frontend User-facing model and control logic Tensor runtime Dense array execution AD engine Gradient propagation Native backend CPU/GPU kernels in C/C++/CUDA Compiler subsystem Graph optimization and lowering Python itself...

Writes › Book › Auto Diff › Chapter 11. Compiler and Runtime Design ›

Graph IRs

Graph IRs A graph intermediate representation models a program as nodes and edges. Nodes represent operations or values. Edges represent data dependencies. For automatic differentiation, this form is natural because the chain rule also follows a dependency graph. A simple function def f(x): y = x * x z = sin(y) return z can be represented as: x -> mul -> y -> sin -> z The primal graph computes...

Writes › Book › Auto Diff › Chapter 10. Matrix and Tensor Differentiation ›

Differentiating Factorizations

Differentiating Factorizations Matrix factorizations rewrite a matrix into structured factors. They are used because the factors make later computations cheaper, more stable, or easier to interpret. In automatic differentiation, factorizations are delicate primitives because their outputs satisfy constraints. A generic matrix has free entries. A factorization output usually does not. Orthogonal matrices, triangular matrices, diagonal singular-value matrices, and permutation matrices all live in constrained spaces. The derivative must respect those...

Writes › Book › Auto Diff › Chapter 9. Differentiation of Control Flow ›

Piecewise Differentiability

Piecewise Differentiability A piecewise differentiable function is built from several differentiable pieces joined by boundaries. Each piece has an ordinary derivative inside its region. At the boundaries, the derivative may agree, disagree, or fail to exist. Conditionals, loops with data-dependent exits, clipping, thresholding, sorting, indexing, activation functions, and many numerical guards all produce piecewise differentiable programs. A typical example is: def f(x): if x < 0: return -x else: return...

Writes › Book › Auto Diff › Chapter 8. Higher-Order Differentiation ›

Nested AD

Nested AD Nested automatic differentiation means applying automatic differentiation inside another automatic differentiation computation. Conceptually, this means differentiating derivative computations. Examples include: Expression Meaning $\nabla(\nabla f)$ Hessian $D(Df)$ second directional derivative $\nabla(Df[v])$ Hessian-vector product $D(\nabla f)$ Jacobian of gradient $\nabla(\text{optimization step})$ meta-gradient Nested AD is essential for higher-order derivatives, implicit differentiation, meta-learning, differentiable optimization, and differentiable programming systems. The mathematics is straightforward. The implementation is subtle. First-Order AD as a...

Writes › Book › Auto Diff › Chapter 7. Dual Numbers and Algebraic Structures ›

Hyper-Dual Numbers

Hyper-Dual Numbers Dual numbers compute first derivatives exactly. Truncated polynomial algebras extend this to higher-order derivatives, but practical higher-order differentiation introduces an important problem: extracting second derivatives accurately without symbolic expansion or numerical cancellation. Hyper-dual numbers solve this problem by introducing multiple nilpotent infinitesimal directions whose mixed products survive. They provide an exact algebraic mechanism for computing: second derivatives mixed partial derivatives Hessians without finite differences and without truncation error....

Writes › Book › Auto Diff › Chapter 6. Reverse Mode Automatic Differentiation ›

Tape-Based Systems

Tape-Based Systems Most reverse mode automatic differentiation systems require a mechanism for recording the forward computation so that the reverse pass can later traverse it backward. This recorded structure is traditionally called a tape. The tape stores enough information to reconstruct local derivative relationships during reverse accumulation. Conceptually, the tape is an execution log of differentiable operations. Why Reverse Mode Needs a Tape Forward mode propagates tangents immediately during execution....

Writes › Book › Auto Diff › Chapter 5. Forward Mode Automatic Differentiation ›

Complexity Analysis

Complexity Analysis Forward mode automatic differentiation has a simple cost model. It evaluates the original program and, at the same time, evaluates the tangent program. Each primitive operation computes its primal result and its derivative contribution. For one tangent direction, the runtime is usually within a small constant factor of the original function evaluation. If the primal computation costs $$ C_f, $$ then one forward-mode derivative pass usually costs $$...

Writes › Book › Auto Diff › Chapter 4. Core Theory of Automatic Differentiation ›

Mixed-Mode Differentiation

Mixed-mode differentiation combines forward accumulation and reverse accumulation in the same derivative computation. It is used when neither pure forward mode nor pure reverse mode gives the best cost model. Forward mode computes Jacobian-vector products: $$ J_f(x)v $$ Reverse mode computes vector-Jacobian products: $$ u^T J_f(x) $$ Mixed mode composes these two operations to compute more structured derivatives efficiently. Why Mix Modes? For a function: $$ f:\mathbb{R}^n \to \mathbb{R}^m $$...

Writes › Book › Auto Diff › Chapter 3. Programs as Mathematical Objects ›

Loops and Recurrence Relations

Loops and Recurrence Relations Loops express repeated computation. Recurrence relations express the same idea mathematically: each state is computed from one or more earlier states. A loop such as h = h0 for t in range(n): h = tanh(w * h + b) y = h corresponds to the recurrence $$ h_{t+1} = \tanh(w h_t + b), \qquad y = h_n. $$ Automatic differentiation treats this as a sequence of...

Writes › Book › Auto Diff › Chapter 2. Mathematical Foundations ›

Computational Graphs

Computational Graphs A computational graph represents a calculation as nodes and edges. Nodes represent operations or values. Edges represent data dependencies. Automatic differentiation uses this graph structure to decide how derivative information should move through a computation. A simple program, a = x * y b = sin(a) c = b + x can be seen as the graph x ─┬─> multiply ─> a ─> sin ─> b ─┐ │...

Writes › Book › Auto Diff › Chapter 1. Introduction ›

Accuracy, Complexity, and Stability

Accuracy, Complexity, and Stability Derivative computation is not only a mathematical problem. It is also a numerical and systems problem. A derivative method must answer three questions simultaneously: Is the derivative accurate? How expensive is it? Is the computation numerically stable? These questions determine whether a differentiation method is practical for scientific computing, optimization, and machine learning. Automatic differentiation became important because it achieves a useful balance across all three...

Writes › Book › Auto Diff › Chapter 21. Major AD Systems ›

PyTorch Autograd

PyTorch Autograd PyTorch Autograd is a dynamic reverse-mode automatic differentiation system. It records tensor operations as they execute, builds a computation graph at runtime, and then traverses that graph backward to compute gradients. Its defining feature is dynamic graph construction. The graph follows the actual Python execution path taken by the program. This makes PyTorch convenient for models with conditionals, loops, recursion, variable-length inputs, and debugging workflows. Dynamic Computation Graphs...

Writes › Book › Auto Diff › Appendix ›

PyTorch Autograd

PyTorch Autograd PyTorch Autograd is a dynamic reverse-mode automatic differentiation system. It records tensor operations as they execute, builds a computation graph at runtime, and then traverses that graph backward to compute gradients. Its defining feature is dynamic graph construction. The graph follows the actual Python execution path taken by the program. This makes PyTorch convenient for models with conditionals, loops, recursion, variable-length inputs, and debugging workflows. Dynamic Computation Graphs...

Writes › Book › Auto Diff › Chapter 20. Building an AD Engine ›

Tape Design

Tape Design A tape is an append-only record of the operations executed during the forward pass. Reverse mode uses the tape to replay derivative rules backward. A graph stores nodes and edges as linked objects. A tape stores instructions in execution order. forward pass: input -> op 0 -> op 1 -> op 2 -> output tape: [op 0, op 1, op 2] backward pass: op 2 -> op 1...

Writes › Book › Auto Diff › Chapter 19. Theory and Foundations ›

Differential Categories

Differential Categories Cartesian differential categories model differentiation in categories with products. Differential categories generalize this idea further by shifting attention from cartesian structure to linear structure itself. The key observation is that differentiation is fundamentally linear. A derivative transforms nonlinear behavior into linear behavior: $$ f(x + \Delta x) \approx f(x) + Df(x)\Delta x. $$ This linear approximation is the essential object. Differential categories formalize: linear maps, derivative operators, resource-sensitive...

Writes › Book › Auto Diff › Chapter 18. Advanced Topics ›

Continuous-Time Adjoint Methods

Continuous-Time Adjoint Methods Many systems evolve continuously over time rather than through discrete layers. A state variable changes according to a differential equation: $$ \frac{dz(t)}{dt} = f(z(t), \theta, t). $$ The output is not a single value but an entire trajectory $$ z(t), \quad t \in [t_0, t_1]. $$ If a loss depends on the final state or on the full trajectory, we need derivatives with respect to parameters θ...

Writes › Book › Auto Diff › Chapter 17. Numerical and Systems Concerns ›

Memory Explosion

Memory Explosion Reverse-mode automatic differentiation trades computation for memory. To compute gradients efficiently, the backward pass requires access to intermediate values produced during the forward pass. For large computational graphs, storing these intermediates can dominate total system cost. This phenomenon is known as memory explosion. It is one of the central engineering constraints in modern automatic differentiation systems. Memory pressure limits: model size, batch size, sequence length, simulation resolution, graph...

Writes › Book › Auto Diff › Chapter 15. Differentiable Systems Architecture ›

Differentiable Physics Engines

Differentiable Physics Engines A differentiable physics engine computes gradients of physical simulation outputs with respect to inputs, parameters, or control signals. Instead of treating simulation as a terminal forward process, the simulator becomes part of the computational graph. The system computes: $$ x_{t+1} = f(x_t, u_t, \theta) $$ where: Symbol Meaning $x_t$ System state $u_t$ Control input $\theta$ Physical parameters $f$ Physics transition operator A loss over trajectories: $$ L(x_0,...

Writes › Book › Auto Diff › Chapter 14. Scientific Computing Applications ›

Computational Fluid Dynamics

Computational Fluid Dynamics Computational fluid dynamics studies fluid motion by solving discretized forms of the governing equations. Automatic differentiation enters CFD when we want gradients of simulation outputs with respect to geometry, boundary conditions, material parameters, control inputs, or model parameters. A CFD solver is usually a large numerical program: $$ \text{geometry} \to \text{mesh} \to \text{discrete equations} \to \text{linear and nonlinear solves} \to \text{flow field} \to \text{objective}. $$ The objective...

Writes › Book › Auto Diff › Chapter 13. Optimization and Machine Learning ›

Neural Network Training

Neural Network Training Neural network training is the repeated application of three operations: evaluate a model, differentiate a scalar loss, and update parameters. Automatic differentiation supplies the middle operation. The training system supplies data movement, batching, numerical policy, optimizer state, checkpointing, logging, and distributed execution. A minimal training step is: batch = next_batch(data) pred = model(batch.x) loss = loss_fn(pred, batch.y) grad = gradient(loss, model.parameters) optimizer.update(model.parameters, grad) This loop looks simple,...

Writes › Book › Auto Diff › Chapter 12. AD in Modern Programming Languages ›

AD in C and C++

AD in C and C++ C and C++ are important targets for automatic differentiation because much scientific, engineering, graphics, finance, and machine learning infrastructure is written in these languages. They provide direct control over memory layout, compilation, vectorization, and hardware-specific optimization. They also make AD difficult because programs can contain pointer aliasing, mutation, templates, manual memory management, macros, and calls into external libraries. In C and C++, automatic differentiation is...

Writes › Book › Auto Diff › Chapter 11. Compiler and Runtime Design ›

SSA Form

SSA Form Static single assignment form, or SSA, is an intermediate representation where each variable is assigned exactly once. A source program may reuse the same variable name many times: def f(x): x = x * x x = sin(x) return x In SSA, each assignment receives a fresh name: x0 = input x1 = x0 * x0 x2 = sin(x1) return x2 This small change has a large effect....

Writes › Book › Auto Diff › Chapter 10. Matrix and Tensor Differentiation ›

Linear Algebra Primitives

Linear Algebra Primitives Linear algebra primitives are tensor operations with algebraic structure: matrix multiplication, triangular solves, factorizations, inverses, determinants, norms, and spectral operations. They are central to automatic differentiation because many numerical programs are built from these operations rather than from scalar arithmetic alone. An AD system can differentiate these primitives in two ways. It can decompose them into smaller operations and apply generic AD, or it can attach a...

Writes › Book › Auto Diff › Chapter 9. Differentiation of Control Flow ›

Dynamic Graphs

Dynamic Graphs A dynamic graph is a computation graph built while the program runs. Its structure depends on ordinary runtime values: branches, loop counts, recursive calls, tensor shapes, data structures, and sometimes input data itself. In a static graph system, the graph is mostly known before execution. In a dynamic graph system, the graph is the execution. This matters for automatic differentiation because reverse mode needs to know which operations...

Writes › Book › Auto Diff › Chapter 8. Higher-Order Differentiation ›

Higher-Order Reverse Mode

Higher-Order Reverse Mode Reverse mode is efficient for scalar-output functions because it propagates one adjoint backward through the computation and produces a full gradient. For $$ f : \mathbb{R}^n \to \mathbb{R}, $$ one reverse pass computes $$ \nabla f(x) $$ at a cost comparable to a small constant multiple of evaluating $f$. Higher-order reverse mode asks for derivatives of reverse-mode derivative computations. The simplest case is differentiating the gradient: $$...

Writes › Book › Auto Diff › Chapter 7. Dual Numbers and Algebraic Structures ›

Truncated Polynomial Algebras

Truncated Polynomial Algebras Dual numbers capture first-order derivatives because the infinitesimal element satisfies $$ \varepsilon^2 = 0. $$ To compute higher-order derivatives, we extend this idea by allowing higher powers to survive temporarily before truncation. The resulting structures are called truncated polynomial algebras. They generalize dual numbers from first-order infinitesimals to finite-order infinitesimal expansions. From Dual Numbers to Higher Orders Recall the dual-number algebra: $$ \mathbb{R}[\varepsilon]/(\varepsilon^2). $$ Every element has...

Writes › Book › Auto Diff › Chapter 6. Reverse Mode Automatic Differentiation ›

Reverse Accumulation Algorithms

Reverse Accumulation Algorithms Reverse accumulation is the operational core of reverse mode automatic differentiation. The forward pass evaluates a program and records dependency information. The reverse pass traverses that recorded structure backward and accumulates adjoint contributions into each variable. The word accumulation is important. A variable may influence the final output through many downstream paths. Reverse mode computes the total derivative by summing contributions from all such paths. For a...

Writes › Book › Auto Diff › Chapter 5. Forward Mode Automatic Differentiation ›

Jacobian-Vector Products

Jacobian-Vector Products The natural output of forward mode automatic differentiation is a Jacobian-vector product. Instead of constructing the full Jacobian matrix explicitly, forward mode computes how a perturbation vector propagates through a function. For a function $$ f : \mathbb{R}^n \to \mathbb{R}^m, $$ the Jacobian at $x$ is $$ J_f(x) = \begin{bmatrix} \frac{\partial f_1}{\partial x_1} & \cdots & \frac{\partial f_1}{\partial x_n} \ \vdots & \ddots & \vdots \ \frac{\partial f_m}{\partial...

Writes › Book › Auto Diff › Chapter 4. Core Theory of Automatic Differentiation ›

Reverse Accumulation

Reverse accumulation is the reverse-mode form of automatic differentiation. It propagates derivative information backward from outputs to inputs. Forward mode asks: $$ \text{How does each intermediate value change when the input changes?} $$ Reverse mode asks: $$ \text{How does the final output change when each intermediate value changes?} $$ The second question is the one needed for gradients of scalar-output functions. The Adjoint Value Reverse mode attaches an adjoint to...

Writes › Book › Auto Diff › Chapter 3. Programs as Mathematical Objects ›

Control Flow

Control Flow Control flow determines which operations a program executes. Straight-line programs have a fixed sequence of operations, but ordinary programs contain branches, loops, recursion, early returns, and exceptions. Automatic differentiation must account for this structure without losing the basic rule: derivatives propagate through the operations that actually determine the output. A small example already shows the issue: if x > 0: y = x * x else: y =...

Writes › Book › Auto Diff › Chapter 2. Mathematical Foundations ›

Chain Rule as Composition Algebra

Chain Rule as Composition Algebra The chain rule is the central theorem behind automatic differentiation. Every useful AD algorithm is a disciplined way of applying the chain rule to a program. A program is built from smaller operations. Each operation maps input values to output values. When one operation feeds another, the corresponding mathematical functions are composed. AD differentiates the whole computation by differentiating each small mapping and composing their...

Writes › Book › Auto Diff › Chapter 1. Introduction ›

Automatic Differentiation

Automatic Differentiation Automatic differentiation computes derivatives by applying the chain rule to the operations of a program. The input is ordinary code that computes a value. The output is code, data, or runtime behavior that also computes derivative information. AD sits between numerical differentiation and symbolic differentiation. Numerical differentiation estimates derivatives from repeated function evaluations. Symbolic differentiation rewrites formulas into derivative formulas. Automatic differentiation follows the actual computation and propagates...

Writes › Book › Auto Diff › Appendix ›

TensorFlow Autograd

TensorFlow Autograd TensorFlow Autograd refers to TensorFlow’s automatic differentiation system, mainly exposed through tf.GradientTape . It is a reverse-mode AD system designed for tensor programs, neural network training, and differentiable numerical computation. TensorFlow began with static computational graphs. A user built a graph first, then executed it inside a runtime. Later TensorFlow 2 made eager execution the default. The modern interface records operations dynamically during execution, then differentiates the recorded...

Writes › Book › Auto Diff › Chapter 21. Major AD Systems ›

TensorFlow Autograd

TensorFlow Autograd TensorFlow Autograd refers to TensorFlow’s automatic differentiation system, mainly exposed through tf.GradientTape . It is a reverse-mode AD system designed for tensor programs, neural network training, and differentiable numerical computation. TensorFlow began with static computational graphs. A user built a graph first, then executed it inside a runtime. Later TensorFlow 2 made eager execution the default. The modern interface records operations dynamically during execution, then differentiates the recorded...

Writes › Book › Auto Diff › Chapter 20. Building an AD Engine ›

Graph Representation

Graph Representation A graph representation makes the structure of a differentiated computation explicit. In reverse mode, this structure is required because the backward pass must know which intermediate values depend on which earlier values. In compiler-based systems, the graph may also serve as an optimization target. A computation graph is a directed graph whose nodes represent values or operations, and whose edges represent data dependencies. For an expression such as:...

Writes › Book › Auto Diff › Chapter 19. Theory and Foundations ›

Categorical Semantics

Categorical Semantics Algebraic semantics describes differentiation through derivations, tangent maps, and linear structure. Categorical semantics goes further. It studies differentiation as a structural property of composition itself. Category theory is useful here because automatic differentiation is fundamentally compositional. Programs are built from smaller programs. Derivatives are built from smaller derivatives. The chain rule is a law about composition. The central question becomes: What categorical structure is required for differentiation to...

Writes › Book › Auto Diff › Chapter 18. Advanced Topics ›

Differentiable Optimization Layers

Differentiable Optimization Layers An optimization layer is a program component whose output is the solution of an optimization problem. Instead of computing $$ z = f(x) $$ by a fixed formula, it computes $$ z^*(\theta) = \arg\min_z L(z,\theta). $$ The parameters θ may come from a neural network, a simulator, a control system, or a statistical model. The output z* is then passed to another computation, often a scalar loss....

Writes › Book › Auto Diff › Chapter 17. Numerical and Systems Concerns ›

Overflow and Underflow

Overflow and Underflow Floating point systems represent numbers within a finite range. When a computed value exceeds the largest representable magnitude, overflow occurs. When a value becomes too small to represent accurately, underflow occurs. Automatic differentiation inherits both phenomena from the primal computation and may amplify them during derivative propagation. Overflow and underflow are not rare edge cases. They appear routinely in: deep neural networks, exponential models, probabilistic inference, scientific...

Writes › Book › Auto Diff › Chapter 15. Differentiable Systems Architecture ›

Differentiable Rendering

Differentiable Rendering Differentiable rendering is the process of computing derivatives of rendered images with respect to scene parameters. A renderer becomes part of the computational graph rather than a terminal visualization step. The central mapping is: $$ \theta \mapsto I $$ where: Symbol Meaning $\theta$ Scene parameters $I$ Rendered image The parameters may include: geometry camera pose material properties lighting texture maps volumetric density skeletal pose simulation state A loss...

Writes › Book › Auto Diff › Chapter 14. Scientific Computing Applications ›

Inverse Problems

Inverse Problems An inverse problem asks for causes from effects. A forward model predicts observations from parameters. An inverse model tries to recover parameters from observations. The usual form is $$ y = F(\theta), $$ where $\theta$ is an unknown parameter vector and $y$ is the model output. In practice, we observe noisy data $$ z \approx F(\theta). $$ The inverse problem is to estimate $\theta$ from $z$. Examples include...

Writes › Book › Auto Diff › Chapter 13. Optimization and Machine Learning ›

Backpropagation

Backpropagation Backpropagation is reverse mode automatic differentiation applied to neural networks. In most machine learning writing, the term refers to the whole training procedure: run a forward pass, compute a loss, propagate gradients backward, then update parameters. More precisely, backpropagation is the derivative computation step. A neural network is a composition of functions: $$ f_\theta(x) = f_k( f_{k-1}( \cdots f_2(f_1(x)) )). $$ Each layer produces an intermediate activation: $$ a_0...

Writes › Book › Auto Diff › Chapter 12. AD in Modern Programming Languages ›

Differentiable Programming

Differentiable Programming Differentiable programming treats differentiation as a general programming-language feature. A program can contain numerical kernels, control flow, data structures, solvers, simulations, and model code. If the program denotes a differentiable computation, the system should be able to compute derivatives of that program. This is broader than neural network training. A differentiable program may include a physics simulator, a renderer, a database query, an optimizer, or a probabilistic model....

Writes › Book › Auto Diff › Chapter 11. Compiler and Runtime Design ›

Intermediate Representations

Intermediate Representations An intermediate representation, or IR, is the internal program form used by a compiler or AD system after parsing and before final code generation. For automatic differentiation, the IR is where the system decides what the program means. It is also where differentiation becomes mechanical. A source program may contain syntax such as: def f(x): y = x * x z = sin(y) return z An AD compiler...

Writes › Book › Auto Diff › Chapter 10. Matrix and Tensor Differentiation ›

Broadcasting Semantics

Broadcasting Semantics Broadcasting is the rule system that allows tensor operations between arrays of different shapes without explicitly materializing expanded copies. It is one of the most important structural features in modern tensor systems. It is also one of the most common sources of gradient bugs. From a mathematical perspective, broadcasting defines an implicit linear replication operator. From a systems perspective, broadcasting defines a virtual tensor view with repeated values...

Writes › Book › Auto Diff › Chapter 9. Differentiation of Control Flow ›

Recursion

Recursion Recursion is control flow where a function calls itself. In automatic differentiation, recursion behaves like a loop with a call stack. Each recursive call contributes one layer to the computation, and differentiation applies the chain rule across the call tree. A simple recursive function has the form: def f(x, n): if n == 0: return x return g(f(x, n - 1)) This denotes repeated composition: $$ f(x,n) = g^{(n)}(x)...

Writes › Book › Auto Diff › Chapter 8. Higher-Order Differentiation ›

Hessian-Vector Products

Hessian-Vector Products A Hessian-vector product computes $$ H_f(x)v = \nabla^2 f(x)v, $$ where $$ f : \mathbb{R}^n \to \mathbb{R}, $$ and $$ v \in \mathbb{R}^n. $$ This operation applies the Hessian as a linear operator to a vector without explicitly constructing the full Hessian matrix. For large systems, this distinction is fundamental. A dense Hessian requires $O(n^2)$ storage. A Hessian-vector product requires only $O(n)$ storage for the input and output...

Writes › Book › Auto Diff › Chapter 7. Dual Numbers and Algebraic Structures ›

Geometric Interpretation

Geometric Interpretation Dual numbers provide an algebraic mechanism for differentiation, but they also have a precise geometric meaning. A dual number represents a point together with an infinitesimal displacement. Forward mode automatic differentiation can therefore be interpreted as the propagation of tangent vectors through a computation. This geometric viewpoint explains why the chain rule appears naturally, why derivatives are linear maps, and why forward mode computes directional derivatives. Points and...

Writes › Book › Auto Diff › Chapter 6. Reverse Mode Automatic Differentiation ›

Vector-Jacobian Products

Vector-Jacobian Products Reverse mode automatic differentiation fundamentally computes vector-Jacobian products. The gradient of a scalar function is a special case of this more general operation. Consider a differentiable function $$ f : \mathbb{R}^n \to \mathbb{R}^m. $$ Its Jacobian matrix is $$ J_f(x) = \frac{\partial f}{\partial x} = \begin{bmatrix} \frac{\partial f_1}{\partial x_1} & \cdots & \frac{\partial f_1}{\partial x_n} \ \vdots & \ddots & \vdots \ \frac{\partial f_m}{\partial x_1} & \cdots &...

Writes › Book › Auto Diff › Chapter 5. Forward Mode Automatic Differentiation ›

Forward Evaluation Rules

Forward Evaluation Rules Forward mode automatic differentiation works by replacing each primitive operation with an extended operation on pairs: $$ x \mapsto (x, \dot{x}) $$ The first component is the primal value. The second component is the tangent value. The evaluation rule for each operation must compute both. For a primitive operation $$ z = \phi(x_1, x_2, \ldots, x_k), $$ the forward rule is $$ \dot{z} = \sum_{i=1}^{k} \frac{\partial \phi}{\partial...

Writes › Book › Auto Diff › Chapter 4. Core Theory of Automatic Differentiation ›

Forward Accumulation

Forward accumulation is the forward-mode form of automatic differentiation. It propagates derivative information in the same order as ordinary program evaluation. Each intermediate value carries two pieces of information: Component Meaning Primal the ordinary value computed by the program Tangent the derivative of that value with respect to a chosen input direction If a program computes: $$ y=f(x) $$ then forward accumulation computes both: $$ y $$ and: $$ \dot...

Writes › Book › Auto Diff › Chapter 3. Programs as Mathematical Objects ›

Dependency Graphs

Dependency Graphs A dependency graph describes how values in a computation depend on earlier values. Automatic differentiation operates on these dependencies. For a straight-line program, v1 = x1 v2 = x2 v3 = v1 * v2 v4 = sin(v3) v5 = v4 + v1 y = v5 the dependency structure is: v1 ─┬─> v3 ─> v4 ─┐ │ ├─> v5 v2 ─┘ │ v1 ───────────────┘ Each node represents a variable...

Writes › Book › Auto Diff › Chapter 2. Mathematical Foundations ›

Jacobians and Hessians

Jacobians and Hessians The gradient is enough when a function has many inputs and one scalar output. More general programs need more general derivative objects. Two of the most important are the Jacobian and the Hessian. The Jacobian stores first-order derivatives of a vector-valued function. The Hessian stores second-order derivatives of a scalar-valued function. Both can be large. In automatic differentiation, we often avoid constructing them explicitly. Instead, we compute...

Writes › Book › Auto Diff › Chapter 1. Introduction ›

Symbolic Differentiation

Symbolic Differentiation Symbolic differentiation computes derivatives by manipulating expressions. The input is a formula. The output is another formula. For example, given $$ f(x) = x^2 + \sin x, $$ symbolic differentiation produces $$ f'(x) = 2x + \cos x. $$ This is the form of differentiation taught in calculus courses. It is exact over the algebraic expression being manipulated. It uses rules such as the sum rule, product rule,...

Writes › Book › Auto Diff › Chapter 21. Major AD Systems ›

Tapenade

Tapenade Tapenade is a source-transformation automatic differentiation system developed at INRIA. Like ADIFOR, it takes an existing program and produces a new differentiated program. Its main targets are Fortran and C, with strong emphasis on scientific and engineering codes. Tapenade is historically important because it pushed source-transformation AD beyond simple forward propagation. It supports both tangent mode and adjoint mode, making it useful for sensitivity analysis, inverse problems, and large...

Writes › Book › Auto Diff › Appendix ›

Tapenade

Tapenade Tapenade is a source-transformation automatic differentiation system developed at INRIA. Like ADIFOR, it takes an existing program and produces a new differentiated program. Its main targets are Fortran and C, with strong emphasis on scientific and engineering codes. Tapenade is historically important because it pushed source-transformation AD beyond simple forward propagation. It supports both tangent mode and adjoint mode, making it useful for sensitivity analysis, inverse problems, and large...

Writes › Book › Auto Diff › Chapter 20. Building an AD Engine ›

Minimal Reverse Mode Engine

Minimal Reverse Mode Engine Reverse mode automatic differentiation computes derivatives by traversing the program backward after evaluation. Unlike forward mode, which propagates tangents alongside values, reverse mode separates computation into two phases: Forward evaluation Backward gradient propagation The forward pass computes values and records dependency information. The backward pass propagates sensitivities from outputs toward inputs. For a scalar-valued function $$ f : \mathbb{R}^n \to \mathbb{R} $$ reverse mode computes the...

Writes › Book › Auto Diff › Chapter 19. Theory and Foundations ›

Algebraic Semantics

Algebraic Semantics Automatic differentiation is often introduced operationally. A program executes elementary operations, and derivative information propagates alongside the computation. This operational view explains implementation, but it does not explain what differentiation fundamentally means at the semantic level. Algebraic semantics studies differentiation as a structure-preserving transformation between programs, functions, and algebraic objects. Instead of viewing AD as a collection of local derivative rules, it treats differentiation as an algebraic operation...

Writes › Book › Auto Diff › Chapter 18. Advanced Topics ›

Differentiating Through Solvers

Differentiating Through Solvers A solver is a program that computes a value by search, iteration, or factorization. Instead of evaluating a closed-form expression, it finds a value that satisfies a condition. Common examples include: Solver type Output condition Linear solver Ax = b Nonlinear root solver F(x, θ) = 0 Fixed-point solver x = G(x, θ) Optimizer ∇x L(x, θ) = 0 ODE solver trajectory satisfies differential equation Projection operator...

Writes › Book › Auto Diff › Chapter 17. Numerical and Systems Concerns ›

Stability of Reverse Mode

Stability of Reverse Mode Reverse mode automatic differentiation computes gradients by propagating adjoint values backward through a computational graph. In exact arithmetic, the reverse accumulation rules are mathematically correct applications of the chain rule. In finite precision arithmetic, however, reverse propagation can become numerically unstable. The instability does not usually come from reverse mode itself. It emerges from the interaction between: floating point rounding, ill-conditioned computations, long dependency chains, repeated...

Writes › Book › Auto Diff › Chapter 15. Differentiable Systems Architecture ›

Differentiable Databases

Differentiable Databases A differentiable database is a data system whose operations participate in gradient-based optimization. Instead of treating storage and querying as external infrastructure, the database becomes part of the computational graph. The central idea is: $$ \text{query} \rightarrow \text{retrieval} \rightarrow \text{transformation} \rightarrow \text{loss} $$ with gradients propagating backward through retrieval, ranking, aggregation, filtering, and learned representations. This changes the role of the database. A traditional database answers queries exactly....

Writes › Book › Auto Diff › Chapter 14. Scientific Computing Applications ›

Sensitivity Analysis

Sensitivity Analysis Sensitivity analysis studies how changes in inputs affect the outputs of a system. In differential equations, optimization, simulation, and machine learning, the main object is usually a function $$ y = f(x,\theta), $$ where $x$ is an input or initial condition and $\theta$ is a parameter vector. The central question is: $$ \text{How does } y \text{ change when } x \text{ or } \theta \text{ changes?} $$...

Writes › Book › Auto Diff › Chapter 13. Optimization and Machine Learning ›

Stochastic Optimization

Stochastic Optimization Stochastic optimization studies optimization when the objective is accessed through samples, noisy estimates, or partial observations. In machine learning, this is the normal case. We do not usually optimize the loss over the entire data distribution. We optimize an empirical approximation, and even that empirical loss is usually accessed through mini-batches. The ideal objective is often written as an expectation: $$ L(\theta) = \mathbb{E} {(x,y) \sim P}[\ell(f \theta(x),...

Writes › Book › Auto Diff › Chapter 12. AD in Modern Programming Languages ›

Functional Languages

Functional Languages Functional programming languages provide a natural semantic foundation for automatic differentiation. Programs are expressed as compositions of functions, immutable values, and transformations over data. This aligns closely with the mathematical structure of differentiation. In a pure functional language, a function behaves like a mathematical mapping: $$ f : X \rightarrow Y $$ The absence of mutable state means evaluation can be analyzed as a composition graph. Automatic differentiation...

Writes › Book › Auto Diff › Chapter 11. Compiler and Runtime Design ›

Operator Overloading

Operator Overloading Operator overloading implements automatic differentiation by changing the meaning of ordinary arithmetic operations for special numeric objects. Instead of rewriting the program, the AD system gives numbers extra derivative state. When the user writes: y = sin(x * x) the operations * and sin execute derivative-aware methods. The program looks unchanged, but the values flowing through it are no longer plain scalars. They are AD values. A forward-mode...

Writes › Book › Auto Diff › Chapter 10. Matrix and Tensor Differentiation ›

Tensor Operations

Tensor Operations Tensor operations generalize scalar, vector, and matrix operations to arrays with arbitrary rank. In automatic differentiation, a tensor is usually treated as a typed array with shape, dtype, layout, and device. The mathematical object is an element of a finite-dimensional vector space. The systems object is a strided memory view with rules for indexing and mutation. A tensor $X$ with shape $$ (d_1, d_2, \ldots, d_k) $$ has...

Writes › Book › Auto Diff › Chapter 9. Differentiation of Control Flow ›

forward

Loops A loop repeats a computation until a condition fails or a fixed iteration count is reached. In automatic differentiation, loops are important because many numerical algorithms are fundamentally iterative: optimization methods recurrent neural networks numerical solvers simulations dynamic programming graph algorithms A loop introduces repeated dependence between program states. The derivative of the loop therefore depends on how perturbations propagate through the sequence of iterations. A loop can be...

Writes › Book › Auto Diff › Chapter 8. Higher-Order Differentiation ›

Hessian Computation

Hessian Computation For a scalar function $$ f : \mathbb{R}^n \to \mathbb{R}, $$ the Hessian is the matrix of all second partial derivatives: $$ H_f(x) = \nabla^2 f(x). $$ Its entries are $$ (H_f(x))_{ij} = \frac{\partial^2 f}{\partial x_i \partial x_j}(x). $$ Computing the Hessian means computing the derivative of the gradient: $$ \nabla^2 f(x) = D(\nabla f)(x). $$ This definition is simple. The difficulty is cost. A gradient has $n$...

Writes › Book › Auto Diff › Chapter 7. Dual Numbers and Algebraic Structures ›

Nilpotent Elements

Nilpotent Elements The defining feature of dual numbers is the existence of a nonzero element whose square vanishes: $$ \varepsilon^2 = 0. $$ Such elements are called nilpotent elements. Nilpotent structure is what allows automatic differentiation to isolate first-order behavior while discarding higher-order terms automatically. The algebra of dual numbers is therefore best understood as a special case of a more general idea: extending ordinary arithmetic with nilpotent infinitesimals. Definition...

Writes › Book › Auto Diff › Chapter 6. Reverse Mode Automatic Differentiation ›

Reverse Computational Graphs

Reverse Computational Graphs Reverse mode automatic differentiation operates on a computational graph. The forward pass evaluates the graph from inputs to outputs. The reverse pass traverses the same graph in the opposite direction and propagates adjoints backward through the dependencies. A computational graph converts a program into a directed acyclic structure of values and operations. Each node represents either: a variable or intermediate value; an elementary operation. Edges represent data...

Writes › Book › Auto Diff › Chapter 5. Forward Mode Automatic Differentiation ›

Dual Numbers

Dual Numbers Dual numbers give forward mode automatic differentiation a compact algebraic form. Instead of storing a value and a tangent as two unrelated fields, we package them into one object: $$ x + \epsilon \dot{x} $$ where $\epsilon$ is a formal symbol satisfying $$ \epsilon^2 = 0. $$ The number $x$ is the primal value. The number $\dot{x}$ is the tangent. The symbol $\epsilon$ marks the tangent part. A...

Writes › Book › Auto Diff › Chapter 4. Core Theory of Automatic Differentiation ›

Elementary Operations

Automatic differentiation reduces differentiation to a finite collection of elementary operations. Every program, regardless of complexity, is decomposed into primitive computational steps with known local derivative rules. An AD system therefore requires two components: a representation of computation as primitive operations derivative propagation rules for each primitive This section formalizes these elementary operations and shows how derivative rules are attached to them. Primitive Operations A primitive operation is an operation...

Writes › Book › Auto Diff › Chapter 3. Programs as Mathematical Objects ›

Intermediate Variables

Intermediate Variables Intermediate variables are the named values created between program inputs and program outputs. They make automatic differentiation mechanical. Consider: y = sin(x1 * x2) + exp(x2) A straight-line version is: v1 = x1 v2 = x2 v3 = v1 * v2 v4 = sin(v3) v5 = exp(v2) v6 = v4 + v5 y = v6 The expression has been decomposed into elementary assignments. Each assignment has one local...

Writes › Book › Auto Diff › Chapter 2. Mathematical Foundations ›

Multivariate Calculus

Multivariate Calculus Automatic differentiation is usually applied to functions with many inputs and many outputs. The calculus needed for this setting is multivariate calculus: the study of how a quantity changes when several variables change at once. A scalar function of several variables has the form $$ f : \mathbb{R}^n \to \mathbb{R} $$ For example, $$ f(x_1, x_2) = x_1^2 + 3x_1x_2 + \sin x_2 $$ depends on two independent...

Writes › Book › Auto Diff › Chapter 1. Introduction ›

Numerical Differentiation

Numerical Differentiation Numerical differentiation estimates derivatives by evaluating a function at nearby input values. It treats the function as a black box. The method does not need access to the internal structure of the program, only the ability to call it. For a scalar function $$ f : \mathbb{R} \to \mathbb{R}, $$ the simplest finite difference approximation is $$ f'(x) \approx \frac{f(x+h)-f(x)}{h}. $$ Here $h$ is a small perturbation. The...

Writes › Book › Auto Diff › Chapter 21. Major AD Systems ›

Chapter 21. Major AD Systems

ADIFOR ADIFOR, short for Automatic Differentiation of Fortran, is one of the classical source-transformation systems for automatic differentiation. It was designed for numerical programs written in Fortran, especially scientific computing codes where derivatives were needed for optimization, sensitivity analysis, and parameter estimation. The central idea of ADIFOR is simple: take an existing Fortran program that computes a function, analyze its source code, and generate a new Fortran program that computes...

Writes › Book › Auto Diff › Appendix ›

Appendix

ADIFOR ADIFOR, short for Automatic Differentiation of Fortran, is one of the classical source-transformation systems for automatic differentiation. It was designed for numerical programs written in Fortran, especially scientific computing codes where derivatives were needed for optimization, sensitivity analysis, and parameter estimation. The central idea of ADIFOR is simple: take an existing Fortran program that computes a function, analyze its source code, and generate a new Fortran program that computes...

Writes › Book › Auto Diff › Chapter 20. Building an AD Engine ›

Chapter 20. Building an AD Engine

Minimal Forward Mode Engine A minimal forward mode automatic differentiation engine has one job: evaluate a program while carrying both a value and its derivative. The engine does not build a graph. It does not store a tape. It computes derivatives in the same order as the original computation. Forward mode is best understood as ordinary evaluation over a richer number type. Instead of evaluating with real numbers, we evaluate...

Writes › Book › Auto Diff › Chapter 19. Theory and Foundations ›

Chapter 19. Theory and Foundations

Complexity Bounds Automatic differentiation is often described by a simple rule: The derivative of a program can usually be computed with cost comparable to the cost of running the program itself. This statement is useful, but incomplete. The cost depends on the shape of the function, the derivative object requested, the accumulation mode, memory behavior, and the representation of intermediate values. A scalar derivative, a gradient, a full Jacobian, and...

Writes › Book › Auto Diff › Chapter 18. Advanced Topics ›

Chapter 18. Advanced Topics

Implicit Differentiation Many programs do not compute their output by applying a fixed sequence of explicit operations. Instead, they define the output as the solution of another problem. A linear solver returns x such that $$ Ax=b. $$ An optimizer returns z such that $$ \nabla_z L(z,\theta)=0. $$ A fixed-point solver returns x such that $$ x = F(x,\theta). $$ In all three cases, the output depends on input parameters,...

Writes › Book › Auto Diff › Chapter 17. Numerical and Systems Concerns ›

Chapter 17. Numerical and Systems Concerns

Floating Point Error Automatic differentiation computes derivatives by executing arithmetic. On a real machine, arithmetic uses finite precision. This means AD gives the derivative of the implemented floating point program, not always the exact derivative of the ideal real-valued mathematical function. That distinction matters. Suppose a program represents a function $$ f : \mathbb{R}^n \to \mathbb{R}^m. $$ Mathematically, we may want the Jacobian $$ J_f(x) = \frac{\partial f(x)}{\partial x}. $$...

Writes › Book › Auto Diff › Chapter 15. Differentiable Systems Architecture ›

Chapter 15. Differentiable Systems Architecture

End-to-End Differentiable Pipelines An end-to-end differentiable pipeline is a system whose final objective can send derivative information backward through every trainable or tunable stage of computation. Instead of treating a model as the only differentiable component, the pipeline treats preprocessing, representation, simulation, retrieval, rendering, scoring, and decision rules as parts of one computational object. The basic form is: $$ x \mapsto z_1 \mapsto z_2 \mapsto \cdots \mapsto z_k \mapsto y...

Writes › Book › Auto Diff › Chapter 14. Scientific Computing Applications ›

Chapter 14. Scientific Computing Applications

Differential Equations Differential equations are one of the main reasons automatic differentiation matters in scientific computing. Many scientific models are not written as closed-form functions. They are written as equations describing how a system changes over time, space, or both. A simple ordinary differential equation has the form $$ \frac{dy(t)}{dt} = f(y(t), t, \theta), $$ where $y(t)$ is the state, $t$ is time, and $\theta$ is a vector of parameters....

Writes › Book › Auto Diff › Chapter 13. Optimization and Machine Learning ›

Chapter 13. Optimization and Machine Learning

Gradient Descent Gradient descent is the basic optimization procedure behind much of modern machine learning. It is simple enough to state in one line, but rich enough to expose many of the main issues in automatic differentiation: representation of objectives, computation of gradients, floating point behavior, memory use, batching, and convergence. Given a differentiable scalar objective $$ L(\theta): \mathbb{R}^n \to \mathbb{R}, $$ gradient descent updates the parameter vector $\theta$ by...

Writes › Book › Auto Diff › Chapter 12. AD in Modern Programming Languages ›

Chapter 12. AD in Modern Programming Languages

Lisp Systems Lisp is one of the natural homes of automatic differentiation. It treats programs as data, has a simple expression syntax, and supports macro systems that can transform code before execution. These properties make it possible to implement automatic differentiation as a direct program transformation rather than as an external compiler pass. A Lisp system represents code as symbolic expressions. The expression (* (+ x 1) (sin x)) is...

Writes › Book › Auto Diff › Chapter 11. Compiler and Runtime Design ›

Chapter 11. Compiler and Runtime Design

Source Transformation Source transformation is an implementation strategy for automatic differentiation in which a program that computes a function is rewritten into another program that computes derivatives of that function. The input is source code, or an intermediate representation close enough to source code. The output is new code with derivative computation built into it. For example, a function y = f(x) may be transformed into a function (y, dy)...

Writes › Book › Auto Diff › Chapter 10. Matrix and Tensor Differentiation ›

Chapter 10. Matrix and Tensor Differentiation

Matrix Calculus Matrix calculus is the notation and rule system used to differentiate functions whose inputs, outputs, or intermediate values are vectors, matrices, or tensors. Automatic differentiation systems do not require matrix calculus internally: they only need local derivative rules for primitive operations. However, matrix calculus is the language used to specify those rules, check them, and understand their shape. A scalar function has the familiar form $$ f :...

Writes › Book › Auto Diff › Chapter 9. Differentiation of Control Flow ›

Chapter 9. Differentiation of Control Flow

Conditionals A conditional is a program construct that chooses one computation among several possible computations. In ordinary code, this is written as if , else , switch , case , pattern matching, or guarded expressions. In automatic differentiation, a conditional raises a simple question: When a program chooses one branch, which derivative should the differentiated program compute? For a fixed execution, the answer is direct. The derivative follows the branch...

Writes › Book › Auto Diff › Chapter 8. Higher-Order Differentiation ›

Chapter 8. Higher-Order Differentiation

Second Derivatives First derivatives describe local rate of change. Second derivatives describe how that rate of change itself changes. In optimization, this is curvature. In dynamics, it is acceleration. In sensitivity analysis, it tells us whether a response is stable, amplifying, or changing direction. For a scalar function $$ f : \mathbb{R} \to \mathbb{R}, $$ the first derivative is $$ f'(x), $$ and the second derivative is $$ f''(x) =...

Writes › Book › Auto Diff › Chapter 7. Dual Numbers and Algebraic Structures ›

Chapter 7. Dual Numbers and Algebraic Structures

Algebra of Dual Numbers Dual numbers give the cleanest algebraic model of forward mode automatic differentiation. They extend ordinary real numbers with a formal infinitesimal part. Instead of carrying only a value, a dual number carries a value and its first-order variation. A dual number has the form $$ a + b\varepsilon $$ where $a,b \in \mathbb{R}$, and $\varepsilon$ is a formal element satisfying $$ \varepsilon^2 = 0 $$ but...

Writes › Book › Auto Diff › Chapter 6. Reverse Mode Automatic Differentiation ›

Chapter 6. Reverse Mode Automatic Differentiation

Adjoint Propagation Reverse mode automatic differentiation computes derivatives by propagating sensitivities backward through a computation. In forward mode, each intermediate value carries a tangent, which says how that value changes when the input is perturbed. In reverse mode, each intermediate value carries an adjoint, which says how the final output changes when that intermediate value is perturbed. Consider a scalar-valued function $$ f : \mathbb{R}^n \to \mathbb{R}. $$ A program...

Writes › Book › Auto Diff › Chapter 5. Forward Mode Automatic Differentiation ›

Chapter 5. Forward Mode Automatic Differentiation

Tangent Propagation Forward mode automatic differentiation computes derivatives by carrying two values through a program at the same time: the ordinary value and its tangent. The ordinary value tells us what the program computes. The tangent tells us how that value changes when the input is perturbed. For a scalar function $$ f : \mathbb{R} \to \mathbb{R}, $$ we usually write the derivative as $f'(x)$. Forward mode instead asks a...

Writes › Book › Auto Diff › Chapter 4. Core Theory of Automatic Differentiation ›

Chapter 4. Core Theory of Automatic Differentiation

Automatic differentiation is built on a simple observation: a complicated derivative can be computed by composing many small local derivatives. Instead of manipulating a full symbolic expression, or approximating derivatives numerically, AD propagates derivative information through each elementary operation in a program. This section develops the central mechanism underlying all forms of automatic differentiation: local derivative propagation. Programs as Compositions Consider a function: $$ f(x)=\sin(x^2+3x) $$ This function is not...

Writes › Book › Auto Diff › Chapter 3. Programs as Mathematical Objects ›

Chapter 3. Programs as Mathematical Objects

Straight-Line Programs A straight-line program is the simplest model of computation used in automatic differentiation. It is a program with a fixed sequence of assignments, no branches, no loops, and no recursion. Every operation is executed exactly once, in a known order. A typical straight-line program has the form: v1 = x1 v2 = x2 v3 = v1 * v2 v4 = sin(v3) v5 = v4 + v1 y =...

Writes › Book › Auto Diff › Chapter 2. Mathematical Foundations ›

Chapter 2. Mathematical Foundations

Functions and Mappings Automatic differentiation begins with a simple object: a function. A function maps an input value to an output value. In elementary calculus, this is often written as $$ f : \mathbb{R} \to \mathbb{R} $$ meaning that $f$ takes one real number and returns one real number. For example, $$ f(x) = x^2 + 3x + 1 $$ takes a scalar input $x$ and returns a scalar output....

Writes › Book › Auto Diff › Chapter 1. Introduction ›

Chapter 1. Introduction

Why Derivatives Matter A derivative measures how an output changes when an input changes. That sentence is simple, but it is one of the main ideas behind numerical computing, optimization, machine learning, simulation, control, statistics, and scientific modeling. When we write a function $$ y = f(x), $$ we usually care about more than the value of $y$. We also care about how sensitive $y$ is to $x$. If $x$...

Writes › Book › Graph Theory ›

XIII. Applications

Chapter Title 131 Social Networks 132 Web Graphs 133 Search Engines and PageRank 134 Biological Networks 135 Chemical Graph Theory 136 Electrical Networks 137 Transportation Networks 138 Communication Networks 139 Compiler Dependency Graphs 140 Knowledge Graphs 141 Recommendation Systems 142 Machine Learning on Graphs 143 Graph Neural Networks 144 Distributed Systems 145 Blockchain and Peer-to-Peer Networks

Writes › Book › Auto Diff ›

Chapter 7. Dual Numbers and Algebraic Structures

Section Title 1 Chapter 7. Dual Numbers and Algebraic Structures 2 Nilpotent Elements 3 Geometric Interpretation 4 Truncated Polynomial Algebras 5 Hyper-Dual Numbers 6 Differential Algebras 7 Category-Theoretic View 8 Differential Lambda Calculus 9 Differential Lambda Calculus

Writes › Book › Graph Theory ›

V. Connectivity and Network Structure

Chapter Title 46 Vertex Connectivity 47 Edge Connectivity 48 Cuts and Cut Sets 49 Bridges and Articulation Points 50 Menger's Theorem 51 Network Reliability 52 Expansion and Expanders 53 Graph Separators 54 Sparse and Dense Graphs 55 Random Walks on Graphs

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 › Auto Diff ›

Chapter 10. Matrix and Tensor Differentiation

Section Title 1 Chapter 10. Matrix and Tensor Differentiation 2 Tensor Operations 3 Broadcasting Semantics 4 Linear Algebra Primitives 5 Differentiating Factorizations 6 Eigenvalue Problems 7 Singular Value Decomposition 8 Sparse Tensor Derivatives 9 GPU Tensor Kernels

Writes › Book › Auto Diff ›

Chapter 4. Core Theory of Automatic Differentiation

Section Title 1 Chapter 4. Core Theory of Automatic Differentiation 2 Elementary Operations 3 Forward Accumulation 4 Reverse Accumulation 5 Mixed-Mode Differentiation 6 Computational Complexity 7 Numerical Exactness up to Floating Point 8 AD as Program Transformation 9 Summary and Synthesis 10 Tangent Propagation

Writes › Book › Auto Diff ›

Chapter 14. Scientific Computing Applications

Section Title 1 Chapter 14. Scientific Computing Applications 2 Sensitivity Analysis 3 Inverse Problems 4 Computational Fluid Dynamics 5 Molecular Simulation 6 Computational Finance 7 Signal Processing 8 Robotics and Control 9 Probabilistic Programming

Writes › Book › Auto Diff ›

Chapter 17. Numerical and Systems Concerns

Section Title 1 Chapter 17. Numerical and Systems Concerns 2 Stability of Reverse Mode 3 Overflow and Underflow 4 Memory Explosion 5 Gradient Vanishing and Explosion 6 Determinism and Reproducibility 7 Parallelism 8 GPU and TPU Execution 9 Distributed Gradient Computation

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 › 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 › Auto Diff ›

Chapter 6. Reverse Mode Automatic Differentiation

Section Title 1 Chapter 6. Reverse Mode Automatic Differentiation 2 Reverse Computational Graphs 3 Vector-Jacobian Products 4 Reverse Accumulation Algorithms 5 Tape-Based Systems 6 Wengert Lists 7 Memory-Time Tradeoffs 8 Checkpointing 9 Reverse Mode in Deep Learning 10 Case Studies

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 › Graph Theory ›

Appendices

Appendix Title A Set Theory and Relations B Proof Techniques C Linear Algebra for Graph Theory D Probability Review E Algorithms and Complexity F Mathematical Notation G Historical Development H Common Graph Families I Theorem Index J Symbol Index

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 › 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 › Graph Theory ›

IX. Probabilistic and Random Graphs

Chapter Title 87 Random Graph Models 88 Erdős-Rényi Graphs 89 Threshold Phenomena 90 Small-World Networks 91 Scale-Free Networks 92 Preferential Attachment 93 Percolation on Graphs 94 Probabilistic Methods 95 Random Processes on Networks

Writes › Book › Auto Diff ›

Chapter 15. Differentiable Systems Architecture

Section Title 1 Chapter 15. Differentiable Systems Architecture 2 Differentiable Databases 3 Differentiable Rendering 4 Differentiable Physics Engines 5 Differentiable Search and Retrieval 6 Differentiable Compilers 7 Differentiable Operating Systems 8 Hybrid Symbolic-Numeric Systems 9 Summary

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 ›

Modern Number Theory

Modern Number Theory Chapter Title Description 1 Chapter 1. Foundations of Arithmetic The natural numbers arise from the basic act of counting. When we count objects in a collection, we assign successive numbers: 2 Chapter 2. Classical Number Theory A Diophantine equation is an equation whose solutions are required to be integers. The unknowns are not allowed to range over the real numbers or complex numbers unless... 3 Chapter 3....

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 › 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 › Linear Algebra ›

V. Eigenvalues and Spectral Theory

Chapter Title 59 Eigenvalues 60 Eigenvectors 61 Characteristic Polynomial 62 Eigenspaces 63 Diagonalization 64 Spectral Theorem 65 Symmetric Matrices 66 Hermitian Operators 67 Normal Operators 68 Jordan Canonical Form 69 Minimal Polynomial 70 Cayley-Hamilton Theorem 71 Rational Canonical Form 72 Matrix Functions 73 Matrix Exponential 74 Perron-Frobenius Theory

Writes › Book › Auto Diff ›

Chapter 1. Introduction

Section Title 1 Chapter 1. Introduction 2 Numerical Differentiation 3 Symbolic Differentiation 4 Automatic Differentiation 5 Accuracy, Complexity, and Stability 6 Historical Development 7 Applications Across Science and Engineering

Writes › Book › Linear Algebra ›

X. Specialized Topics

Chapter Title 127 Complex Vector Spaces 128 Finite Fields 129 Linear Algebra over Arbitrary Fields 130 Modules and Linear Algebra 131 Category-Theoretic Perspective 132 Convex Geometry 133 Random Matrices 134 Numerical Optimization 135 Operator Theory 136 Spectral Graph Theory 137 Compressed Sensing 138 Tensor Decompositions 139 Geometric Algebra 140 Modern Applications in AI

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 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 › Graph Theory ›

VIII. Algebraic Graph Theory

Chapter Title 76 Adjacency Matrices 77 Incidence Matrices 78 Laplacian Matrices 79 Spectrum of a Graph 80 Eigenvalues and Eigenvectors 81 Spectral Theorems 82 Algebraic Connectivity 83 Expander Graphs 84 Graph Energy 85 Cayley Graphs 86 Automorphism Groups

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 › Graph Theory ›

I. Foundations of Graph Theory

Chapter Title 1 What Graph Theory Is 2 Basic Definitions 3 Vertices and Edges 4 Graph Representations 5 Degree of a Vertex 6 Walks, Trails, and Paths 7 Cycles and Circuits 8 Connected Graphs 9 Components 10 Isomorphism 11 Subgraphs 12 Graph Operations 13 Complement Graphs 14 Graph Invariants 15 Classes of Graphs

Writes › Book › Auto Diff ›

Chapter 13. Optimization and Machine Learning

Section Title 1 Chapter 13. Optimization and Machine Learning 2 Stochastic Optimization 3 Backpropagation 4 Neural Network Training 5 Sequence Models 6 Attention Mechanisms 7 Implicit Layers 8 Meta-Learning 9 Reinforcement Learning 10 Physics-Informed Models

Writes › Book › Auto Diff ›

Chapter 11. Compiler and Runtime Design

Section Title 1 Chapter 11. Compiler and Runtime Design 2 Operator Overloading 3 Intermediate Representations 4 SSA Form 5 Graph IRs 6 Tracing Systems 7 Staging and Partial Evaluation 8 Memory Planning 9 Kernel Fusion 10 Ahead-of-Time vs Just-in-Time Differentiation

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 ›

Auto Diff

Auto Diff Chapter Title Description 1 Chapter 1. Introduction A derivative measures how an output changes when an input changes. That sentence is simple, but it is one of the main ideas behind numerical computing, optimization, machine... 2 Chapter 2. Mathematical Foundations Automatic differentiation begins with a simple object: a function. 3 Chapter 3. Programs as Mathematical Objects A straight-line program is the simplest model of computation used in automatic...

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 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 › Linear Algebra ›

IX. Applications

Chapter Title 109 Linear Regression 110 Optimization and Linear Algebra 111 Graphs and Adjacency Matrices 112 Markov Chains 113 Differential Equations 114 Fourier Series and Transforms 115 Signal Processing 116 Computer Graphics 117 Robotics and Kinematics 118 Control Theory 119 Quantum Mechanics 120 Machine Learning 121 Principal Component Analysis 122 PageRank and Network Analysis 123 Coding Theory 124 Cryptography 125 Finite Element Methods 126 Scientific Computing

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 › Graph Theory ›

VII. Coloring Theory

Chapter Title 66 Vertex Coloring 67 Edge Coloring 68 Chromatic Number 69 Chromatic Polynomial 70 Greedy Coloring 71 Brooks' Theorem 72 Perfect Graphs 73 Ramsey Theory 74 List Coloring 75 Fractional Coloring

Writes › Book › Graph Theory ›

X. Graph Algorithms

Chapter Title 96 Graph Traversal Algorithms 97 Breadth-First Search 98 Depth-First Search 99 Shortest Paths 100 Dijkstra's Algorithm 101 Bellman-Ford Algorithm 102 Floyd-Warshall Algorithm 103 Network Flow 104 Maximum Flow Algorithms 105 Minimum Cut Algorithms 106 Matching Algorithms 107 Union-Find Structures 108 Dynamic Graph Algorithms 109 Approximation Algorithms 110 Randomized Algorithms

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 › 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 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 › Modern Number Theory ›

Chapter 3. Analytic Number Theory

Section Title 1 Chapter 3. Analytic Number Theory 2 Infinite Products 3 Euler Products 4 Convergence Methods 5 Abel Summation 6 Prime Counting Function 7 Chebyshev Bounds 8 Prime Number Theorem 9 Logarithmic Integral 10 Error Terms 11 Short Intervals 12 Prime Gaps 13 Twin Prime Heuristics 14 Definition of the Zeta Function 15 Euler Product Formula 16 Analytic Continuation 17 Functional Equation 18 Zeros of the Zeta Function 19...

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 ›

Linear Algebra

Linear Algebra Part I. Foundations Chapter Title 1 What Linear Algebra Is 2 Scalars, Vectors, and Fields 3 Geometry of Euclidean Space 4 Linear Equations 5 Systems of Linear Equations 6 Matrices 7 Matrix Operations 8 Elementary Row Operations 9 Gaussian Elimination 10 Gauss-Jordan Elimination 11 Invertible Matrices 12 Rank and Nullity 13 Determinants 14 Cofactors and Adjugates 15 Block Matrices 16 Matrix Factorizations Overview Part II. Vector Spaces Chapter...

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 › 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 › Auto Diff ›

Chapter 5. Forward Mode Automatic Differentiation

Section Title 1 Chapter 5. Forward Mode Automatic Differentiation 2 Dual Numbers 3 Forward Evaluation Rules 4 Jacobian-Vector Products 5 Complexity Analysis 6 Higher-Dimensional Tangent Spaces 7 Efficient Seeding Strategies 8 Sparse Forward Methods 9 Case Studies

Writes › Book › Graph Theory ›

IV. Planar and Geometric Graphs

Chapter Title 36 Planar Graphs 37 Plane Embeddings 38 Euler's Formula 39 Faces and Regions 40 Kuratowski's Theorem 41 Graph Coloring of Planar Graphs 42 Dual Graphs 43 Geometric Graphs 44 Intersection Graphs 45 Computational Geometry Connections

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 › Linear Algebra ›

VIII. Advanced Structures

Chapter Title 98 Tensor Products 99 Exterior Algebra 100 Symmetric Algebra 101 Multilinear Maps 102 Bilinear Forms 103 Alternating Forms 104 Clifford Algebras 105 Lie Algebras 106 Representation Theory Basics 107 Infinite-Dimensional Vector Spaces 108 Functional Analysis Connections

Writes › Book › Modern Number Theory ›

Chapter 1. Foundations of Arithmetic

Section Title 1 Chapter 1. Foundations of Arithmetic 2 The Integers 3 Arithmetic Operations 4 Order Relations 5 Absolute Value and Distance 6 Mathematical Induction 7 Strong Induction 8 Recursive Definitions 9 Growth of Integers 10 Historical Development of Number Systems 11 Divisibility Relations 12 Prime Numbers 13 Composite Numbers 14 The Division Algorithm 15 Greatest Common Divisors 16 Least Common Multiples 17 Euclidean Algorithm 18 Extended Euclidean Algorithm 19...

Writes › Book › Linear Algebra ›

VII. Numerical Linear Algebra

Chapter Title 85 Floating Point Arithmetic 86 Conditioning and Stability 87 Error Analysis 88 Iterative Methods for Linear Systems 89 Jacobi Method 90 Gauss-Seidel Method 91 Conjugate Gradient Method 92 Krylov Subspaces 93 Power Iteration 94 QR Algorithm 95 Sparse Matrices 96 Structured Matrices 97 Randomized Linear Algebra

Writes › Book › Auto Diff ›

Chapter 3. Programs as Mathematical Objects

Section Title 1 Chapter 3. Programs as Mathematical Objects 2 Intermediate Variables 3 Dependency Graphs 4 Control Flow 5 Loops and Recurrence Relations 6 Memory and State 7 Purity and Side Effects 8 Differentiable Subprograms

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 › Auto Diff ›

Chapter 8. Higher-Order Differentiation

Section Title 1 Chapter 8. Higher-Order Differentiation 2 Hessian Computation 3 Hessian-Vector Products 4 Higher-Order Reverse Mode 5 Nested AD 6 Taylor Mode AD 7 Efficient Higher-Order Methods 8 Perturbation Confusion 9 Complexity of Higher Orders

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 › Modern Number Theory ›

Chapter 4. Algebraic Number Theory

Section Title 1 Chapter 4. Algebraic Number Theory 2 Splitting Fields 3 Galois Groups 4 Finite Fields 5 Cyclotomic Fields 6 Ramification 7 Absolute Values 8 $p$-Adic Numbers 9 Completion of Fields 10 Hensel’s Lemma 11 Local-Global Principles 12 Adeles and Ideles 13 Abelian Extensions 14 Reciprocity Maps 15 Hilbert Class Fields 16 Local Class Field Theory 17 Global Class Field Theory 18 Modular Groups 19 Modular Functions 20 Modular...

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 › 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 › Auto Diff ›

Chapter 21. Major AD Systems

Section Title 1 Chapter 21. Major AD Systems 2 Tapenade 3 TensorFlow Autograd 4 PyTorch Autograd 5 JAX 6 Zygote 7 Enzyme 8 Tinygrad 9 Comparative Architecture Analysis 10 Differentiation of Large Stateful Systems

Writes › Book › Graph Theory ›

VI. Matching and Covering

Chapter Title 56 Matchings 57 Perfect Matchings 58 Hall's Marriage Theorem 59 Bipartite Matching 60 Maximum Matching Algorithms 61 Vertex Covers 62 Edge Covers 63 Independent Sets 64 Cliques 65 Dominating Sets

Writes › Book › Linear Algebra ›

IV. Inner Product Spaces

Chapter Title 45 Inner Products 46 Norms and Metrics 47 Orthogonality 48 Orthogonal Complements 49 Orthonormal Bases 50 Gram-Schmidt Orthogonalization 51 Orthogonal Projections 52 Least Squares Problems 53 QR Factorization 54 Unitary and Orthogonal Matrices 55 Hermitian Spaces 56 Positive Definite Matrices 57 Quadratic Forms 58 Sylvester's Law of Inertia

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 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 › 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 › Linear Algebra ›

III. Linear Transformations

Chapter Title 32 Linear Transformations 33 Kernel and Image 34 Matrix Representation of Linear Maps 35 Composition of Transformations 36 Isomorphisms 37 Automorphisms 38 Projection Operators 39 Reflection Operators 40 Rotation Operators 41 Shears and Scalings 42 Similarity Transformations 43 Invariant Subspaces 44 Cyclic Subspaces

Writes › Book ›

Graph Theory

Graph Theory Reference Part I. Foundations of Graph Theory Chapter Title 1 What Graph Theory Is 2 Basic Definitions 3 Vertices and Edges 4 Graph Representations 5 Degree of a Vertex 6 Walks, Trails, and Paths 7 Cycles and Circuits 8 Connected Graphs 9 Components 10 Isomorphism 11 Subgraphs 12 Graph Operations 13 Complement Graphs 14 Graph Invariants 15 Classes of Graphs Part II. Directed and Weighted Graphs Chapter Title...

Writes › Book › Graph Theory ›

XI. Computational Complexity

Chapter Title 111 Complexity Classes 112 NP-Complete Graph Problems 113 Hamiltonian Paths and Cycles 114 Traveling Salesman Problem 115 Graph Isomorphism Problem 116 Parameterized Complexity 117 Fixed-Parameter Tractability 118 Approximation Hardness

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 › 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 › Auto Diff ›

Chapter 22. Open Problems

Section Title 1 Chapter 22. Open Problems

Writes › Book › Graph Theory ›

XIV. Specialized Structures

Chapter Title 146 Bipartite Graphs 147 Complete Graphs 148 Regular Graphs 149 Interval Graphs 150 Chordal Graphs 151 Comparability Graphs 152 Perfect Graphs 153 Tournament Graphs 154 Grid Graphs 155 De Bruijn Graphs 156 Kneser Graphs 157 Petersen Graph 158 Ramanujan Graphs

Writes › Book › Graph Theory ›

II. Directed and Weighted Graphs

Chapter Title 16 Directed Graphs 17 In-Degree and Out-Degree 18 Directed Paths and Cycles 19 Strong Connectivity 20 Directed Acyclic Graphs 21 Topological Ordering 22 Weighted Graphs 23 Multigraphs 24 Hypergraphs 25 Signed and Labeled Graphs

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 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 › 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 › Modern Number Theory ›

Appendix

Section Title 1 Appendix 2 Appendix B. Proof Techniques 3 Appendix C. Abstract Algebra Review 4 Appendix D. Real and Complex Analysis Review 5 Appendix E. Topology Background 6 Appendix F. Measure and Integration 7 Appendix G. Linear Algebra Review 8 Appendix H. Category Theory Basics 9 Appendix I. Computational Tools 10 Appendix J. Historical Notes and Bibliography 11 Glossary 12 Notation Index 13 Index of Theorems 14 Index of...

Writes › Book › Auto Diff ›

Chapter 12. AD in Modern Programming Languages

Section Title 1 Chapter 12. AD in Modern Programming Languages 2 Functional Languages 3 Differentiable Programming 4 AD in C and C++ 5 AD in Python 6 AD in Rust 7 AD in Julia 8 AD in Swift 9 Type Systems for Differentiation 10 Effect Systems and Mutation

Writes › Book › Linear Algebra ›

I. Foundations

Chapter Title 1 What Linear Algebra Is 2 Scalars, Vectors, and Fields 3 Geometry of Euclidean Space 4 Linear Equations 5 Systems of Linear Equations 6 Matrices 7 Matrix Operations 8 Elementary Row Operations 9 Gaussian Elimination 10 Gauss-Jordan Elimination 11 Invertible Matrices 12 Rank and Nullity 13 Determinants 14 Cofactors and Adjugates 15 Block Matrices 16 Matrix Factorizations Overview

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

Writes › Book › Auto Diff ›

Appendix

Section Title 1 Appendix 2 Tapenade 3 TensorFlow Autograd 4 PyTorch Autograd 5 JAX 6 Zygote 7 Enzyme 8 Tinygrad 9 Comparative Architecture Analysis 10 Differentiation of Large Stateful Systems

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 › 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 › Linear Algebra ›

Appendices

Appendix Title A Set Theory and Logic B Proof Techniques C Real and Complex Numbers D Polynomial Algebra E Calculus Review F Numerical Computation G Mathematical Notation H Historical Notes I Glossary J Theorem Index K Symbol Index

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 › Auto Diff ›

Chapter 19. Theory and Foundations

Section Title 1 Chapter 19. Theory and Foundations 2 Algebraic Semantics 3 Categorical Semantics 4 Differential Categories 5 Lambda Calculus and AD 6 Program Equivalence 7 Formal Verification 8 Denotational Models 9 Differentiation as Functorial Transformation

Writes › Book › Linear Algebra ›

II. Vector Spaces

Chapter Title 17 Vector Spaces 18 Subspaces 19 Span and Linear Combination 20 Linear Independence 21 Basis 22 Dimension 23 Coordinate Systems 24 Change of Basis 25 Row Space and Column Space 26 Null Space 27 Quotient Spaces 28 Dual Spaces 29 Annihilators 30 Direct Sums 31 Affine Spaces

Writes › Book › Linear Algebra ›

VI. Matrix Decompositions

Chapter Title 75 LU Decomposition 76 PLU Decomposition 77 Cholesky Decomposition 78 QR Decomposition 79 Schur Decomposition 80 Singular Value Decomposition 81 Polar Decomposition 82 Hessenberg Form 83 Tridiagonalization 84 Canonical Matrix Forms

Writes › Book ›

Zig

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 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 › Auto Diff ›

Chapter 20. Building an AD Engine

Section Title 1 Chapter 20. Building an AD Engine 2 Minimal Reverse Mode Engine 3 Graph Representation 4 Tape Design 5 Memory Management 6 Operator Libraries 7 Custom Gradients 8 Performance Benchmarking 9 Testing Derivatives 10 Production Deployment

Writes › Book › Auto Diff ›

Chapter 2. Mathematical Foundations

Section Title 1 Chapter 2. Mathematical Foundations 2 Multivariate Calculus 3 Jacobians and Hessians 4 Chain Rule as Composition Algebra 5 Computational Graphs 6 Linearization 7 Dual Spaces and Pushforwards 8 Taylor Expansions

Writes › Book › Auto Diff ›

Chapter 9. Differentiation of Control Flow

Section Title 1 Chapter 9. Differentiation of Control Flow 2 forward 3 Recursion 4 Dynamic Graphs 5 Piecewise Differentiability 6 Non-Smooth Programs 7 Differentiating Stateful Systems 8 Exception Handling and Undefined Regions

Writes › Book › Auto Diff ›

Chapter 16. Sparse and Structured Differentiation

Section Title 1 Chapter 16. Sparse and Structured Differentiation

Writes › Book › Modern Number Theory ›

Chapter 2. Classical Number Theory

Section Title 1 Chapter 2. Classical Number Theory 2 Pythagorean Triples 3 Pell Equations 4 Sums of Squares 5 Catalan-Type Equations 6 Exponential Diophantine Equations 7 Rational and Integral Points 8 Geometry of Diophantine Problems 9 Squares Modulo $n$ 10 Legendre Symbol 11 Jacobi Symbol 12 Euler Criterion 13 Quadratic Reciprocity 14 Gauss Sums 15 Higher Reciprocity Laws 16 Computational Aspects 17 Euclidean Algorithm Revisited 18 Finite Continued Fractions 19...

Writes › Book › Auto Diff ›

Chapter 18. Advanced Topics

Section Title 1 Chapter 18. Advanced Topics 2 Differentiating Through Solvers 3 Differentiable Optimization Layers 4 Continuous-Time Adjoint Methods 5 Neural ODEs 6 Probabilistic Automatic Differentiation 7 Quantum Differentiation 8 Differentiable Programming Languages 9 Verified Differentiation 10 Unified Differentiable Infrastructure

Writes › Book › Graph Theory ›

XII. Advanced Topics

Chapter Title 119 Extremal Graph Theory 120 Turán-Type Problems 121 Szemerédi Regularity Lemma 122 Minor Theory 123 Robertson-Seymour Theory 124 Infinite Graphs 125 Topological Graph Theory 126 Category-Theoretic Graphs 127 Simplicial Complexes 128 Graph Limits 129 Temporal Graphs 130 Quantum Graph Theory

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 › Graph Theory ›

III. Trees and Forests

Chapter Title 26 Trees 27 Forests 28 Rooted Trees 29 Binary Trees 30 Spanning Trees 31 Minimum Spanning Trees 32 Prüfer Sequences 33 Tree Traversal 34 Tree Decomposition 35 Applications of Trees

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

Writes › Book › Modern Number Theory ›

Chapter 5. Arithmetic Geometry and Modern Directions

Section Title 1 Chapter 5. Arithmetic Geometry and Modern Directions 2 Schemes 3 Morphisms and Fibers 4 Curves over Fields 5 Arithmetic Surfaces 6 Étale Cohomology 7 Weil Conjectures 8 Representation Theory Background 9 Automorphic Representations 10 Adelic Methods 11 Langlands Program 12 Functoriality 13 Trace Formula 14 Fast Integer Arithmetic 15 Primality Testing 16 Integer Factorization 17 Lattice Reduction 18 Algorithms for Modular Forms 19 Algorithms for Elliptic Curves...

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

#book

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`