Release Modes em Zig — O que é e Como Usar

Definição

Release modes (modos de compilação) em Zig controlam o nível de otimização e as verificações de segurança do binário gerado. Zig oferece quatro modos: Debug (padrão), ReleaseSafe, ReleaseFast e ReleaseSmall. Cada modo representa um trade-off diferente entre performance, tamanho do binário e verificações de segurança em runtime.

Por que Release Modes Importam

1. Desenvolvimento vs Produção: Debug para desenvolvimento, Release para distribuição.
2. Performance: ReleaseFast pode ser 10-100x mais rápido que Debug.
3. Segurança: ReleaseSafe mantém verificações mesmo com otimizações.
4. Tamanho: ReleaseSmall minimiza o binário para embarcados e WASM.

Os Quatro Modos

Exemplo Prático

Compilação com Diferentes Modos

# Debug (padrão) — sem otimização, com safety
zig build-exe src/main.zig

# ReleaseSafe — otimizado + safety checks
zig build-exe src/main.zig -O ReleaseSafe

# ReleaseFast — máxima performance
zig build-exe src/main.zig -O ReleaseFast

# ReleaseSmall — menor binário possível
zig build-exe src/main.zig -O ReleaseSmall

# Via sistema de build
zig build -Doptimize=ReleaseFast

Comportamento de Safety Checks

const std = @import("std");

pub fn main() void {
    var array = [_]u8{ 1, 2, 3 };

    // Em Debug e ReleaseSafe: panic com stack trace
    // Em ReleaseFast e ReleaseSmall: undefined behavior
    const indice: usize = 5;
    _ = array[indice]; // Acesso fora dos limites!
}

Detectar Modo em Comptime

const std = @import("std");
const builtin = @import("builtin");

pub fn main() void {
    const modo = switch (builtin.mode) {
        .Debug => "Debug",
        .ReleaseSafe => "ReleaseSafe",
        .ReleaseFast => "ReleaseFast",
        .ReleaseSmall => "ReleaseSmall",
    };
    std.debug.print("Modo de compilação: {s}\n", .{modo});

    // Código condicional por modo
    if (builtin.mode == .Debug) {
        std.debug.print("Modo debug — verificações extras ativas\n", .{});
    }
}

Verificações de Safety

Verificações presentes em Debug e ReleaseSafe, ausentes em ReleaseFast e ReleaseSmall:

• Bounds checking: Acesso fora dos limites de arrays/slices
• Integer overflow: Overflow de aritmética inteira
• Null pointer: Desreferência de ponteiro nulo (optional unwrap)
• Unreachable: Alcançar código marcado como unreachable
• Alignment: Acesso com alinhamento incorreto

Armadilhas Comuns

• Testar apenas em Debug: Bugs que dependem de timing ou otimização podem não aparecer em Debug. Teste em ReleaseSafe também.
• Assumir safety em Release: ReleaseFast remove safety checks. Bugs silenciosos podem corromper memória. Prefira ReleaseSafe em produção quando possível.
• Benchmark em Debug: Nunca meça performance em modo Debug — o código não é otimizado.
• ReleaseSmall e performance: ReleaseSmall otimiza para tamanho, não velocidade. Pode ser mais lento que ReleaseFast.

Termos Relacionados

• build.zig — Onde o modo é configurado
• zig build — Flag -Doptimize= seleciona o modo
• Cross-Compilation — Modo se combina com target
• Unreachable — Comportamento varia por modo

Tutoriais Relacionados

• Zig Build System
• Performance em Zig
• Introdução ao Zig