---
title: "Introdução ao Zig: Primeiros Passos com a Linguagem"
url: "https://ziglang.com.br/tutoriais/introdu%C3%A7%C3%A3o-ao-zig-primeiros-passos-com-a-linguagem/"
markdown_url: "https://ziglang.com.br/tutoriais/introdu%C3%A7%C3%A3o-ao-zig-primeiros-passos-com-a-linguagem.MD"
description: "Aprenda os fundamentos da linguagem Zig neste tutorial completo para iniciantes. Instale o compilador, escreva seu primeiro programa, entenda variáveis, tipos, funções e controle de fluxo."
date: "2026-02-08"
author: "Zig Brasil"
---

# Introdução ao Zig: Primeiros Passos com a Linguagem

Aprenda os fundamentos da linguagem Zig neste tutorial completo para iniciantes. Instale o compilador, escreva seu primeiro programa, entenda variáveis, tipos, funções e controle de fluxo.


Zig é uma linguagem de programação de sistemas moderna que oferece performance comparável a C, mas com muito mais segurança e ergonomia. Neste tutorial completo, vamos dar os primeiros passos com Zig: desde a instalação até a compreensão dos conceitos fundamentais que tornam essa linguagem especial.

Se você quer entender melhor o que é Zig e por que ela está ganhando popularidade, confira nosso artigo [O que é Zig?](/tutoriais/o-que-e-zig/).

## Por que aprender Zig?

Antes de começar, vale entender o que torna Zig diferente de outras linguagens:

- **Performance de C sem os problemas de C** — mesmo poder, sem comportamento indefinido oculto
- **Sem garbage collector** — controle total de memória com allocators explícitos
- **Cross-compilation nativa** — compile para 30+ plataformas com um único comando
- **Interoperabilidade com C** — importe headers C diretamente sem wrappers
- **Comptime** — execute código em tempo de compilação para metaprogramação poderosa

Empresas como Uber, Cloudflare e o projeto Bun já usam Zig em produção. Para mais detalhes, veja [por que aprender Zig](/artigos/por-que-aprender-zig/).

## Instalando o Zig

A instalação do Zig é simples em qualquer sistema operacional. Para um guia detalhado com todas as opções, confira nosso [tutorial de instalação do Zig](/tutoriais/como-instalar-zig/).

### Linux e macOS

A forma mais rápida é baixar o binário pré-compilado do [site oficial](https://ziglang.org/download/):

```bash
# Baixe a versão mais recente (substitua pela URL atualizada)
curl -LO https://ziglang.org/download/zig-linux-x86_64.tar.xz

# Extraia o arquivo
tar -xf zig-linux-x86_64.tar.xz

# Adicione ao PATH (adicione ao seu .bashrc ou .zshrc para ser permanente)
export PATH=$PATH:$PWD/zig-linux-x86_64
```

No macOS, você também pode usar o Homebrew:

```bash
brew install zig
```

### Windows

No Windows, use o gerenciador de pacotes **Scoop** ou **Chocolatey**:

```powershell
# Via Scoop
scoop install zig

# Via Chocolatey
choco install zig
```

### Verificando a instalação

Após instalar, verifique se tudo está funcionando:

```bash
zig version
```

Você deve ver algo como `0.13.0` ou a versão mais recente. Se o comando não for encontrado, verifique se o diretório do Zig está no seu `PATH`.

## Seu primeiro programa em Zig

Vamos criar o clássico "Olá, mundo!" em Zig. Crie um arquivo chamado `hello.zig`:

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

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();
    try stdout.print("Olá, mundo!\n", .{});
}
```

Compile e execute:

```bash
zig build-exe hello.zig
./hello
```

Você verá `Olá, mundo!` no terminal.

### Entendendo cada linha

Vamos analisar o código em detalhe:

1. **`const std = @import("std")`** — Importa a biblioteca padrão do Zig. O `@import` é um *builtin* que carrega módulos.

2. **`pub fn main() !void`** — Declara a função principal pública. O `!void` é um tipo especial chamado *error union*: significa que a função pode retornar `void` (nada) ou um erro. Isso faz parte do [sistema de tratamento de erros do Zig](/tutoriais/tratamento-de-erros-em-zig/).

3. **`std.io.getStdOut().writer()`** — Obtém um *writer* para a saída padrão (stdout). O Zig usa interfaces genéricas para I/O.

4. **`try stdout.print("Olá, mundo!\n", .{})`** — O `try` propaga automaticamente qualquer erro que `print` possa retornar. O `.{}` é uma tupla vazia de argumentos.

## Variáveis e constantes

No Zig, existem duas formas de declarar valores:

### `const` — Valores imutáveis (preferido)

```zig
const x: i32 = 42;        // tipo explícito
const nome = "Zig Brasil"; // tipo inferido ([]const u8)
const pi = 3.14159;        // tipo inferido (comptime_float)
```

### `var` — Valores mutáveis

```zig
var contador: u32 = 0;
contador += 1;  // OK — variáveis podem ser modificadas
contador = 10;  // OK
```

**Dica importante:** O Zig encoraja o uso de `const` sempre que possível. Se você declarar um `var` e nunca modificar o valor, o compilador vai emitir um aviso.

### Tipos básicos

O Zig tem um sistema de tipos explícito e previsível:

```zig
// Inteiros com tamanho explícito
const a: i8 = -128;    // inteiro com sinal, 8 bits
const b: u16 = 65535;  // inteiro sem sinal, 16 bits
const c: i32 = 42;     // inteiro com sinal, 32 bits
const d: u64 = 1000;   // inteiro sem sinal, 64 bits

// Ponto flutuante
const e: f32 = 3.14;   // 32 bits
const f: f64 = 2.718;  // 64 bits (precisão dupla)

// Booleano
const ativo: bool = true;

// Tamanho de ponteiro (usize — depende da plataforma)
const tamanho: usize = 100;
```

Para aprender mais sobre os tipos de dados, incluindo arrays, slices e strings, confira nosso guia de [Strings e Arrays em Zig](/tutoriais/strings-e-arrays-zig/).

## Funções

Funções em Zig são declaradas com `fn` e têm tipos explícitos para parâmetros e retorno:

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

fn somar(a: i32, b: i32) i32 {
    return a + b;
}

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

pub fn main() !void {
    const resultado = somar(10, 20);
    std.debug.print("Soma: {}\n", .{resultado});

    const divisao = try dividir(10.0, 3.0);
    std.debug.print("Divisão: {d:.2}\n", .{divisao});
}
```

Note como `dividir` retorna `!f64` — um *error union* que pode ser um `f64` ou um erro. Esse é o sistema de tratamento de erros do Zig em ação: explícito, sem exceções, sem surpresas.

## Controle de fluxo

### If/else

```zig
const idade: u8 = 25;

if (idade >= 18) {
    std.debug.print("Maior de idade\n", .{});
} else {
    std.debug.print("Menor de idade\n", .{});
}
```

### `if` como expressão

Diferente de C, o `if` em Zig pode ser usado como expressão:

```zig
const status = if (idade >= 18) "adulto" else "menor";
```

### While

```zig
var i: u32 = 0;
while (i < 10) : (i += 1) {
    std.debug.print("{} ", .{i});
}
```

### For (iteração sobre slices)

```zig
const nomes = [_][]const u8{ "Ana", "Bruno", "Carlos" };
for (nomes) |nome| {
    std.debug.print("Olá, {s}!\n", .{nome});
}
```

## Defer — limpeza garantida

Uma das funcionalidades mais poderosas do Zig é o `defer`, que garante que uma ação será executada quando sair do escopo atual:

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

pub fn main() !void {
    const allocator = std.heap.page_allocator;
    const buffer = try allocator.alloc(u8, 1024);
    defer allocator.free(buffer); // será executado ao sair da função

    // Use o buffer com segurança...
    // A memória será liberada automaticamente
}
```

Isso elimina a maioria dos *memory leaks* comuns em C. Para entender mais sobre como o Zig gerencia memória, veja nosso tutorial sobre [gerenciamento de memória](/tutoriais/gerenciamento-de-memoria-zig/).

## Compilando com `zig build`

Para projetos maiores, o Zig tem um [sistema de build integrado](/tutoriais/zig-build-system/) que substitui ferramentas como Make, CMake ou Cargo:

```bash
# Inicializar um novo projeto
zig init

# Compilar o projeto
zig build

# Compilar e executar
zig build run
```

O arquivo `build.zig` define toda a configuração do projeto — dependências, targets, testes — tudo em Zig puro, sem linguagens de configuração separadas.

## Próximos passos

Parabéns! Você já sabe o básico do Zig. Para continuar sua jornada, recomendamos:

1. **[Strings e Arrays](/tutoriais/strings-e-arrays-zig/)** — Entenda slices, arrays e manipulação de strings
2. **[Structs, Enums e Unions](/tutoriais/structs-enums-unions-zig/)** — Crie tipos de dados customizados
3. **[Tratamento de Erros](/tutoriais/tratamento-de-erros-em-zig/)** — Domine o sistema de erros do Zig
4. **[Gerenciamento de Memória](/tutoriais/gerenciamento-de-memoria-zig/)** — Allocators e controle manual de memória
5. **[Comptime](/tutoriais/comptime-em-zig/)** — A funcionalidade mais poderosa do Zig

Ou se você vem de outra linguagem, temos guias especializados:
- [Zig para programadores C](/tutoriais/zig-para-programadores-c/)
- [Zig para programadores Python](/tutoriais/zig-para-programadores-python/)
- [Zig para programadores JavaScript](/tutoriais/zig-para-programadores-javascript/)

Explore todos os nossos [tutoriais em português](/tutoriais/) e junte-se à [comunidade Zig Brasil](/comunidade/)!