Glossário Zig — Termos e Conceitos em Português

Referência rápida de todos os termos e conceitos importantes da linguagem Zig. Ideal para consulta durante seus estudos ou desenvolvimento.

Dica: Use Ctrl+F (ou Cmd+F no Mac) para buscar um termo específico.

A

Allocator

Objeto que gerencia alocação e desalocação de memória em Zig. Diferente de C (que usa malloc/free globais) ou linguagens com garbage collector, Zig exige que allocators sejam passados explicitamente como parâmetro. Os principais allocators são:

• GeneralPurposeAllocator (GPA): Allocator de uso geral com detecção de leaks e double-free
• ArenaAllocator: Aloca em bloco e libera tudo de uma vez — ideal para dados temporários
• FixedBufferAllocator: Aloca dentro de um buffer de tamanho fixo, sem usar heap
• PageAllocator: Aloca páginas diretamente do sistema operacional

Tutorial: Gerenciamento de Memória em Zig

ArrayList

Estrutura de dados dinâmica equivalente a std::vector em C++ ou Vec em Rust. Cresce automaticamente conforme elementos são adicionados. Em Zig, requer um allocator explícito: std.ArrayList(T).

Tutorial: Data Structures em Zig

Async/Await

Modelo de programação assíncrona em Zig baseado em coroutines. Permite escrever código concorrente sem callbacks ou threads explícitas. Nota: O suporte a async/await está sendo reimplementado nas versões recentes do Zig.

Tutorial: Async/Await em Zig

B

Build System (Sistema de Build)

Zig possui um sistema de build integrado na própria linguagem, configurado através do arquivo build.zig. Não necessita de ferramentas externas como CMake, Make ou Meson. Suporta cross-compilation nativa, integração com bibliotecas C e gerenciamento de dependências.

Tutorial: Zig Build System

build.zig

Arquivo de configuração do sistema de build do Zig, escrito na própria linguagem. Define como o projeto é compilado, quais dependências usa, e quais targets produz. Equivalente ao Cargo.toml do Rust ou CMakeLists.txt do C++.

build.zig.zon

Arquivo de manifesto do pacote Zig (em formato ZON — Zig Object Notation). Define metadados do pacote como nome, versão e dependências externas. Usado pelo gerenciador de pacotes do Zig.

Tutorial: Zig Packaging

Bloco (Block)

Expressão delimitada por {} que pode retornar um valor. Em Zig, blocos podem ter labels e serem usados como expressões:

const x = blk: {
    // ...
    break :blk valor;
};

C

Comptime (Compile-Time)

Uma das features mais poderosas do Zig. Permite executar código em tempo de compilação, eliminando a necessidade de macros, templates ou pré-processadores. Funções marcadas com comptime são avaliadas durante a compilação, gerando código otimizado sem overhead em runtime.

fn fibonacci(comptime n: u32) u32 {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}
// fibonacci(10) é calculado em tempo de compilação!

Tutorial: Comptime em Zig

Const

Palavra-chave para declarar uma constante (valor imutável). Em Zig, const é o padrão recomendado — use var apenas quando mutabilidade for necessária.

const nome = "Zig Brasil";  // imutável
var contador: u32 = 0;       // mutável

Cross-Compilation

Capacidade de compilar código para uma plataforma diferente da máquina host. Zig suporta cross-compilation nativa para mais de 30 arquiteturas sem necessidade de instalar toolchains adicionais.

zig build-exe main.zig -target x86_64-linux-gnu
zig build-exe main.zig -target aarch64-macos

D

Defer

Palavra-chave que agenda a execução de uma expressão para quando o escopo atual terminar. Garante que recursos sejam liberados mesmo em caso de erros. Equivalente ao defer em Go.

const file = try std.fs.cwd().openFile("dados.txt", .{});
defer file.close(); // sempre executado ao sair do escopo

Detectable Illegal Behavior

Comportamentos que Zig detecta e sinaliza como erro (diferente de C, que tem “undefined behavior”). Exemplos: acesso fora dos limites de um array, overflow de inteiros, uso de ponteiro nulo. Em modo de build safe, esses erros causam um panic com stack trace.

E

Enum

Tipo que define um conjunto fixo de valores nomeados. Em Zig, enums podem ter métodos e valores associados.

const Cor = enum { vermelho, verde, azul };

Tutorial: Structs, Enums e Unions

Error Set

Conjunto de valores de erro possíveis em Zig. Cada função pode declarar exatamente quais erros pode retornar.

const FileError = error{ NotFound, AccessDenied, EndOfStream };

Error Union

Tipo que pode conter um valor válido OU um erro. Representado pela sintaxe !. É o mecanismo principal de tratamento de erros em Zig — não existem exceções.

fn dividir(a: f64, b: f64) !f64 {
    if (b == 0) return error.DivisaoPorZero;
    return a / b;
}

Tutorial: Tratamento de Erros em Zig

Errdefer

Variante de defer que só executa quando o escopo termina com um erro. Útil para desfazer alocações parciais quando uma operação falha no meio.

const ptr = try allocator.create(Node);
errdefer allocator.destroy(ptr); // só executa se houver erro depois

F

FFI (Foreign Function Interface)

Interface para chamar código de outras linguagens (principalmente C). Zig tem interoperabilidade nativa com C — pode importar headers C diretamente e chamar funções C sem overhead.

Tutorial: Zig e C: Interoperabilidade

For Loop

Loop de iteração em Zig. Diferente de C, o for em Zig itera sobre slices e ranges:

for (items) |item| {
    // usa item
}
for (0..10) |i| {
    // i vai de 0 a 9
}

G

Generics (Genéricos)

Em Zig, generics são implementados através de comptime. Não existe sintaxe especial como <T> — em vez disso, tipos são passados como parâmetros comptime.

fn max(comptime T: type, a: T, b: T) T {
    return if (a > b) a else b;
}

GPA (GeneralPurposeAllocator)

O allocator de uso geral mais comum em Zig. Detecta memory leaks, double-free e use-after-free em modo debug. Recomendado para desenvolvimento e debugging.

H

HashMap

Estrutura de dados chave-valor em Zig (std.HashMap ou std.StringHashMap). Requer um allocator explícito e oferece complexidade O(1) amortizada para operações de busca.

Tutorial: Data Structures em Zig

I

Inline

Palavra-chave que força o compilador a expandir uma função no ponto de chamada (inlining). Também usada em inline for e inline while para desenrolar loops em tempo de compilação.

io_uring

Interface de I/O assíncrono de alta performance do Linux. Zig tem suporte nativo para io_uring, permitindo construir servidores de altíssimo throughput.

Tutorial: Zig Async I/O com io_uring

L

LLVM

Backend de compilação usado pelo Zig para gerar código de máquina otimizado. O mesmo backend usado por Clang (C/C++) e Rust. Garante performance comparável a C em código Zig.

M

Mutex

Mecanismo de sincronização para proteger dados compartilhados entre threads. Em Zig: std.Thread.Mutex.

Tutorial: Concorrência em Zig

O

Optional

Tipo que pode conter um valor ou null. Representado pela sintaxe ?. Obriga o programador a tratar explicitamente o caso nulo.

var nome: ?[]const u8 = null;
nome = "Zig";
if (nome) |n| {
    // n é []const u8, sem null
}

Orelse

Operador que fornece um valor padrão quando um optional é null:

const valor = optional_valor orelse 42;

P

Panic

Erro irrecuperável em Zig que encerra o programa com um stack trace. Ocorre em situações como acesso fora dos limites, overflow de inteiro (em safe mode) ou chamada explícita a @panic(). Diferente de exceções — não pode ser “capturado”.

Pointer (Ponteiro)

Referência ao endereço de memória de um valor. Zig distingue entre:

• *T — ponteiro para um único item
• [*]T — ponteiro para múltiplos itens (sem tamanho conhecido)
• []T — slice (ponteiro + tamanho)

S

Sentinel-Terminated

Arrays ou slices que terminam com um valor especial (sentinel). Strings em Zig são [:0]const u8 — slices de bytes terminados em null (zero), compatíveis com strings C.

Slice

Referência a uma porção contígua de um array, composta por um ponteiro e um comprimento. Tipo fundamental em Zig para manipulação de sequências de dados.

const arr = [_]u8{ 1, 2, 3, 4, 5 };
const slice = arr[1..4]; // [2, 3, 4]

Tutorial: Strings e Arrays em Zig

Struct

Tipo composto que agrupa dados relacionados. Em Zig, structs podem ter métodos, valores padrão e serem genéricos via comptime.

const Ponto = struct {
    x: f64,
    y: f64,

    pub fn distancia(self: Ponto, outro: Ponto) f64 {
        // ...
    }
};

Tutorial: Structs, Enums e Unions

T

Tagged Union

Union que armazena qual campo está ativo (discriminated union). Permite pattern matching seguro com switch:

const Resultado = union(enum) {
    sucesso: u32,
    erro: []const u8,
};

Try

Operador que propaga erros automaticamente. Se a expressão retorna um erro, a função atual retorna esse mesmo erro. Forma idiomática de tratar erros em Zig.

const file = try std.fs.cwd().openFile("config.txt", .{});
// Se openFile falhar, o erro é propagado para o chamador

Thread

Unidade de execução concorrente. Zig fornece std.Thread para criar e gerenciar threads, com suporte a mutexes e primitivas de sincronização.

Tutorial: Concorrência em Zig

U

Undefined

Valor especial usado para declarar variáveis sem inicializar:

var buffer: [1024]u8 = undefined;

Acessar uma variável undefined antes de atribuir um valor é detectable illegal behavior.

Union

Tipo que pode armazenar um de vários tipos de dados diferentes no mesmo espaço de memória. Em Zig, unions podem ser “tagged” (discriminated) para segurança.

Tutorial: Structs, Enums e Unions

Unreachable

Palavra-chave que indica ao compilador que um ponto do código nunca será alcançado. Ajuda na otimização e detecta bugs em modo safe:

switch (valor) {
    1 => // ...
    2 => // ...
    else => unreachable, // panic se alcançado em safe mode
}

V

Var

Palavra-chave para declarar variáveis mutáveis. Em Zig, prefer usar const sempre que possível — var só quando mutabilidade for realmente necessária.

W

WASM (WebAssembly)

Zig pode compilar diretamente para WebAssembly, permitindo executar código Zig no browser ou em ambientes serverless. O target é wasm32-freestanding.

Tutorial: Zig e WebAssembly

Z

Zig

Linguagem de programação de sistemas criada por Andrew Kelley em 2015. Projetada como uma alternativa moderna ao C, com foco em simplicidade, performance, segurança e legibilidade. Usa o backend LLVM para gerar código otimizado e suporta cross-compilation nativa para mais de 30 plataformas.

Saiba mais: O que é Zig?

ZON (Zig Object Notation)

Formato de dados nativo do Zig, similar a JSON mas usando sintaxe Zig. Usado em arquivos build.zig.zon para configuração de pacotes.

Zig Software Foundation (ZSF)

Organização sem fins lucrativos que mantém e desenvolve a linguagem Zig. Fundada em 2020, financia o desenvolvimento full-time da linguagem e suas ferramentas.

Leia Também

• O que é Zig? Guia Completo — Introdução completa à linguagem
• Zig para Iniciantes — Série de tutoriais do zero
• Por que Aprender Zig em 2026? — Razões para investir na linguagem