Zig para Iniciantes: Primeiros Passos — Guia Completo 2026

Quer aprender Zig do zero mas não sabe por onde começar? Você está no lugar certo. Este é o primeiro artigo da série “Zig para Iniciantes”, projetada para levar você do completo zero até programar com confiança em Zig.

Neste guia, vamos cobrir tudo que você precisa para dar os primeiros passos com Zig: o que é a linguagem, como instalá-la, como escrever seu primeiro programa, e os conceitos fundamentais que todo iniciante precisa dominar.

🎯 Objetivo deste artigo: Ao final, você terá o Zig instalado, entenderá sua filosofia única, e terá escrito seus primeiros programas funcionais.

O Que é Zig? (Em 2 Minutos)

Zig é uma linguagem de programação de sistemas moderna, criada por Andrew Kelley em 2016. Ela foi projetada para ser uma alternativa melhor ao C — mantendo a simplicidade e o controle, mas eliminando classes de bugs comuns e adicionando recursos modernos.

Por Que Aprender Zig em 2026?

📈 Dado importante: Zig foi a 4ª linguagem mais admirada no Stack Overflow Survey 2025, com 64% de aprovação. Projetos como Bun (runtime JavaScript), TigerBeetle (banco de dados financeiro) e Ghostty (terminal moderno) são escritos em Zig.

A Filosofia do Zig (Zig Zen)

Execute este comando no terminal após instalar:

zig zen

Você verá os princípios que guiam a linguagem:

* Communicate intent precisely.
* Edge cases matter.
* Favor reading code over writing code.
* Only one obvious way to do things.
* Resource allocation may fail; resource deallocation must succeed.
* ...

Estes princípios fazem Zig ideal para quem quer entender profundamente como a computação funciona, sem abstrações que escondem a complexidade.

Instalando o Zig (5 Minutos)

Antes de começar a programar, você precisa instalar o Zig. Temos um guia completo de instalação, mas aqui está o resumo rápido:

Linux (Ubuntu/Debian)

# Via Snap (mais fácil)
sudo snap install zig --classic

# Ou instalação manual
wget https://ziglang.org/download/0.15.2/zig-x86_64-linux-0.15.2.tar.xz
tar -xf zig-x86_64-linux-0.15.2.tar.xz
sudo mv zig-x86_64-linux-0.15.2 /opt/zig
echo 'export PATH="/opt/zig:$PATH"' >> ~/.bashrc
source ~/.bashrc

macOS (com Homebrew)

brew install zig

Windows (com WinGet)

winget install zig.zig

Verifique a Instalação

zig version
# Deve mostrar: 0.15.2 (ou versão mais recente)

✅ Pronto? Com o Zig instalado, vamos ao seu primeiro programa!

Seu Primeiro Programa: Hello World

Vamos começar com o clássico “Olá, Mundo!” para garantir que tudo funciona.

Método 1: Arquivo Único (Rápido)

Crie um arquivo chamado ola.zig:

const std = @import("std");

pub fn main() void {
    std.debug.print("Olá, Mundo! 🎉\n", .{});
}

Execute:

zig run ola.zig

Saída:

Olá, Mundo! 🎉

🎉 Parabéns! Você acabou de executar seu primeiro programa Zig!

Método 2: Projeto Completo (Recomendado)

Para projetos reais, use a estrutura oficial do Zig:

mkdir meu-primeiro-projeto
cd meu-primeiro-projeto
zig init

Isso cria:

meu-primeiro-projeto/
├── build.zig          # Configuração de build
├── build.zig.zon      # Dependências
└── src/
    └── main.zig       # Seu código

Execute:

zig build run

Saída:

All your codebase are belong to us.
Run `zig build test` to run the tests.

💡 Dica: O comando zig init cria um projeto pronto para crescer. Use-o para qualquer projeto que vá além de um arquivo simples.

Conceitos Fundamentais do Zig

Agora que você tem o Zig funcionando, vamos entender os conceitos essenciais que formam a base da linguagem.

1. Constantes vs Variáveis

Zig distingue claramente entre valores que mudam e valores que não mudam:

const std = @import("std");

pub fn main() void {
    // const = valor NÃO muda (imutável)
    const pi: f64 = 3.14159;
    
    // var = valor PODE mudar (mutável)
    var contador: i32 = 0;
    contador = contador + 1;
    
    std.debug.print("PI = {d}\n", .{pi});
    std.debug.print("Contador = {d}\n", .{contador});
}

Regra de Ouro: Use const por padrão. Mude para var apenas quando realmente precisar de mutabilidade.

2. Tipos de Dados Básicos

Zig é estaticamente tipado — você deve declarar (ou o compilador inferir) o tipo de cada variável.

const std = @import("std");

pub fn main() void {
    const idade: u8 = 25;           // u8: 0 a 255
    const temperatura: f32 = 23.5;  // f32: número decimal
    const ativo: bool = true;       // bool: true/false
    const letra: u8 = 'Z';          // u8 também para caracteres
    
    std.debug.print("Idade: {d} anos\n", .{idade});
    std.debug.print("Temperatura: {d}°C\n", .{temperatura});
    std.debug.print("Ativo: {}\n", .{ativo});
    std.debug.print("Letra: {c}\n", .{letra});
}

🔑 Formatos de print: {d} = decimal/inteiro, {} = default, {c} = caractere

3. Inferência de Tipo com @TypeOf

Você pode deixar o Zig inferir tipos quando óbvio:

const std = @import("std");

pub fn main() void {
    // O compilador infere o tipo do literal
    const mensagem = "Olá, Zig!";  // Inferido como []const u8
    const ano = 2026;               // Inferido como comptime_int
    
    std.debug.print("{s}\n", .{mensagem});
    std.debug.print("Ano: {d}\n", .{ano});
}

⚠️ Atenção: Prefira explicitar tipos em código de produção. A inferência é útil para prototipagem e literais.

4. Funções

Funções são blocos de código reutilizáveis:

const std = @import("std");

// Função que recebe dois inteiros e retorna a soma
fn soma(a: i32, b: i32) i32 {
    return a + b;
}

// Função que não retorna nada (void)
fn saudacao(nome: []const u8) void {
    std.debug.print("Olá, {s}!\n", .{nome});
}

pub fn main() void {
    const resultado = soma(10, 20);
    std.debug.print("10 + 20 = {d}\n", .{resultado});
    
    saudacao("Iniciante");
}

Anatomia de uma função:

fn nome(parametro: Tipo) TipoRetorno {
    // corpo
    return valor;
}

5. Controle de Fluxo Básico

if / else

const std = @import("std");

pub fn main() void {
    const nota: u8 = 85;
    
    if (nota >= 90) {
        std.debug.print("Conceito A\n", .{});
    } else if (nota >= 80) {
        std.debug.print("Conceito B\n", .{});
    } else if (nota >= 70) {
        std.debug.print("Conceito C\n", .{});
    } else {
        std.debug.print("Reprovado\n", .{});
    }
}

switch (Múltiplas Opções)

const std = @import("std");

pub fn main() void {
    const dia: u8 = 3;
    
    const nome_dia = switch (dia) {
        1 => "Domingo",
        2 => "Segunda",
        3 => "Terça",
        4 => "Quarta",
        5 => "Quinta",
        6 => "Sexta",
        7 => "Sábado",
        else => "Dia inválido",
    };
    
    std.debug.print("Dia {d}: {s}\n", .{ dia, nome_dia });
}

Loops: while

const std = @import("std");

pub fn main() void {
    var i: u8 = 1;
    
    while (i <= 5) {
        std.debug.print("Contagem: {d}\n", .{i});
        i += 1;
    }
    
    std.debug.print("Fim!\n", .{});
}

Loops: for

const std = @import("std");

pub fn main() void {
    // Iterando sobre um array
    const numeros = [_]i32{ 10, 20, 30, 40, 50 };
    
    for (numeros) |numero| {
        std.debug.print("Número: {d}\n", .{numero});
    }
    
    // Com índice
    for (numeros, 0..) |numero, indice| {
        std.debug.print("numeros[{d}] = {d}\n", .{ indice, numero });
    }
}

Exercícios Práticos para Iniciantes

A melhor forma de aprender é praticando. Tente resolver estes exercícios antes de continuar:

Exercício 1: Calculadora Simples

Crie um programa que:

1. Declare duas variáveis a e b
2. Calcule e imprima: soma, subtração, multiplicação e divisão

const std = @import("std");

pub fn main() void {
    const a: i32 = 15;
    const b: i32 = 4;
    
    std.debug.print("a = {d}, b = {d}\n", .{ a, b });
    std.debug.print("Soma: {d}\n", .{a + b});
    std.debug.print("Subtração: {d}\n", .{a - b});
    std.debug.print("Multiplicação: {d}\n", .{a * b});
    std.debug.print("Divisão: {d}\n", .{@divTrunc(a, b)});
    std.debug.print("Resto: {d}\n", .{@rem(a, b)});
}

Exercício 2: Verificador de Idade

Crie um programa que verifica se uma pessoa é maior de idade (18+ anos).

const std = @import("std");

pub fn main() void {
    const idade: u8 = 21;
    
    if (idade >= 18) {
        std.debug.print("Maior de idade ({d} anos)\n", .{idade});
    } else {
        std.debug.print("Menor de idade ({d} anos)\n", .{idade});
    }
}

Exercício 3: Tabuada

Use um loop while para imprimir a tabuada do 7.

const std = @import("std");

pub fn main() void {
    const numero: u8 = 7;
    var i: u8 = 1;
    
    std.debug.print("=== Tabuada do {d} ===\n", .{numero});
    
    while (i <= 10) {
        const resultado = numero * i;
        std.debug.print("{d} x {d} = {d}\n", .{ numero, i, resultado });
        i += 1;
    }
}

Padrões e Convenções

Nomeação

Zig segue convenções claras de nomenclatura:

Comentários

// Comentário de linha única

/// Comentário de documentação (aparece em tools)

//
// Comentário de múltiplas linhas
// é apenas várias linhas de comentário simples
//

Formatação

Zig inclue um formatador oficial. Use sempre:

zig fmt meu-arquivo.zig

Ou configure seu editor para formatar ao salvar.

Erros Comuns de Iniciantes (e Como Evitá-los)

❌ Erro 1: Esquecer o Tipo

// ERRADO
var x = 10;  // Erro: tipo não pode ser inferido em runtime

// CORRETO
var x: i32 = 10;
// ou
const x = 10;  // const pode ser comptime_int

❌ Erro 2: Modificar uma const

const std = @import("std");

pub fn main() void {
    const valor = 10;
    valor = 20;  // ERRO: cannot assign to constant
}

Correção: Use var se precisar mudar o valor.

❌ Erro 3: Divisão de Inteiros

const resultado = 5 / 2;  // Resultado: 2 (truncado!)

Correção: Use floats para divisão precisa:

const resultado: f32 = 5.0 / 2.0;  // Resultado: 2.5

❌ Erro 4: Esquecer .{ } no print

std.debug.print("Valor: {d}\n", valor);  // ERRO
std.debug.print("Valor: {d}\n", .{valor});  // CORRETO

❌ Erro 5: Índice Fora dos Limites

const array = [_]i32{ 1, 2, 3 };
const x = array[5];  // ERRO: index out of bounds (em runtime)

Correção: Zig verifica bounds em alguns casos, mas sempre valide seus índices.

FAQ — Perguntas Frequentes

Preciso saber C antes de aprender Zig?

Não! Embora Zig seja uma alternativa ao C, você pode aprender Zig sem nunca ter programado em C. Conhecimento de C ajuda a entender alguns conceitos de baixo nível, mas não é obrigatório.

Zig é difícil para iniciantes em programação?

Zig é mais acessível que C++ ou Rust para iniciantes porque:

• Não tem classes, herança ou polimorfismo complexo
• A documentação é clara e direta
• O compilador dá mensagens de erro úteis
• A curva de aprendizado é linear

Por outro lado, exige mais atenção que Python ou JavaScript porque você gerencia tipos explicitamente.

Quanto tempo leva para aprender Zig?

Com dedicação de 1-2 horas por dia:

• Básico: 1-2 semanas (sintaxe, tipos, funções)
• Intermediário: 1-2 meses (ponteiros, allocators, comptime)
• Avançado: 3-6 meses (metaprogramação, otimizações, integração C)

Posso usar Zig para web development?

Sim! Zig pode ser usado para:

• Backend: Servidores HTTP de alta performance
• WebAssembly: Compilar para rodar no navegador
• Edge computing: Cloudflare Workers, Fastly Compute

Veja: Criando um Servidor HTTP em Zig (quando disponível).

Zig tem empregos no Brasil?

Ainda é um mercado em formação. A maioria das oportunidades é internacional (remoto) ou em startups. No entanto, a demanda está crescendo rapidamente com projetos como Bun e TigerBeetle.

Qual a diferença entre Zig e Rust?

Leia mais: Zig vs Rust: Qual Escolher?

O Que Vem Depois?

Este foi apenas o primeiro artigo da série “Zig para Iniciantes”. Continue sua jornada:

📚 Próximos Artigos da Série

1. ✅ Artigo 1: Primeiros Passos (você está aqui!)
2. 🔄 Artigo 2: Sintaxe Básica de Zig: Variáveis, Tipos e Funções — Aprofundamento em tipos e funções
3. ⏳ Artigo 3: Controle de Fluxo em Zig: if, switch, loops — Estruturas de controle completas

🎯 Conteúdo Relacionado

• Como Instalar o Zig — Guia detalhado de instalação
• O Que é Zig? Guia Completo — Visão geral da linguagem
• Zig para Programadores C — Se você vem do C
• Comptime em Zig — O superpoder do Zig
• Zig Build System — Gerenciamento de projetos

🛠️ Pratique Mais

• Ziglings — Exercícios interativos
• Zig Documentation — Documentação oficial
• Zig by Example — Exemplos práticos

Resumo: Checklist do Iniciante

• Zig instalado e funcionando
• Primeiro “Hello World” executado
• Entende a diferença entre const e var
• Conhece os tipos básicos (i32, u32, f64, bool)
• Sabe criar funções
• Usa if, switch, while e for
• Próximo passo: Sintaxe Básica Completa

Tem dúvidas? Encontrou algum erro? Deixe um comentário abaixo ou entre em contato. Este guia é atualizado regularmente com base no feedback da comunidade.

Happy coding! 🦎