# Zig — General-Purpose Programming Language and Toolchain

> Zig is a general-purpose programming language and toolchain for maintaining robust, optimal, and reusable software. Simpler than C with no preprocessor, no hidden control flow, no hidden allocations. Also a drop-in C/C++ compiler with cross-compilation out of the box.

## Install

Save the content below to `.claude/skills/` or append to your `CLAUDE.md`:

## Quick Use

```bash
# Install
brew install zig                           # macOS
snap install zig --classic --beta          # Linux
# Or download from https://ziglang.org/download

zig version
```

Hello world:
```zig
const std = @import("std");

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();
    try stdout.print("Hello, {s}!", .{ "world" });
}
```

Build and run:
```bash
zig init-exe
zig build run
zig build test
zig build-exe src/main.zig -O ReleaseFast

# Cross-compile from any host
zig build-exe -target x86_64-linux-gnu src/main.zig
zig build-exe -target aarch64-macos src/main.zig

# Use Zig as a C/C++ compiler
zig cc -o app app.c
zig c++ -o app app.cpp
```

## Intro

Zig is a general-purpose programming language and toolchain for maintaining robust, optimal, and reusable software. Designed by Andrew Kelley starting in 2015, Zig aims to be a modern improvement over C: no hidden control flow, no hidden memory allocations, manual memory management with safety tools, and first-class cross-compilation. Zig is also a drop-in C/C++ compiler (via LLVM).

- **Repo**: https://github.com/ziglang/zig (the main repo, now mirrored from Codeberg)
- **Stars**: 42K+
- **License**: MIT

## What Zig Does

- **No hidden control flow** — no operator overloading, no exceptions, no implicit allocations
- **Manual memory with allocators** — all allocation is explicit; pass allocators as parameters
- **Comptime** — compile-time evaluation for generics, type reflection, code gen
- **Error union types** — `!T` return types replace exceptions
- **C ABI interop** — call C directly, compile C with `zig cc`
- **Cross-compile** — any target from any host, no extra toolchain
- **Build system** — `zig build` replaces make/cmake
- **Safety modes** — Debug, ReleaseSafe, ReleaseFast, ReleaseSmall
- **Async/await** — cooperative multitasking (frozen in recent versions)

## Architecture

Compiler built on top of LLVM (Zig also has a self-hosted backend in progress). Comptime is the star feature — Zig runs normal Zig code at compile time for generics, type transformation, and code generation. Zig cc uses Clang and bundled libc headers for turnkey C/C++ cross-compilation.

## Self-Hosting

Language toolchain.

## Key Features

- Simpler than C++, safer than C
- Explicit memory allocators
- Comptime metaprogramming
- Error union types
- Cross-compile everywhere
- Zig as a C/C++ compiler
- Build system built in
- Great stack traces in Debug mode
- WebAssembly target
- Bit-packed structs

## Comparison

| Language | Memory Model | Cross-Compile | Comptime |
|---|---|---|---|
| Zig | Manual + allocators | Trivial | First-class |
| Rust | Ownership | Harder | Limited (macros) |
| C | Manual | Hard | Preprocessor |
| C++ | Manual + RAII | Hard | Templates |
| Go | GC | Good | Limited |
| Odin | Manual | Good | Limited |

## FAQ

**Q: Zig vs Rust?**
A: Rust pursues compile-time memory safety (borrow checker); Zig pursues simplicity and readability, keeping manual memory management but adding tooling (GPA memory checker). Zig is easier to learn, Rust is safer.

**Q: Is it stable yet?**
A: Not yet at 1.0. Stability is improving rapidly in v0.13+. Production projects like Bun and TigerBeetle use it.

**Q: Why can it act as a C compiler?**
A: Zig ships LLVM + Clang + a complete set of libc headers, so `zig cc` can cross-compile C/C++ to any LLVM-supported target with zero config.

## Sources

- Docs: https://ziglang.org/documentation
- GitHub: https://github.com/ziglang/zig
- License: MIT

---
Source: https://tokrepo.com/en/workflows/zig-general-purpose-programming-language-toolchain-1b748d0a
Author: AI Open Source