Zig: a linguagem que está fazendo times migrarem do Rust em 2026

O que é Zig

Zig é uma linguagem de programação de sistemas de baixo nível, criada por Andrew Kelley em 2016. O objetivo é simples e ambicioso ao mesmo tempo: ser uma alternativa moderna ao C, sem as complexidades do C++ e sem o modelo de borrow checker do Rust.

A linguagem ganhou destaque nos últimos meses depois que o time do Roc, uma linguagem de programação funcional criada por Richard Feldman, publicou um relato detalhado de como está indo a reescrita do compilador Roc de Rust para Zig. O post viralizou no Hacker News com centenas de comentários, reacendendo o debate sobre quando Zig faz sentido no lugar do Rust.

O lema do Zig resume bem a proposta: "nenhum fluxo de controle oculto, nenhuma alocação implícita de memória, nenhuma macro, nenhuma pré-processagem". Cada linha de código Zig faz exatamente o que parece fazer, sem surpresas.

Como funciona

Zig é compilado direto para código nativo usando LLVM como backend, o que garante performance comparável ao C. A linguagem não tem garbage collector nem runtime, sendo ideal para sistemas embarcados, ferramentas de linha de comando, compiladores e qualquer código onde você precisa de controle total da memória.

Um conceito central é o gerenciamento explícito de alocadores. Em vez de ter um alocador global implícito, cada função que precisa alocar memória recebe um Allocator como parâmetro. Isso pode parecer verboso no início, mas torna o código muito mais previsível e testável.

O tratamento de erros é outro diferencial: em vez de exceções, Zig usa error unions. Uma função retorna !T, que pode ser um valor do tipo T ou um erro. O compilador obriga você a tratar todos os erros, mas de forma muito mais simples que o Rust.

Principais recursos

O comptime é provavelmente o recurso mais poderoso do Zig. Ele permite executar código arbitrário em tempo de compilação, eliminando a necessidade de macros ou templates complicados. Você escreve código Zig normal, e o compilador executa na hora da compilação.

A interoperabilidade com C é nativa e trivial. Com @cImport você importa headers C diretamente no código Zig, sem precisar escrever bindings manualmente. Além disso, zig cc é um compilador C/C++ completo baseado em Clang, ou seja, você pode usar Zig como substituto do GCC imediatamente.

• Cross-compilation nativa: compile para qualquer plataforma de qualquer máquina, sem Docker, sem sysroot complicado
• Build system integrado: o arquivo build.zig substitui Makefile e CMake usando Zig puro
• Testes integrados: zig test roda os testes inline no próprio arquivo fonte
• Undefined behavior detectável: em modo Debug, Zig detecta integer overflow, null pointer e outros problemas em runtime

Como começar: instalação passo a passo

Instalar o Zig é simples. Basta baixar o binário do site oficial e colocar no PATH. Não há dependências externas, o LLVM já vem embutido no binário do compilador.

# macOS via Homebrew
brew install zig

# Windows via Scoop
scoop install zig

# Ou baixe o binário diretamente em ziglang.org/download
# e adicione ao PATH

# Verificar instalação
zig version

Após instalar, crie seu primeiro projeto com o comando init:

mkdir meu-projeto
cd meu-projeto
zig init

Isso cria o build.zig, o build.zig.zon (arquivo de dependências) e a pasta src/ com main.zig. Para compilar e rodar: zig build run.

Exemplo prático

Veja como o Zig trata erros e usa alocadores explícitos. Este código abre um arquivo, lê o conteúdo e imprime o número de bytes:

const std = @import("std");

pub fn main() !void {
    const allocator = std.heap.page_allocator;

    const file = try std.fs.cwd().openFile("dados.txt", .{});
    defer file.close();

    const conteúdo = try file.readToEndAlloc(allocator, 1024 * 1024);
    defer allocator.free(conteúdo);

    std.debug.print("Bytes lidos: {d}\n", .{conteúdo.len});
}

Repare no try antes de cada operação que pode falhar. Se a operação retornar um erro, ele é propagado automaticamente para a função chamadora. O defer garante que os recursos sejam liberados mesmo em caso de erro.

O comptime em ação: uma função genérica que aceita qualquer tipo numérico, sem templates complexos:

fn somar(comptime T: type, a: T, b: T) T {
    return a + b;
}

const r1 = somar(i32, 10, 20);   // 30
const r2 = somar(f64, 1.5, 2.5); // 4.0

Comparação com alternativas

A comparação mais comum é com Rust. Rust oferece garantias mais fortes de segurança de memória pelo borrow checker, mas tem curva de aprendizado mais íngreme e tempos de compilação maiores. Zig é mais simples, compila mais rápido e tem C interop mais fácil, mas depende mais da disciplina do programador.

Comparado ao C, Zig oferece muito mais sem aumentar a complexidade: tratamento de erros explícito, comptime, cross-compilation automática e build system moderno, tudo sem sacrificar previsibilidade.

O Go tem garbage collector, runtime e é focado em produtividade de servidor. Go é melhor para APIs e microsserviços. Zig é para código que precisa rodar próximo ao metal: compiladores, sistemas embarcados, game engines, ferramentas de sistema.

Pontos positivos e limitações

Pontos positivos: compilação cruzada simples e poderosa, C interop nativa via @cImport, comptime elimina macros, tempos de compilação mais rápidos que Rust, zero runtime, código muito previsível e legível para qualquer desenvolvedor.

Limitações reais: o ecossistema ainda é pequeno comparado ao Rust. O package manager do Zig está em fase inicial. A linguagem ainda está em versão 0.x, o que significa que APIs podem mudar entre versões menores do compilador.

Sem borrow checker, erros de use-after-free e double-free ainda são possíveis. Zig detecta muitos desses problemas em modo Debug via safety checks, mas em modo Release a responsabilidade é do programador.

Casos de uso reais

Compiladores e interpretadores: o caso mais comentado agora é a reescrita do compilador Roc de Rust para Zig. Times que escrevem compiladores valorizam o controle fino de memória e a C interop do Zig. O próprio compilador do Zig é escrito em Zig.

Sistemas embarcados e microcontroladores: Zig é uma escolha crescente para firmware porque não tem runtime, tem controle de alocação explícito e compila para arquiteturas ARM, RISC-V e outras sem complicação.

Ferramentas de linha de comando: CLIs que precisam processar grandes volumes de dados se beneficiam do zero overhead do Zig e da facilidade de distribuir binários estáticos sem dependências externas.

Game engines e gráficos: alguns projetos de game engine estão explorando Zig pela performance e pela integração simples com bibliotecas C de gráficos como SDL e OpenGL via @cImport.

Dicas e boas práticas

Vale a pena?

Zig vale a pena para quem já trabalha com C/C++ e quer modernizar o fluxo sem abraçar toda a complexidade do Rust. A proposta de valor é clara: linguagem simples, poderosa e previsível para código de sistemas, com ferramentas modernas incluídas.

Se você é dev de backend em Go, Python ou Node.js e quer aprender uma linguagem de baixo nível, Zig é uma introdução mais suave que Rust. A ausência do borrow checker torna a curva de aprendizado mais gentil, sem abrir mão de performance.

Para quem precisa de produção estável agora com ecossistema maduro, Rust ainda é a aposta mais segura. Mas se você tem apetite para explorar uma linguagem em crescimento, Zig está em um momento muito interessante, e o buzz de 2026 em torno das migrações Rust-para-Zig mostra que não é hype vazio.