# 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:

```text
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 are built |
| Standard library | Real production Zig APIs |

Do not start here as a beginner. The compiler is large. Read small standard library files first.

### H.2 Zig Standard Library

The standard library ships with Zig.

It is ordinary Zig code, so you can read it directly.

Good files to read first:

| Topic | What to look for |
|---|---|
| `std.mem` | Slice and memory helpers |
| `std.fmt` | Formatting and parsing |
| `std.ArrayList` | Growable arrays |
| `std.HashMap` | Hash tables |
| `std.fs` | Files and directories |
| `std.testing` | Test helpers |

A useful habit is to read function signatures before implementation.

### H.3 TigerBeetle

TigerBeetle is a distributed financial accounting database written in Zig.

Study it for:

| Area | Why it matters |
|---|---|
| Systems design | Clear control over storage and networking |
| Testing | Heavy use of simulation and correctness checks |
| Performance | Careful memory and I/O design |
| Reliability | Strong focus on failure handling |

This is a serious production-grade Zig project.

### H.4 Bun

Bun is a JavaScript runtime and toolkit that uses Zig heavily.

Study it for:

| Area | Why it matters |
|---|---|
| Large application architecture | Big mixed-language project |
| Tooling | Runtime, bundler, package manager, test runner |
| C/C++ interop | Integration with JavaScriptCore and system libraries |
| Performance work | Fast startup and low-level optimization |

Bun is not a small beginner project, but it shows Zig used in a major developer tool.

### H.5 Ghostty

Ghostty is a terminal emulator written in Zig.

Study it for:

| Area | Why it matters |
|---|---|
| GUI application design | Real desktop application structure |
| Terminal protocols | Parsing, rendering, escape sequences |
| Cross-platform work | macOS, Linux, and other platform concerns |
| Performance | Fast rendering and careful allocation |

It is useful once you understand files, memory, structs, and build files.

### H.6 Mach

Mach is a set of Zig projects for graphics and game development.

Study it for:

| Area | Why it matters |
|---|---|
| Graphics programming | GPU APIs and rendering |
| Game engine architecture | ECS, assets, loops, platform layers |
| Cross-platform design | Desktop and WebAssembly targets |
| Real-time systems | Frame timing and performance |

This is useful if your interest is games, rendering, or interactive applications.

### H.7 zls

`zls` is the Zig Language Server.

It powers editor features such as:

| Feature | Meaning |
|---|---|
| Completion | Suggest names while typing |
| Go to definition | Jump to declarations |
| Diagnostics | Show errors in editor |
| Hover | Show type and documentation info |

Study `zls` for language tooling, parsing, editor integration, and long-running command-line services.

### H.8 Ziglings

Ziglings is a beginner-friendly exercise project.

It gives you small broken programs and asks you to fix them.

Use it for:

| Goal | Why |
|---|---|
| Syntax practice | Small focused examples |
| Error messages | Learn compiler diagnostics |
| Standard library basics | Practical repetition |
| Confidence | Quick feedback loop |

This is one of the best projects to use while reading the early chapters of this book.

### H.9 zig-clap

`zig-clap` is a command-line argument parser.

Study it for:

| Area | Why it matters |
|---|---|
| CLI tools | Common real-world need |
| API design | How to expose simple parsing APIs |
| Errors | Handling invalid user input |
| Text processing | Parsing arguments and options |

A command-line parser is a good intermediate project because it uses strings, slices, structs, errors, and tests.

### H.10 zap

`zap` is a web framework for Zig.

Study it for:

| Area | Why it matters |
|---|---|
| HTTP servers | Request and response handling |
| Routing | Mapping paths to handlers |
| C interop | Built on top of lower-level networking pieces |
| Application structure | Organizing real web services |

Read it after learning networking, allocators, and error handling.

### H.11 zig-sqlite

`zig-sqlite` is a Zig wrapper around SQLite.

Study it for:

| Area | Why it matters |
|---|---|
| C interop | Wrapping a mature C library |
| Resource cleanup | Database handles and prepared statements |
| Error mapping | Turning C return codes into Zig errors |
| API design | Safer Zig interface over C |

This is a strong example of how to wrap C libraries idiomatically.

### H.12 zig-gamedev

`zig-gamedev` is a collection of Zig libraries and samples for game development.

Study it for:

| Area | Why it matters |
|---|---|
| Graphics | Rendering examples |
| Audio | Sound APIs |
| Assets | Loading external files |
| Platform APIs | Windowing and input |

It is useful for learning how Zig programs interact with system libraries.

### H.13 Zigmod and Package Tools

Package tooling in Zig has changed over time. Older projects may use tools that are no longer the current recommended path.

Study old package tools mainly for historical context.

For modern projects, prefer the package and build system supported by your Zig version.

### H.14 Choosing Projects to Read

Do not read large projects from top to bottom.

Instead, pick one small question.

Examples:

| Question | Where to look |
|---|---|
| How does this project parse CLI arguments? | `main.zig`, argument parser module |
| How does it allocate memory? | Search for `Allocator` |
| How does it clean up resources? | Search for `defer` and `deinit` |
| How does it define errors? | Search for `error{` |
| How does it build? | Read `build.zig` |
| How does it test? | Search for `test "` |

Reading code this way is faster and less frustrating.

### H.15 Good Beginner Reading Order

A practical order:

| Step | Project type |
|---|---|
| 1 | Ziglings |
| 2 | Small CLI tools |
| 3 | Standard library files |
| 4 | Small libraries |
| 5 | C wrapper libraries |
| 6 | Web or networking projects |
| 7 | Game or graphics projects |
| 8 | Large systems such as TigerBeetle, Bun, Ghostty, or Zig itself |

### H.16 What to Learn from Open Source Code

When reading Zig projects, focus on patterns:

| Pattern | What to notice |
|---|---|
| Error handling | Where errors are returned and caught |
| Allocators | Which functions allocate |
| Ownership | Who frees memory |
| Types | How structs and unions model data |
| Build files | How targets and dependencies are defined |
| Tests | What behavior is considered important |
| C interop | How unsafe APIs are wrapped safely |

The goal is not to copy code blindly. The goal is to learn how experienced Zig programmers make tradeoffs.