How to Install Zig on Debian: The General-Purpose Systems Programming Language

Zig is a general-purpose systems programming language and toolchain for building robust, optimal and reusable software. It aims to be a modern alternative to C, with no hidden control flow, no hidden memory allocations, compile-time code execution (comptime) instead of a preprocessor or macros, and first-class cross-compilation out of the box.

Zig moves fast, and each release brings meaningful language and standard-library changes. That is precisely why the version shipped in Debian’s official repositories tends to lag well behind upstream, and on older releases it may be absent altogether. Building the compiler from source is possible but pulls in a full LLVM toolchain and a lot of patience.

The unofficial deb.griffo.io repository solves this by providing a prebuilt, up-to-date Zig package that installs and updates cleanly with apt. This guide walks through the whole process on Debian.

Install the Latest Zig on Debian: The Short Version

If you only came for the commands, this adds the repository and installs the latest Zig .deb package on Debian:

sudo install -d -m 0755 /etc/apt/keyrings
curl -fsSL https://deb.griffo.io/EA0F721D231FDD3A0A17B9AC7808B4DD62C41256.asc | sudo gpg --dearmor --yes -o /etc/apt/keyrings/deb.griffo.io.gpg
echo "deb [signed-by=/etc/apt/keyrings/deb.griffo.io.gpg] https://deb.griffo.io/apt $(lsb_release -sc 2>/dev/null) main" | sudo tee /etc/apt/sources.list.d/deb.griffo.io.list > /dev/null
sudo apt update
sudo apt install zig

The rest of this guide explains what each command does, how to verify the install, how to keep Zig up to date, and what to check when something goes wrong.

What Makes Zig Special?

  • 🧠 Compile-time code execution — comptime runs ordinary Zig at compile time, replacing macros, generics and build scripts with one consistent mechanism.
  • 🌍 First-class cross-compilation — target another OS or architecture with a single -target flag; no separate cross-toolchain to install.
  • 🔍 No hidden control flow — no exceptions, no operator overloading surprises; if you see a function call, it is a function call.
  • 🧹 Manual, explicit memory — allocators are passed as values, making allocation strategy visible and testable.
  • 🔧 A drop-in C/C++ compiler — zig cc and zig c++ wrap Clang, so Zig can build existing C and C++ projects too.
  • 🧪 Built-in testing — test blocks live next to your code and run with zig test or zig build test.
  • 📦 Integrated build system — build.zig is written in Zig itself, no external build tool required.
  • ⚡ Small, fast binaries — several optimisation modes including ReleaseSmall and ReleaseFast.

Why Use the deb.griffo.io Repository?

  • Easy installation and updates straight through the APT package manager.
  • Automatic dependency management handled by the Debian packaging.
  • Always tracks upstream releases, so you get current Zig instead of a stale snapshot.
  • No compiling from source and no LLVM build to babysit.
  • Works across supported Debian releases — Bookworm, Trixie and Sid.

Prerequisites

Before you begin, make sure you have:

  • A Debian-based system (Bookworm 12, Trixie 13, or Sid)
  • sudo privileges
  • curl installed (sudo apt install curl if it is missing)

Step 1: Add the deb.griffo.io Repository

Run the following commands to register the repository’s signing key and source list:

# Create the keyrings directory
sudo install -d -m 0755 /etc/apt/keyrings

# Download and install the repository GPG key
curl -fsSL https://deb.griffo.io/EA0F721D231FDD3A0A17B9AC7808B4DD62C41256.asc | sudo gpg --dearmor --yes -o /etc/apt/keyrings/deb.griffo.io.gpg

# Add the repository (auto-detects your distro codename)
echo "deb [signed-by=/etc/apt/keyrings/deb.griffo.io.gpg] https://deb.griffo.io/apt $(lsb_release -sc 2>/dev/null) main" | sudo tee /etc/apt/sources.list.d/deb.griffo.io.list > /dev/null

# Update the package list
sudo apt update

What each step does:

  1. Keyrings directory — creates /etc/apt/keyrings with sane permissions to hold third-party signing keys.
  2. GPG key — downloads the repository key and stores it in de-armoured form for APT to verify packages against.
  3. Source list — adds the repository, using lsb_release -sc to detect your Debian codename automatically.
  4. Update — refreshes APT’s package index so the new packages become visible.

Step 2: Update the Package List

If you skipped the final command above, refresh the index now:

sudo apt update

Step 3: Install Zig

sudo apt install zig

APT resolves any dependencies and installs the latest packaged Zig toolchain.

Step 4: Verify the Installation

Zig’s version subcommand takes no dashes — it is simply zig version:

zig version

You should see something similar to:

0.14.1

For a fuller picture of the environment the compiler detected, run zig env.

Getting Started with Zig

Hello, World

Create hello.zig:

const std = @import("std");

pub fn main() void {
    std.debug.print("Hello from Zig on Debian!\n", .{});
}

Run it directly without a separate compile step:

zig run hello.zig

Or produce a standalone binary:

zig build-exe hello.zig
./hello

Starting a Project with the Build System

zig init scaffolds a project with a build.zig, a build.zig.zon manifest and a src/ tree:

mkdir myapp && cd myapp
zig init

# Build the project
zig build

# Build and run in one step
zig build run

# Run the test suite
zig build test

The generated build.zig is ordinary Zig code, so your build logic and your program share one language.

Writing Tests

Tests live alongside your source. Given math.zig:

const std = @import("std");

pub fn add(a: i32, b: i32) i32 {
    return a + b;
}

test "add sums two integers" {
    try std.testing.expectEqual(@as(i32, 5), add(2, 3));
}

Run it with:

zig test math.zig

Cross-Compilation

This is one of Zig’s headline features. Build a Windows executable from your Debian box without installing anything extra:

# Windows x86_64
zig build-exe hello.zig -target x86_64-windows

# 64-bit ARM Linux
zig build-exe hello.zig -target aarch64-linux

# List every target Zig knows about
zig targets | less

Using Zig as a C Compiler

zig cc is a full Clang-backed C compiler with the same cross-compilation superpowers:

# Compile a C file
zig cc -o demo demo.c

# Cross-compile that same C file for ARM
zig cc -target aarch64-linux -o demo-arm demo.c

Formatting Code

Keep your sources tidy with the built-in formatter:

# Format a file in place
zig fmt hello.zig

# Check formatting without writing (useful in CI)
zig fmt --check src/

Keeping Zig Updated

Because Zig now lives in APT, updates arrive with the rest of your system:

sudo apt update && sudo apt upgrade

Other Tools from deb.griffo.io

The same repository packages plenty of other modern developer tools for Debian:

  • Helix — a post-modern modal text editor with built-in LSP, great for Zig.
  • Zellij — a terminal workspace and multiplexer with batteries included.
  • Lazydocker — a simple terminal UI for Docker and docker-compose.
  • Yazi — a blazing-fast terminal file manager written in Rust.

Troubleshooting

GPG or Key Errors

If APT complains that the repository is not signed or the key cannot be verified, re-add the key:

sudo install -d -m 0755 /etc/apt/keyrings
curl -fsSL https://deb.griffo.io/EA0F721D231FDD3A0A17B9AC7808B4DD62C41256.asc | sudo gpg --dearmor --yes -o /etc/apt/keyrings/deb.griffo.io.gpg
sudo apt update

Package Not Found

If apt install zig reports that the package is unavailable:

  1. Make sure you ran sudo apt update after adding the repository.
  2. Confirm your release is supported (Bookworm, Trixie or Sid).
  3. Inspect the source list to check the codename was detected correctly:
cat /etc/apt/sources.list.d/deb.griffo.io.list

zig version Fails or Reports the Wrong Version

If you previously installed Zig by unpacking a tarball into /usr/local/bin or ~/.local/bin, that copy may shadow the APT one. Check which binary is first on your PATH:

which zig
type -a zig

Remove or rename the stray copy, then open a new shell so the APT-managed zig takes precedence.

Uninstalling

# Remove the Zig package
sudo apt remove zig

# Optionally remove the repository entirely
sudo rm -f /etc/apt/sources.list.d/deb.griffo.io.list
sudo rm -f /etc/apt/keyrings/deb.griffo.io.gpg
sudo apt update

Conclusion

Zig gives you a lean, explicit systems language with cross-compilation and a C compiler bundled in, and the deb.griffo.io repository keeps that toolchain current on Debian without any manual tarball juggling. Install it once with apt, and future releases arrive through the same apt upgrade you already run.

Whether you are writing bare-metal firmware, replacing a C build, or just exploring comptime, having an up-to-date compiler a single command away removes a lot of friction.

Frequently Asked Questions

How do I install the latest Zig on Debian?

Add the deb.griffo.io APT repository and its signing key, then run sudo apt install zig. The repository tracks upstream Zig releases, so you get the latest packaged version rather than a build frozen when your distribution was released.

Is there a .deb package for Zig?

Yes. deb.griffo.io publishes Zig as a signed .deb for Debian. You could download that .deb and install it by hand, but adding the repository is the better option: APT then resolves dependencies and picks up new versions on its own.

How do I update Zig to the latest version?

Run sudo apt update && sudo apt upgrade. Once Zig is installed from APT there is no separate updater to remember, since new releases arrive with the rest of your system updates.

How do I install Zig on Ubuntu?

Exactly the same way; lsb_release -sc simply resolves to a different codename. There is a companion guide with the Ubuntu specifics: How to install Zig on Ubuntu.

Which Debian releases are supported?

Bookworm 12, Trixie 13 and Sid. Because the repository line is built from lsb_release -sc, the matching suite is selected for you.

Resources

Disclaimer: The deb.griffo.io repository is an unofficial community project and is not affiliated with the official Debian or Ubuntu projects, or with the upstream Zig project.