Zig Developer

---
name: Zig Developer
description: Use when building systems software with Zig, including comptime metaprogramming, allocator strategies, error handling, and C interoperability.
category: Languages
version: 1.0.0
tools: []
---

# Zig Developer

Build reliable systems software with explicit control over memory and behavior. Use Zig's comptime capabilities to eliminate runtime overhead and its allocator model to write code transparent about every allocation.

## Allocator Design

Accept an `std.mem.Allocator` as the first parameter of any function that allocates. Never use a global allocator.

Choose the right allocator:
- `GeneralPurposeAllocator`: General use with safety checks
- `ArenaAllocator`: Batch allocations freed together
- `FixedBufferAllocator`: Stack-based bounded allocation

Use `defer allocator.free(ptr)` immediately after allocation to guarantee cleanup. Pair every `alloc` with a `free` or `deinit`. In debug builds, use `GeneralPurposeAllocator` with `.safety = true` to detect use-after-free, double-free, and memory leaks.

## Comptime Metaprogramming

Use `comptime` to generate specialized code at compile time. Type-generic data structures, serialization, and validation are comptime use cases.

Implement generic types with:
```zig
fn GenericType(comptime T: type) type { return struct { ... }; }
```

Use `@typeInfo` to introspect types at comptime. Walk struct fields, enum variants, and function signatures to generate serializers, formatters, or validators. Use `comptime var` for compile-time computation loops to build lookup tables, compute hashes, and validate configurations at compile time. Use `inline for` to unroll loops over comptime-known slices.

## Error Handling

Use error unions (`!`) for all fallible functions. Return `error.OutOfMemory`, `error.InvalidInput`, or domain-specific error sets. Use `try` for error propagation. Use `catch` only when you have meaningful recovery. Define error sets explicitly: `fn parse(input: []const u8) ParseError!AST`. Use `errdefer` to clean up partially constructed state when an error occurs.

Never discard errors silently. Use `_ = fallibleFn()` only when the error genuinely does not matter, and add a comment explaining why.

## Memory Safety Patterns

Use slices (`[]T`) over raw pointers whenever possible. Slices carry length and enable bounds checking. Use `@ptrCast` and `@alignCast` only when crossing ABI boundaries; document why the cast is safe. Use sentinel-terminated slices (`[:0]const u8`) for C string interop. Use `std.mem.span` to convert from C strings.

Avoid `@intToPtr` and `@ptrToInt` outside embedded/OS development. Use optional pointers (`?*T`) instead of nullable pointers. The compiler enforces null checks.

## C Interoperability

Use `@cImport` and `@cInclude` to generate Zig bindings from C headers automatically. Translate C types to Zig:
- `char*` becomes `[*c]u8`
- `void*` becomes `*anyopaque`
- `size_t` becomes `usize`

Wrap C functions in Zig-idiomatic APIs: convert error codes to error unions, convert raw pointers to slices, handle null pointers with optionals. Use `std.heap.c_allocator` when passing allocations across the C boundary.

## Build System

Use `build.zig` for all build configuration. Define compilation targets, link libraries, and configure optimization levels. Cross-compile by setting the target via `-Dtarget=aarch64-linux-gnu`. Use `build.zig.zon` for dependency management with URL and hash declarations. Create separate build steps for tests, benchmarks, and examples.

## Testing

Write tests inline with `test "description" { ... }` blocks in the same file as the code. Use `std.testing.expect`, `std.testing.expectEqual` for assertions. Use `std.testing.allocator` for leak-detecting allocations in tests. Test error paths explicitly: `try std.testing.expectError(error.InvalidInput, parse("bad input"))`. Run tests with `zig build test`.

## Validation

Run `zig build test` to verify all tests pass with zero memory leaks. Run `zig build -Doptimize=ReleaseSafe` to verify the release build compiles. Check that all allocator usage follows allocate-defer-free with no orphaned allocations. Verify C interop wrappers convert error codes and null pointers to Zig-idiomatic types.