---
title: "Zig para Iniciantes: Primeiros Passos em 2026 | Zig Brasil"
url: "https://ziglang.com.br/tutoriais/zig-para-iniciantes-primeiros-passos/"
markdown_url: "https://ziglang.com.br/tutoriais/zig-para-iniciantes-primeiros-passos.MD"
description: "Aprenda Zig do zero: instalação, hello world e conceitos fundamentais. Tutorial passo a passo em português para iniciantes começarem a programar em Zig."
date: "2026-02-09"
author: ""
---

# Zig para Iniciantes: Primeiros Passos em 2026 | Zig Brasil

Aprenda Zig do zero: instalação, hello world e conceitos fundamentais. Tutorial passo a passo em português para iniciantes começarem a programar em Zig.


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?

| Aspecto | Zig | Benefício para Iniciantes |
|---------|-----|---------------------------|
| **Simplicidade** | Sem classes, herança, ou complexidade OO | Menos conceitos para aprender |
| **Performance** | Tão rápida quanto C | Aprenda a escrever código eficiente desde o início |
| **Compilação** | Ultra-rápida (cache inteligente) | Feedback imediato enquanto aprende |
| **Cross-compilation** | Compile para qualquer plataforma | Um código, múltiplos destinos |
| **Sem dependências ocultas** | Controle total da memória | Entenda o que acontece "por baixo" |
| **Comptime** | Código roda em tempo de compilação | Metaprogramação sem macros complexas |

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

### A Filosofia do Zig (Zig Zen)

Execute este comando no terminal após instalar:

```bash
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](/tutoriais/como-instalar-zig/), mas aqui está o resumo rápido:

### Linux (Ubuntu/Debian)

```bash
# 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)

```bash
brew install zig
```

### Windows (com WinGet)

```powershell
winget install zig.zig
```

### Verifique a Instalação

```bash
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`:

```zig
const std = @import("std");

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

Execute:

```bash
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:

```bash
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:

```bash
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:

```zig
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.

| Tipo | Descrição | Exemplo |
|------|-----------|---------|
| `i32` | Inteiro 32-bit com sinal | `-42` |
| `u32` | Inteiro 32-bit sem sinal | `42` |
| `i64`, `u64` | Inteiros 64-bit | `-9999999999` |
| `f32` | Ponto flutuante 32-bit | `3.14` |
| `f64` | Ponto flutuante 64-bit | `3.1415926535` |
| `bool` | Booleano | `true` ou `false` |
| `u8` | Byte/caractere ASCII | `'A'` |

```zig
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:

```zig
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:

```zig
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:**
```zig
fn nome(parametro: Tipo) TipoRetorno {
    // corpo
    return valor;
}
```

### 5. Controle de Fluxo Básico

#### if / else

```zig
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)

```zig
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

```zig
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

```zig
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

<details>
<summary>Ver Solução</summary>

```zig
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)});
}
```

</details>

### Exercício 2: Verificador de Idade

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

<details>
<summary>Ver Solução</summary>

```zig
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});
    }
}
```

</details>

### Exercício 3: Tabuada

Use um loop `while` para imprimir a tabuada do 7.

<details>
<summary>Ver Solução</summary>

```zig
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;
    }
}
```

</details>

---

## Padrões e Convenções

### Nomeação

Zig segue convenções claras de nomenclatura:

| Elemento | Convenção | Exemplo |
|----------|-----------|---------|
| Variáveis/Funções | `snake_case` | `minha_variavel`, `calcular_soma()` |
| Tipos/Structs | `PascalCase` | `Pessoa`, `ConfiguracaoServidor` |
| Constantes | `snake_case` maiúsculas | `PI`, `TAMANHO_MAXIMO` |
| Enumerações | `PascalCase` | `StatusPedido` |

### Comentários

```zig
// 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:

```bash
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

```zig
// 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

```zig
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

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

**Correção:** Use floats para divisão precisa:
```zig
const resultado: f32 = 5.0 / 2.0;  // Resultado: 2.5
```

### ❌ Erro 4: Esquecer `.{ }` no print

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

### ❌ Erro 5: Índice Fora dos Limites

```zig
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](/tutoriais/zig-http-server/) (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?

| Aspecto | Zig | Rust |
|---------|-----|------|
| Gerenciamento de memória | Manual (você controla) | Ownership (compilador controla) |
| Curva de aprendizado | Mais suave | Mais íngreme |
| Compilação | Mais rápida | Mais lenta |
| Tamanho binário | Menor | Maior |
| Segurança | Você garante | Compilador garante |

Leia mais: [Zig vs Rust: Qual Escolher?](/artigos/zig-vs-rust/)

---

## 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](/tutoriais/zig-para-iniciantes/artigo-2-sintaxe-basica/) — 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](/tutoriais/como-instalar-zig/) — Guia detalhado de instalação
- [O Que é Zig? Guia Completo](/artigos/o-que-e-zig-guia-completo/) — Visão geral da linguagem
- [Zig para Programadores C](/tutoriais/zig-para-programadores-c/) — Se você vem do C
- [Comptime em Zig](/tutoriais/comptime-em-zig/) — O superpoder do Zig
- [Zig Build System](/tutoriais/zig-build-system/) — Gerenciamento de projetos

### 🛠️ Pratique Mais

- [Ziglings](https://github.com/ratfactor/ziglings) — Exercícios interativos
- [Zig Documentation](https://ziglang.org/documentation/master/) — Documentação oficial
- [Zig by Example](https://zig-by-example.com/) — Exemplos práticos

---

## Resumo: Checklist do Iniciante

- [x] Zig instalado e funcionando
- [x] Primeiro "Hello World" executado
- [x] Entende a diferença entre `const` e `var`
- [x] Conhece os tipos básicos (i32, u32, f64, bool)
- [x] Sabe criar funções
- [x] Usa `if`, `switch`, `while` e `for`
- [ ] Próximo passo: [Sintaxe Básica Completa](/tutoriais/zig-para-iniciantes/artigo-2-sintaxe-basica/)

---

*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! 🦎**