Zig 2025 : l’alternative moderne au C pour systèmes critiques

Zig émerge comme l'alternative moderne à C en 2025, offrant sécurité mémoire, simplicité et interopérabilité C directe. Utilisé par Bun, TigerBeetle et d'autres projets critiques, Zig se positionne comme le langage systems du futur.

🚀 Pourquoi Zig ?

Zig résout les problèmes de C tout en conservant sa philosophie : contrôle total, performance maximale, et simplicité.

Les promesses de Zig

// hello.zig - Simplicité extrême
const std = @import("std");

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();
    try stdout.print("Hello from Zig!\n", .{});
}

# Compilation ultra-simple
zig build-exe hello.zig

# Cross-compilation native (aucun setup nécessaire !)
zig build-exe hello.zig -target x86_64-linux
zig build-exe hello.zig -target aarch64-macos
zig build-exe hello.zig -target wasm32-wasi

Philosophie Zig vs C vs Rust

💡 Concepts Fondamentaux de Zig

Gestion mémoire explicite

const std = @import("std");

pub fn main() !void {
    // Allocator explicite (pas de malloc() global)
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit(); // Cleanup automatique avec defer

    const allocator = gpa.allocator();

    // Allocation dynamique
    const buffer = try allocator.alloc(u8, 1024);
    defer allocator.free(buffer); // Libération automatique

    // Remplir le buffer
    @memset(buffer, 0);

    // ArrayList (comme vector en C++)
    var list = std.ArrayList(i32).init(allocator);
    defer list.deinit();

    try list.append(42);
    try list.append(100);

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

Gestion d'erreurs avec Error Unions

// Définir des erreurs
const FileError = error{
    FileNotFound,
    PermissionDenied,
    OutOfMemory,
};

// Fonction retournant Error Union
fn readFile(path: []const u8, allocator: std.mem.Allocator) ![]u8 {
    const file = std.fs.cwd().openFile(path, .{}) catch |err| {
        // Gestion d'erreur explicite
        return switch (err) {
            error.FileNotFound => FileError.FileNotFound,
            error.AccessDenied => FileError.PermissionDenied,
            else => err,
        };
    };
    defer file.close();

    // Lecture avec propagation d'erreur automatique (try)
    const content = try file.readToEndAlloc(allocator, 1024 * 1024);
    return content;
}

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();

    const allocator = gpa.allocator();

    // Gestion d'erreur avec catch
    const content = readFile("data.txt", allocator) catch |err| {
        std.debug.print("Error reading file: {}\n", .{err});
        return;
    };
    defer allocator.free(content);

    std.debug.print("File content: {s}\n", .{content});
}

Comptime : Métaprogrammation compile-time

// Comptime = code exécuté à la compilation
fn fibonacci(n: u32) u32 {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

// Calculé à la compilation !
const fib_10 = comptime fibonacci(10); // 55

// Fonction générique avec comptime
fn max(comptime T: type, a: T, b: T) T {
    return if (a > b) a else b;
}

pub fn main() void {
    const max_int = max(i32, 10, 20);      // 20
    const max_float = max(f64, 3.14, 2.71); // 3.14

    std.debug.print("Max int: {}, Max float: {d}\n", .{ max_int, max_float });
}

// Génération de code à la compilation
fn generateStruct(comptime fields: []const []const u8) type {
    return struct {
        // Code généré dynamiquement !
        inline for (fields) |field| {
            @field(@This(), field, i32) = 0;
        }
    };
}

const MyStruct = generateStruct(&[_][]const u8{ "x", "y", "z" });

Interopérabilité C native

// Zig peut importer des headers C directement
const c = @cImport({
    @cInclude("stdio.h");
    @cInclude("stdlib.h");
});

pub fn main() void {
    // Appeler des fonctions C
    _ = c.printf("Hello from C printf!\n");

    // Malloc/free C
    const ptr = c.malloc(100);
    defer c.free(ptr);

    // Utiliser des structs C
    var point: c.struct_point = .{ .x = 10, .y = 20 };
    _ = point;
}

// Exporter une fonction Zig pour C
export fn add(a: i32, b: i32) i32 {
    return a + b;
}

// Peut être appelée depuis C:
// extern int add(int a, int b);

🔧 Exemples Pratiques

HTTP Server en Zig

const std = @import("std");
const net = std.net;

pub fn main() !void {
    const address = try net.Address.parseIp("127.0.0.1", 8080);

    var server = net.StreamServer.init(.{});
    defer server.deinit();

    try server.listen(address);
    std.debug.print("Server listening on {}\n", .{address});

    while (true) {
        const connection = try server.accept();
        // Gérer la connexion dans un thread
        _ = try std.Thread.spawn(.{}, handleClient, .{connection});
    }
}

fn handleClient(connection: net.StreamServer.Connection) !void {
    defer connection.stream.close();

    var buf: [1024]u8 = undefined;
    const bytes_read = try connection.stream.read(&buf);

    std.debug.print("Request: {s}\n", .{buf[0..bytes_read]});

    // Réponse HTTP simple
    const response =
        \\HTTP/1.1 200 OK
        \\Content-Type: text/html
        \\
        \\<html><body><h1&gt;Hello from Zig!</h1&gt;</body></html>
    ;

    try connection.stream.writeAll(response);
}

JSON parsing

const std = @import("std");

const User = struct {
    name: []const u8,
    age: u32,
    email: []const u8,
};

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    const json_str =
        \\{
        \\  "name": "Alice",
        \\  "age": 30,
        \\  "email": "alice@example.com"
        \\}
    ;

    // Parse JSON
    const parsed = try std.json.parseFromSlice(
        User,
        allocator,
        json_str,
        .{}
    );
    defer parsed.deinit();

    const user = parsed.value;
    std.debug.print("User: {s}, age: {}, email: {s}\n",
        .{ user.name, user.age, user.email });

    // Serialize to JSON
    var buffer = std.ArrayList(u8).init(allocator);
    defer buffer.deinit();

    try std.json.stringify(user, .{}, buffer.writer());

    std.debug.print("JSON: {s}\n", .{buffer.items});
}

Concurrent programming

const std = @import("std");

fn worker(id: u32, counter: *std.atomic.Value(u32)) void {
    var i: u32 = 0;
    while (i moins de 1000) : (i += 1) {
        // Incrémentation atomique
        _ = counter.fetchAdd(1, .Monotonic);
    }
    std.debug.print("Worker {} done\n", .{id});
}

pub fn main() !void {
    var counter = std.atomic.Value(u32).init(0);

    // Créer 10 threads
    var threads: [10]std.Thread = undefined;

    for (&threads, 0..) |*thread, i| {
        thread.* = try std.Thread.spawn(.{}, worker, .{ i, &counter });
    }

    // Attendre tous les threads
    for (threads) |thread| {
        thread.join();
    }

    std.debug.print("Final count: {}\n", .{counter.load(.Monotonic)});
    // Output: Final count: 10000
}

📊 Performances Zig vs C vs Rust

Benchmarks compilation

# Simple program (1000 lines)
Zig:   0.3s
C:     0.8s (gcc -O3)
Rust:  2.1s (release mode)

# Medium project (10K lines)
Zig:   1.2s
C:     3.5s
Rust:  12.8s

# Zig compile ~10x plus vite que Rust

Runtime performance

Fibonacci(40) benchmark:

C (gcc -O3):        0.42s
Zig (release):      0.41s
Rust (release):     0.40s

Différence: négligeable (±2%)
Conclusion: performance identique à C/Rust

Binary size

# Hello World program

C:          8 KB
Zig:       12 KB
Rust:     450 KB (sans optimisation de taille)
Rust:      95 KB (avec strip et opt-level="z")

# Zig produit des binaires compacts

🎯 Projets Réels Utilisant Zig

Bun : JavaScript runtime

// Bun utilise Zig pour ses parties critiques
// Exemple simplifié du transpiler JavaScript

const std = @import("std");

pub const Transpiler = struct {
    allocator: std.mem.Allocator,

    pub fn init(allocator: std.mem.Allocator) Transpiler {
        return .{ .allocator = allocator };
    }

    pub fn transpile(self: *Transpiler, source: []const u8) ![]u8 {
        // Transpile JSX/TS vers JS
        var output = std.ArrayList(u8).init(self.allocator);
        errdefer output.deinit();

        // Parsing et transformation
        try output.appendSlice(source);

        return output.toOwnedSlice();
    }
};

// Performance: 20x plus rapide que esbuild (Go)

TigerBeetle : Database

// TigerBeetle: base de données financière en Zig
// Performance: 1M+ transactions/seconde

const Account = struct {
    id: u128,
    balance: i64,
    ledger: u32,
    code: u16,
    flags: u16,
    timestamp: u64,
};

pub fn transfer(
    from_account: *Account,
    to_account: *Account,
    amount: i64
) !void {
    if (from_account.balance < amount) {
        return error.InsufficientFunds;
    }

    from_account.balance -= amount;
    to_account.balance += amount;

    // Atomicité garantie par l'architecture
}

Autres projets notables

• Ghostty : Terminal emulator ultra-rapide
• Mach Engine : Game engine
• Zed (partiellement) : Code editor
• River : Wayland compositor

🔍 Zig vs Rust : Le Débat

Quand choisir Zig ?

// Zig: simplicité et contrôle

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();

    const data = try allocator.alloc(u8, 1024);
    defer allocator.free(data);

    // Code simple et lisible
    // Gestion mémoire explicite mais claire
}

Quand choisir Rust ?

// Rust: sécurité maximale à la compilation

fn main() {
    let data: Vec<u8&gt; = vec![0; 1024];

    // Borrow checker empêche erreurs à la compilation
    // Mais courbe d'apprentissage élevée
}

Comparaison philosophique

Zig : "La simplicité est la sophistication ultime"

• Erreurs runtime explicites
• Contrôle total
• Courbe apprentissage douce

Rust : "Sécurité sans compromis"

• Erreurs compilation
• Abstractions zéro-cost
• Courbe apprentissage élevée

🛠️ Tooling et Écosystème

Package manager : Zig build system

// build.zig - système de build intégré
const std = @import("std");

pub fn build(b: *std.Build) void {
    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});

    const exe = b.addExecutable(.{
        .name = "myapp",
        .root_source_file = .{ .path = "src/main.zig" },
        .target = target,
        .optimize = optimize,
    });

    // Ajouter dépendances
    const http = b.dependency("http", .{
        .target = target,
        .optimize = optimize,
    });
    exe.addModule("http", http.module("http"));

    b.installArtifact(exe);

    // Commandes custom
    const run_cmd = b.addRunArtifact(exe);
    const run_step = b.step("run", "Run the app");
    run_step.dependOn(&run_cmd.step);

    // Tests
    const tests = b.addTest(.{
        .root_source_file = .{ .path = "src/main.zig" },
        .target = target,
        .optimize = optimize,
    });

    const test_step = b.step("test", "Run tests");
    test_step.dependOn(&b.addRunArtifact(tests).step);
}

# Commandes build
zig build                 # Build en mode debug
zig build -Doptimize=ReleaseFast  # Release optimisé
zig build test            # Run tests
zig build run             # Build + run

# Cross-compilation facile
zig build -Dtarget=x86_64-linux
zig build -Dtarget=aarch64-macos
zig build -Dtarget=wasm32-wasi

ZLS : Language Server

// .vscode/settings.json
{
  "zig.path": "/usr/local/bin/zig",
  "zig.zls.enabled": true,
  "zig.zls.path": "/usr/local/bin/zls"
}

🚨 Limitations et Considérations

Zig n'est pas stable (0.13.0 en 2025)

⚠️ Breaking changes possibles entre versions
⚠️ API standard library peut changer
⚠️ Pas de garantie de stabilité avant 1.0

Recommandation: OK pour nouveaux projets,
attention pour production critique

Écosystème jeune

Comparaison packages (2025):

Rust (crates.io):     150 000+ packages
Zig (builtin deps):    ~2 000 packages
C (system libs):      Mature mais dispersé

Zig: écosystème grandissant mais limité

Courbe d'apprentissage

Concepts uniques à maîtriser:
- comptime (métaprogrammation)
- Allocators explicites
- Error unions
- Undefined behavior explicite

Temps d'apprentissage: ~2-4 semaines
(vs Rust: 3-6 mois)

🔮 Conclusion

Zig représente l'équilibre parfait entre simplicité C et sécurité Rust. En 2025, Zig est prêt pour la production dans des cas d'usage spécifiques.

Utilisez Zig si :

• Vous écrivez du code systems (OS, drivers, embedded)
• Performance maximale requise
• Interopérabilité C critique
• Vous voulez simplicité + contrôle

Restez sur C si :

• Projet legacy stable
• Écosystème mature requis
• Équipe non formée

Choisissez Rust si :

• Sécurité mémoire compile-time obligatoire
• Écosystème riche nécessaire
• Application web/CLI moderne

Zig est l'avenir du systems programming pour développeurs valorisant simplicité et performance. Avec Bun, TigerBeetle et d'autres adoptions majeures, Zig prouve sa viabilité en production. La version 1.0 attendue en 2026 marquera sa maturité complète.

Articles connexes

Pour approfondir le sujet, consultez également ces articles :

• JetBrains Developer Ecosystem 2025 : TypeScript, Rust et Go en tête, Docker explose +17%
• Rust en 2025 : Le Langage qui Révolutionne la Programmation Système
• Accessibilité Web (WCAG) : Le guide complet du développeur 2025