Zig Programming Language — Complete Guide

If you're a systems programmer—or want to become one—Zig is a language you cannot ignore. It is designed as a modern alternative to C, focusing on simplicity, performance, and control without hidden behavior.

---

1. What is Zig?

Zig is a low-level, general-purpose programming language designed for:

• Systems programming
• Embedded development
• Performance-critical applications

👉 Created by Andrew Kelley
👉 First released in 2015

---

2. Design Philosophy

Zig is built on a few strong principles:

---

1. No Hidden Control Flow

Unlike many languages:

• No hidden allocations
• No exceptions
• No implicit behavior

👉 Everything is explicit.

---

2. Manual Memory Management

Like C:

• You control memory
• No garbage collector

But safer and clearer.

---

3. Simplicity Over Abstraction

Zig avoids:

• Complex OOP systems
• Heavy abstractions

👉 Focus = clarity + control

---

4. Compile-Time Execution

Zig has powerful compile-time evaluation:

• Code can run at compile time
• Enables metaprogramming

---

3. Installing Zig

Download from:

👉 https://ziglang.org

Check version:

zig version

---

4. Your First Zig Program

const std = @import("std");

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

Run:

zig run main.zig

---

5. Basic Syntax

---

Variables

var x: i32 = 10;     // mutable
const y: i32 = 20;   // immutable

Type inference:

const a = 5;

---

Primitive Types

• Integers: i32, u64
• Float: f32, f64
• Boolean: bool
• Void: void

---

Control Flow

If

if (x > 10) {
    // do something
} else {
    // do something else
}

---

While

while (x < 100) {
    x += 1;
}

---

For

for (items) |item| {
    std.debug.print("{}\n", .{item});
}

---

6. Functions

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

---

Multiple Return (Error Union)

fn divide(a: i32, b: i32) !i32 {
    if (b == 0) return error.DivisionByZero;
    return a / b;
}

---

7. Error Handling (Very Important)

Zig does not use exceptions.

Instead:

---

Error Union

const result = divide(10, 2) catch 0;

---

Try Keyword

const result = try divide(10, 2);

👉 If error → return immediately

---

Error Sets

error{OutOfMemory, InvalidInput}

---

8. Pointers

Zig uses pointers like C, but safer.

var x: i32 = 10;
var ptr = &x;

Dereference:

ptr.* = 20;

---

Nullable Pointer

var ptr: ?*i32 = null;

---

9. Arrays and Slices

---

Array

var arr = [5]i32{1,2,3,4,5};

---

Slice (View into array)

var slice = arr[0..3];

👉 Slices are widely used in Zig

---

10. Structs

const Person = struct {
    name: []const u8,
    age: u8,
};

Usage:

var p = Person{ .name = "Ali", .age = 20 };

---

11. Enums

const Color = enum {
    Red,
    Green,
    Blue,
};

---

12. Memory Management

Zig uses allocators explicitly.

---

Example

const allocator = std.heap.page_allocator;

var memory = try allocator.alloc(i32, 10);
defer allocator.free(memory);

---

Key Idea

👉 You always know:

• Where memory comes from
• Who frees it

---

13. Defer Keyword

Runs code when scope ends:

defer std.debug.print("Done\n", .{});

---

14. Compile-Time Programming (Zig Superpower)

---

comptime

fn square(comptime x: i32) i32 {
    return x * x;
}

---

Example: Generate Code

inline for (0..5) |i| {
    std.debug.print("{}\n", .{i});
}

👉 Executed at compile time

---

15. No Preprocessor (Unlike C)

Zig replaces macros with:

• Functions
• comptime

👉 Cleaner and safer

---

16. Interoperability with C

Zig can directly use C code.

---

Import C

const c = @cImport({
    @cInclude("stdio.h");
});

---

👉 You can:

• Call C functions
• Use C libraries

---

17. Build System (Built-in)

Zig includes its own build system.

Example:

const std = @import("std");

pub fn build(b: *std.Build) void {
    const exe = b.addExecutable("app", "main.zig");
    exe.install();
}

Run:

zig build

---

18. Cross Compilation (Very Powerful)

Zig can compile for different platforms easily:

zig build-exe main.zig -target x86_64-linux

👉 No external toolchains needed

---

19. Testing in Zig

Built-in testing:

test "addition works" {
    try std.testing.expect(add(2,3) == 5);
}

Run:

zig test main.zig

---

20. Performance

Zig is:

• Comparable to C
• No runtime overhead
• Zero-cost abstractions

---

21. Zig vs C

Feature	C	Zig
Memory control	Yes	Yes
Safety	Low	Higher
Build system	External	Built-in
Error handling	Manual	Structured
Compile-time	Limited	Powerful

---

22. Zig vs Rust

Feature	Zig	Rust
Complexity	Low	High
Safety model	Manual	Ownership
Learning curve	Easier	Harder
Control	High	Medium

---

23. When to Use Zig

Use Zig for:

• OS development
• Game engines
• Embedded systems
• Custom databases
• High-performance tools

---

24. When NOT to Use Zig

Avoid if:

• You need large ecosystem
• You want rapid prototyping
• You prefer high-level abstractions

---

25. Real-World Use Cases

Zig is used in:

• Game development
• Compilers
• CLI tools
• Replacing C in systems

---

26. Roadmap to Master Zig

If you're serious:

---

Step 1: Basics

• Syntax
• Types
• Control flow

---

Step 2: Core Systems Concepts

• Memory management
• Pointers
• Allocators

---

Step 3: Advanced Zig

• comptime
• Error handling
• Build system

---

Step 4: Real Projects

• File parser
• HTTP server
• Database engine (perfect for you)

---

27. Final Thoughts

Zig is not trying to replace everything.

👉 It’s trying to fix what’s broken in C
👉 Without adding unnecessary complexity

---

Core Philosophy:

"No hidden control flow. No hidden memory allocations. No surprises."

---

If you're a C programmer building systems (like databases):

👉 Zig is one of the best next steps.