---
title: "Como Instalar Zig em 2026: Linux, Windows, macOS e VS Code"
url: "https://ziglang.com.br/tutoriais/como-instalar-zig/"
markdown_url: "https://ziglang.com.br/tutoriais/como-instalar-zig.MD"
description: "Guia rápido para instalar Zig em 2026 no Linux, Windows e macOS: download oficial, Homebrew, WinGet, Scoop, zigup, PATH, VS Code e ZLS."
date: "2026-02-08"
author: ""
---

# Como Instalar Zig em 2026: Linux, Windows, macOS e VS Code

Guia rápido para instalar Zig em 2026 no Linux, Windows e macOS: download oficial, Homebrew, WinGet, Scoop, zigup, PATH, VS Code e ZLS.


Quer começar a programar em **[Zig Lang](/)** mas não sabe como instalar? Este guia completo mostra o passo a passo para instalar o [Zig](/tutoriais/o-que-e-zig/) no **Linux**, **Windows** e **macOS** — com todas as opções disponíveis, desde gerenciadores de pacotes até instalação manual, `zigup`, VS Code e ZLS.

Ao final, você terá o Zig funcionando, o editor configurado e seu primeiro programa compilado.

## Resposta rápida: melhor forma de instalar Zig em 2026

Se você quer apenas começar sem comparar todos os métodos, use esta rota:

| Sistema | Melhor primeira opção | Comando ou caminho |
|---|---|---|
| Ubuntu, Debian, Linux Mint, Pop!_OS | Download oficial ou Snap | `sudo snap install zig --classic` ou binário de `ziglang.org/download` |
| Fedora, RHEL, CentOS Stream | Pacote da distro ou download oficial | `sudo dnf install zig` |
| Arch, Manjaro, EndeavourOS | Pacman | `sudo pacman -S zig` |
| macOS | Homebrew | `brew install zig` |
| Windows 10/11 | WinGet ou Scoop | `winget install zig.zig` ou `scoop install zig` |
| Projetos com versões diferentes | `zigup` | Veja [gerenciar versões do Zig](/instalacao/zig-gerenciar-versoes/) |

Para a maioria dos iniciantes, o caminho mais seguro é instalar a versão estável, rodar `zig version`, criar um `hello.zig` e configurar o editor depois. Se você quer um guia separado por plataforma, use também o hub de [instalação do Zig](/instalacao/), com páginas específicas para [Ubuntu/Debian](/instalacao/instalar-zig-linux-ubuntu/), [Fedora/RHEL](/instalacao/instalar-zig-linux-fedora/), [Arch Linux](/instalacao/instalar-zig-linux-arch/), [macOS](/instalacao/instalar-zig-macos/), [Windows](/instalacao/instalar-zig-windows/) e [WSL](/instalacao/instalar-zig-wsl/).

## O que Você Vai Precisar

Antes de começar, confirme que você tem:

- **Acesso ao terminal** (ou PowerShell no Windows)
- **Conexão com a internet** para baixar os arquivos
- **Espaço em disco**: cerca de 100 MB para o Zig (sem dependências adicionais!)
- **Permissões de administrador** (apenas para instalação via gerenciador de pacotes)

> **Zig não tem dependências externas.** Diferente de muitas linguagens, você não precisa instalar runtimes, frameworks ou bibliotecas separadas. É um único binário que já vem com tudo. Essa simplicidade é uma das [razões para aprender Zig](/artigos/por-que-aprender-zig/).

### Qual Versão Escolher?

| Versão | Status | Recomendação |
|---|---|---|
| **0.15.2** | Última versão estável | ✅ Recomendada para a maioria dos usuários |
| **0.16.0-dev** | Branch de desenvolvimento (master) | Para quem quer testar as novidades mais recentes |
| **0.14.1** | Versão estável anterior | Útil se alguma dependência exigir essa versão |

**Nosso conselho:** Se você está começando, use a **versão 0.15.2** (estável). Este guia usa essa versão nos exemplos.

### Quando usar zigup em vez do pacote do sistema?

Use o pacote do sistema quando você está aprendendo, fazendo scripts pequenos ou quer uma instalação simples. Use [`zigup`](/glossario/zigup/) quando precisa alternar entre versões do Zig, testar `master`, manter um projeto antigo em uma versão específica ou reproduzir o mesmo ambiente no trabalho e no CI.

Exemplo de fluxo com `zigup`:

```bash
# Instalar a versão estável usada pelo projeto
zigup 0.15.2

# Testar o compilador de desenvolvimento
zigup master

# Conferir qual versão está ativa
zig version
```

Esse caminho é especialmente útil porque Zig ainda evolui rápido antes do 1.0. Se uma dependência exige uma versão específica, não tente "consertar" o projeto atualizando tudo de uma vez; instale a versão esperada e teste com calma. Para detalhes, veja o guia completo de [gerenciamento de versões do Zig](/instalacao/zig-gerenciar-versoes/).

## Instalando no Linux

O Linux é a plataforma mais popular entre desenvolvedores Zig. Você tem várias opções de instalação.

Se você usa uma distribuição específica, também temos guias dedicados: [Ubuntu/Debian](/instalacao/instalar-zig-linux-ubuntu/), [Fedora/RHEL](/instalacao/instalar-zig-linux-fedora/), [Arch Linux](/instalacao/instalar-zig-linux-arch/), [Nix/NixOS](/instalacao/instalar-zig-nix/) e [WSL](/instalacao/instalar-zig-wsl/).

### Opção 1: Snap (Ubuntu, Debian e derivados)

A forma mais simples para distribuições baseadas em Ubuntu:

```bash
# Instalar o Zig via Snap
sudo snap install zig --classic
```

Verifique a instalação:

```bash
zig version
# Saída esperada: 0.15.2
```

> **Nota:** O pacote Snap é mantido pela comunidade. Para garantir a versão mais recente, prefira a instalação manual.

### Opção 2: Gerenciadores de Pacotes por Distribuição

#### Ubuntu / Debian

O Zig não está nos repositórios oficiais do Debian/Ubuntu. A melhor opção é usar o Snap (acima) ou a instalação manual (abaixo). Existe também um PPA da comunidade:

```bash
# Usando o PPA da comunidade (pode não ter a versão mais recente)
sudo apt install software-properties-common
sudo add-apt-repository ppa:ziglang/zig
sudo apt update
sudo apt install zig
```

Se o PPA não estiver disponível para a sua versão do Ubuntu, use a **instalação manual** (Opção 3).

#### Fedora

```bash
# Fedora — disponível nos repositórios oficiais
sudo dnf install zig
```

#### Arch Linux

```bash
# Arch Linux — disponível no repositório extra
sudo pacman -S zig
```

O Arch geralmente tem a versão mais recente disponível rapidamente após cada release.

#### NixOS / Nix

```bash
# Usando Nix (funciona em qualquer distro com Nix instalado)
nix-env -iA nixpkgs.zig
```

### Opção 3: Instalação Manual (Recomendada)

A instalação manual garante que você tenha **exatamente a versão desejada**, funciona em **qualquer distribuição Linux** e não requer permissões de root.

**Passo 1 — Baixe o binário:**

```bash
# Para x86_64 (a maioria dos PCs e notebooks)
wget https://ziglang.org/download/0.15.2/zig-x86_64-linux-0.15.2.tar.xz

# Para ARM64 (Raspberry Pi 4+, servidores ARM)
# wget https://ziglang.org/download/0.15.2/zig-aarch64-linux-0.15.2.tar.xz
```

> 💡 **Dica:** Não sabe sua arquitetura? Execute `uname -m`. Se retornar `x86_64`, use o primeiro link. Se retornar `aarch64`, use o segundo.

**Passo 2 — Extraia o arquivo:**

```bash
tar -xf zig-x86_64-linux-0.15.2.tar.xz
```

**Passo 3 — Mova para um local permanente:**

```bash
sudo mv zig-x86_64-linux-0.15.2 /opt/zig
```

**Passo 4 — Adicione ao PATH:**

Adicione a seguinte linha ao final do seu arquivo de configuração do shell:

Para **Bash** (`~/.bashrc`):
```bash
echo 'export PATH="/opt/zig:$PATH"' >> ~/.bashrc
source ~/.bashrc
```

Para **Zsh** (`~/.zshrc`):
```bash
echo 'export PATH="/opt/zig:$PATH"' >> ~/.zshrc
source ~/.zshrc
```

Para **Fish** (`~/.config/fish/config.fish`):
```bash
echo 'set -gx PATH /opt/zig $PATH' >> ~/.config/fish/config.fish
source ~/.config/fish/config.fish
```

**Passo 5 — Verifique:**

```bash
zig version
# Saída esperada: 0.15.2
```

### Alternativa: Instalação no diretório do usuário (sem root)

Se você não tem permissões de administrador:

```bash
# Extraia no seu diretório home
mkdir -p ~/apps
tar -xf zig-x86_64-linux-0.15.2.tar.xz -C ~/apps/
mv ~/apps/zig-x86_64-linux-0.15.2 ~/apps/zig

# Adicione ao PATH
echo 'export PATH="$HOME/apps/zig:$PATH"' >> ~/.bashrc
source ~/.bashrc
```

## Instalando no macOS

O macOS funciona bem para desenvolvimento Zig, tanto em Apple Silicon quanto em Macs Intel. Se quiser uma página focada só nesse ambiente, veja também [como instalar Zig no macOS](/instalacao/instalar-zig-macos/).

### Opção 1: Homebrew (Recomendada)

Se você usa [Homebrew](https://brew.sh/) (o gerenciador de pacotes mais popular do macOS), a instalação é simples:

```bash
# Instalar o Zig
brew install zig
```

Verifique a instalação:

```bash
zig version
# Saída esperada: 0.15.2
```

**Atualizar para a última versão:**

```bash
brew upgrade zig
```

#### Instalando a versão nightly (desenvolvimento)

Se você quer a versão mais recente (master branch), existe um tap da comunidade:

```bash
brew install --cask zig@nightly --no-quarantine
```

> ⚠️ **Atenção:** A versão nightly pode ter breaking changes. Use apenas se souber o que está fazendo.

### Opção 2: MacPorts

```bash
sudo port install zig
```

### Opção 3: Instalação Manual

**Passo 1 — Identifique seu processador:**

```bash
uname -m
# Apple Silicon (M1, M2, M3, M4): arm64
# Intel Mac: x86_64
```

**Passo 2 — Baixe o binário correto:**

```bash
# Para Apple Silicon (M1/M2/M3/M4)
curl -LO https://ziglang.org/download/0.15.2/zig-aarch64-macos-0.15.2.tar.xz

# Para Intel Mac
# curl -LO https://ziglang.org/download/0.15.2/zig-x86_64-macos-0.15.2.tar.xz
```

**Passo 3 — Extraia e mova:**

```bash
tar -xf zig-aarch64-macos-0.15.2.tar.xz
sudo mv zig-aarch64-macos-0.15.2 /usr/local/zig
```

**Passo 4 — Adicione ao PATH:**

Para **Zsh** (padrão no macOS):
```bash
echo 'export PATH="/usr/local/zig:$PATH"' >> ~/.zshrc
source ~/.zshrc
```

**Passo 5 — Verifique:**

```bash
zig version
```

> 💡 **Nota sobre o Gatekeeper:** Na primeira execução, o macOS pode exibir um aviso de segurança. Vá em **Ajustes do Sistema → Privacidade e Segurança** e clique em "Permitir" para o binário do Zig. Ou use: `xattr -d com.apple.quarantine /usr/local/zig/zig`

## Instalando no Windows

No Windows, o caminho mais direto em 2026 é WinGet ou Scoop. Se você prefere um ambiente Linux para builds e ferramentas de linha de comando, considere instalar pelo [WSL](/instalacao/instalar-zig-wsl/). Para instruções mais detalhadas só de Windows, use o guia [Como instalar Zig no Windows](/instalacao/instalar-zig-windows/).

### Opção 1: WinGet (Recomendada — Windows 10/11)

O WinGet é o gerenciador de pacotes oficial da Microsoft, já incluído no Windows 10 (versões recentes) e Windows 11:

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

Feche e reabra o terminal, depois verifique:

```powershell
zig version
```

### Opção 2: Scoop

O [Scoop](https://scoop.sh/) é um excelente gerenciador de pacotes para Windows:

```powershell
# Se você ainda não tem o Scoop instalado:
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
irm get.scoop.sh | iex

# Instalar o Zig
scoop install zig
```

### Opção 3: Chocolatey

O [Chocolatey](https://chocolatey.org/) é outro gerenciador popular:

```powershell
# Requer PowerShell como Administrador
choco install zig
```

### Opção 4: Instalação Manual

**Passo 1 — Baixe o arquivo:**

Acesse [ziglang.org/download](https://ziglang.org/download/) e baixe o arquivo `.zip` para Windows:

- **x86_64** (64-bit, a maioria dos PCs): `zig-x86_64-windows-0.15.2.zip`
- **aarch64** (Windows on ARM): `zig-aarch64-windows-0.15.2.zip`

Ou via PowerShell:

```powershell
# Download para Windows x86_64
Invoke-WebRequest -Uri "https://ziglang.org/download/0.15.2/zig-x86_64-windows-0.15.2.zip" -OutFile "zig-0.15.2.zip"
```

**Passo 2 — Extraia o ZIP:**

```powershell
Expand-Archive -Path "zig-0.15.2.zip" -DestinationPath "C:\zig"
```

**Passo 3 — Configure a variável PATH:**

Via PowerShell (adiciona permanentemente para o usuário atual):

```powershell
$zigPath = "C:\zig\zig-x86_64-windows-0.15.2"
[Environment]::SetEnvironmentVariable("Path", $env:Path + ";$zigPath", "User")
```

Ou pela interface gráfica:

1. Pressione `Win + R`, digite `sysdm.cpl` e pressione Enter.
2. Clique na aba **Avançado** → **Variáveis de Ambiente**.
3. Em "Variáveis do usuário", selecione **Path** e clique em **Editar**.
4. Clique em **Novo** e adicione: `C:\zig\zig-x86_64-windows-0.15.2`
5. Clique em **OK** em todas as janelas.

**Passo 4 — Verifique (abra um novo terminal):**

```powershell
zig version
# Saída esperada: 0.15.2
```

### Tabela Resumo: Métodos de Instalação no Windows

| Método | Comando | Atualização automática? |
|---|---|---|
| **WinGet** | `winget install zig.zig` | `winget upgrade zig.zig` |
| **Scoop** | `scoop install zig` | `scoop update zig` |
| **Chocolatey** | `choco install zig` | `choco upgrade zig` |
| **Manual** | Download + PATH | Manual (re-download) |

## Verificando a Instalação

Independente do método e sistema operacional, execute estes comandos para confirmar que tudo está funcionando:

### 1. Verificar a versão

```bash
zig version
```

Saída esperada:
```
0.15.2
```

### 2. Verificar o ambiente

```bash
zig env
```

Este comando mostra informações detalhadas sobre a instalação, incluindo caminhos, arquitetura-alvo e diretório da biblioteca padrão. Se este comando funciona, sua instalação está correta.

### 3. Zig Zen — A Filosofia do Zig

Experimente este comando especial:

```bash
zig zen
```

Saída:
```
 ▄▄▄▄▄ ▄▄▄▄▄ ▄▄▄▄▄
 █   █ █   █ █   █
 █   █ █   █ █   █
 ▀▄▄▄▀ ▀▄▄▄▀ ▀▄▄▄▀

Communicate your intent, not just to the compiler, but to other humans
  (and your future self).
Edge cases are not rarefied.
It is better to do less than to do more.
Do not communicate by the act of not communicating.
Fancy algorithms are slow when n is small, and n is usually small.
...
```

Esses são os princípios de design do Zig. Se você vê essa saída, parabéns — o Zig está instalado com sucesso! 🎉

## Configurando o Editor / IDE

Um bom editor torna a experiência com Zig muito mais produtiva. Veja como configurar os editores mais populares. Depois de configurar seu editor, confira também nosso guia de [debugging em Zig](/tutoriais/zig-debugging/) para aproveitar ao máximo as ferramentas de desenvolvimento. Se você já sabe que vai usar VS Code, pule direto para o guia dedicado de [configuração do VS Code para Zig](/instalacao/configurar-vscode-zig/).

### VS Code (Recomendado para Iniciantes)

O Visual Studio Code oferece a melhor experiência para Zig graças à extensão oficial.

**Passo 1 — Instale a extensão do Zig:**

1. Abra o VS Code.
2. Pressione `Ctrl+Shift+X` (ou `Cmd+Shift+X` no macOS) para abrir Extensions.
3. Pesquise por **"Zig Language"** (extensão oficial: `ziglang.vscode-zig`).
4. Clique em **Install**.

**Passo 2 — Instale o ZLS (Zig Language Server):**

O ZLS fornece autocomplete, go-to-definition, diagnóstico de erros em tempo real e muito mais.

A extensão oficial do VS Code pode instalar o ZLS automaticamente. Quando solicitado:

1. Abra o Command Palette (`Ctrl+Shift+P`).
2. Execute **"Zig Setup: Install Zig"** — isso configura o Zig e ZLS automaticamente.

Ou instale o ZLS manualmente:

```bash
# Linux / macOS
# Via gerenciador de pacotes (se disponível)
# Arch: sudo pacman -S zls
# Homebrew: brew install zls

# Ou baixe de: https://github.com/zigtools/zls/releases
```

**Passo 3 — Configure o VS Code:**

Abra as configurações do VS Code (`Ctrl+,`) e ajuste:

```json
{
    "zig.path": "zig",
    "zig.zls.path": "zls",
    "zig.formattingProvider": "zls",
    "editor.formatOnSave": true,
    "[zig]": {
        "editor.defaultFormatter": "ziglang.vscode-zig",
        "editor.tabSize": 4
    }
}
```

**Funcionalidades que você ganha com ZLS:**

- ✅ Autocomplete inteligente
- ✅ Go to Definition / Find References
- ✅ Diagnóstico de erros em tempo real
- ✅ Formatação automática ao salvar
- ✅ Hover com documentação
- ✅ Inlay hints (mostrar tipos inferidos)

### Neovim

Para usuários de Neovim com LSP nativo:

```lua
-- No seu init.lua (usando nvim-lspconfig)
require('lspconfig').zls.setup{
    cmd = { "zls" },
    filetypes = { "zig", "zon" },
    root_dir = require('lspconfig.util').root_pattern("build.zig", ".git"),
}
```

Certifique-se de que o ZLS está no seu PATH. Instale também o plugin [nvim-treesitter](https://github.com/nvim-treesitter/nvim-treesitter) com o parser para Zig:

```vim
:TSInstall zig
```

### Sublime Text

1. Instale o [Package Control](https://packagecontrol.io/).
2. Instale o pacote **"LSP"** e **"LSP-zig"**.
3. O LSP-zig configura o ZLS automaticamente.

### Emacs

Instale o pacote `zig-mode` via MELPA:

```elisp
(use-package zig-mode
  :ensure t)

;; Para LSP (com eglot, incluído no Emacs 29+)
(add-hook 'zig-mode-hook 'eglot-ensure)
```

### JetBrains (IntelliJ, CLion, etc.)

1. Abra **Settings → Plugins**.
2. Pesquise por **"Zig"** no Marketplace.
3. Instale o plugin **ZigBrains**.
4. Configure o caminho do Zig e ZLS em **Settings → Languages & Frameworks → Zig**.

## Seu Primeiro Programa: Hello World

Vamos criar e executar um programa simples para confirmar que tudo está funcionando corretamente.

### Criando o Projeto

**Opção A — Arquivo único (rápido):**

Crie um arquivo chamado `hello.zig`:

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

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

Compile e execute:

```bash
# Compilar e executar em um único comando
zig run hello.zig
```

Saída esperada:
```
Olá, Zig! 🎉
```

**Opção B — Projeto completo com `zig init` (recomendado):**

```bash
# Criar um diretório para o projeto
mkdir meu-projeto-zig
cd meu-projeto-zig

# Inicializar o projeto Zig
zig init
```

O comando `zig init` cria a seguinte estrutura (saiba mais sobre o [sistema de build do Zig](/tutoriais/zig-build-system/)):

```
meu-projeto-zig/
├── build.zig          # Configuração do build
├── build.zig.zon      # Manifesto de dependências
└── src/
    ├── main.zig       # Código principal
    └── root.zig       # Biblioteca
```

Veja o conteúdo do `src/main.zig` gerado:

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

pub fn main() !void {
    // Prints to stderr
    std.debug.print("All your {s} are belong to us.\n", .{"codebase"});

    // stdout is typically meant for the actual output of a program
    const stdout_file = std.io.getStdOut().writer();
    var bw = std.io.bufferedWriter(stdout_file);
    const stdout = bw.writer();

    try stdout.print("Run `zig build test` to run the tests.\n", .{});

    try bw.flush();
}
```

Compile e execute o projeto:

```bash
# Compilar e executar
zig build run
```

Para compilar gerando o binário otimizado:

```bash
# Build em modo release
zig build -Doptimize=.ReleaseFast

# O binário estará em:
# Linux/macOS: ./zig-out/bin/meu-projeto-zig
# Windows: .\zig-out\bin\meu-projeto-zig.exe
```

### Vamos Além: Um Programa Mais Interessante

Crie um arquivo `fatorial.zig` para testar mais features:

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

fn fatorial(n: u64) u64 {
    if (n == 0) return 1;
    return n * fatorial(n - 1);
}

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();

    try stdout.print("=== Calculadora de Fatorial ===\n\n", .{});

    for (0..13) |i| {
        try stdout.print("{}! = {}\n", .{ i, fatorial(i) });
    }

    try stdout.print("\n✅ Zig está funcionando perfeitamente!\n", .{});
}
```

Execute:

```bash
zig run fatorial.zig
```

Saída:
```
=== Calculadora de Fatorial ===

0! = 1
1! = 1
2! = 2
3! = 6
4! = 24
5! = 120
6! = 720
7! = 5040
8! = 40320
9! = 362880
10! = 3628800
11! = 39916800
12! = 479001600

✅ Zig está funcionando perfeitamente!
```

Se você viu essa saída, sua instalação está 100% funcional! 🎉

## Resolvendo Problemas Comuns

### ❌ "command not found: zig" ou "zig não é reconhecido"

**Causa:** O diretório do Zig não está no PATH.

**Solução — Linux/macOS:**
```bash
# Verifique onde o Zig está
which zig 2>/dev/null || echo "Zig não encontrado no PATH"

# Veja se o binário existe
ls -la /opt/zig/zig  # ou onde você instalou

# Adicione ao PATH (ajuste o caminho)
export PATH="/opt/zig:$PATH"

# Para tornar permanente, adicione ao seu ~/.bashrc ou ~/.zshrc
```

**Solução — Windows:**
```powershell
# Verifique o PATH atual
$env:Path -split ';' | Select-String "zig"

# Se vazio, adicione manualmente:
[Environment]::SetEnvironmentVariable("Path", $env:Path + ";C:\zig\zig-x86_64-windows-0.15.2", "User")

# IMPORTANTE: Feche e reabra o PowerShell após alterar o PATH
```

### ❌ "unable to find zig installation directory: FileNotFound"

**Causa:** O diretório `lib/` do Zig não está junto com o binário.

**Solução:** Certifique-se de que a estrutura de diretórios está intacta:
```
/opt/zig/
├── zig          # O binário
├── lib/         # A biblioteca padrão (DEVE estar aqui)
│   ├── std/
│   └── ...
└── doc/
```

Se você moveu apenas o binário `zig` sem o diretório `lib/`, o Zig não vai funcionar. Mova o diretório completo.

### ❌ "error: zig is not compatible with this version of..." (VS Code)

**Causa:** Incompatibilidade entre versões do Zig e do ZLS.

**Solução:**
```bash
# Verifique as versões
zig version
zls --version

# ZLS e Zig devem ser da MESMA versão major
# Se Zig é 0.15.x, ZLS também deve ser 0.15.x
```

Atualize o ZLS para a versão compatível ou use o instalador automático do VS Code:
1. `Ctrl+Shift+P` → **"Zig Setup: Install Zig"**

### ❌ Aviso de segurança no macOS (Gatekeeper)

**Causa:** O macOS bloqueia binários de fontes não identificadas.

**Solução:**
```bash
# Remover a quarentena do binário
xattr -d com.apple.quarantine /usr/local/zig/zig

# Ou vá em: Ajustes do Sistema → Privacidade e Segurança
# e clique em "Permitir mesmo assim"
```

### ❌ Versão antiga instalada via gerenciador de pacotes

**Causa:** Alguns gerenciadores de pacotes podem demorar a atualizar.

**Solução:**
```bash
# Verifique a versão atual
zig version

# Se estiver desatualizada:
# Ubuntu/Debian: considere instalação manual
# Arch: sudo pacman -Syu zig
# macOS: brew upgrade zig
# Windows: winget upgrade zig.zig
```

### ❌ Problemas de permissão no Linux

```bash
# Se o binário não tem permissão de execução:
chmod +x /opt/zig/zig

# Se não consegue mover para /opt/:
# Use a instalação no diretório do usuário (veja seção acima)
mkdir -p ~/apps/zig
# ... e adicione ~/apps/zig ao PATH
```

### ❌ Proxy corporativo impedindo download

```bash
# Configure o proxy antes de baixar
export HTTP_PROXY="http://proxy.empresa.com:8080"
export HTTPS_PROXY="http://proxy.empresa.com:8080"

# Depois faça o download normalmente
wget https://ziglang.org/download/0.15.2/zig-x86_64-linux-0.15.2.tar.xz
```

## Como Atualizar o Zig

### Gerenciadores de pacotes

```bash
# Homebrew (macOS)
brew upgrade zig

# Arch Linux
sudo pacman -Syu zig

# Scoop (Windows)
scoop update zig

# Chocolatey (Windows)
choco upgrade zig

# WinGet (Windows)
winget upgrade zig.zig

# Snap (Linux)
sudo snap refresh zig
```

### Instalação manual

Para atualizações manuais, basta repetir o processo de instalação com a nova versão. Por exemplo:

```bash
# 1. Baixe a nova versão
wget https://ziglang.org/download/NOVA_VERSAO/zig-x86_64-linux-NOVA_VERSAO.tar.xz

# 2. Remova a versão antiga
sudo rm -rf /opt/zig

# 3. Extraia e mova a nova versão
tar -xf zig-x86_64-linux-NOVA_VERSAO.tar.xz
sudo mv zig-x86_64-linux-NOVA_VERSAO /opt/zig

# 4. Verifique
zig version
```

O PATH não precisa ser alterado, pois o diretório continua o mesmo.

## Próximos Passos

Agora que o Zig está instalado e configurado, hora de colocar a mão na massa:

1. **Comece a aprender** — A [Introdução ao Zig](/tutoriais/introducao-ao-zig/) é o próximo passo ideal para quem acabou de instalar.
2. **Crie um projeto completo** — Siga [Primeiro projeto Zig](/instalacao/zig-primeiro-projeto/) para entender `build.zig`, `build.zig.zon` e `zig build`.
3. **Configure o editor** — Use [VS Code para Zig](/instalacao/configurar-vscode-zig/) ou [Neovim para Zig](/instalacao/configurar-neovim-zig/).
4. **Vem do C?** — Confira [Zig para Programadores C](/tutoriais/zig-para-programadores-c/) com comparações lado a lado.
5. **Vem do Python?** — Veja nosso guia [Zig para Programadores Python](/tutoriais/zig-para-programadores-python/).
6. **Gerencie versões** — Se trabalha em mais de um projeto, leia [gerenciar versões do Zig](/instalacao/zig-gerenciar-versoes/).
7. **Documentação oficial** — [ziglang.org/documentation](https://ziglang.org/documentation/master/) é a referência completa da linguagem.
8. **Comunidade** — Junte-se à [comunidade Zig Brasil](/comunidade/) e ao [Discord do Zig](https://discord.gg/zig) para tirar dúvidas.

---

*Encontrou algum problema que não está listado aqui? Deixe um comentário ou abra uma issue no nosso repositório. Este guia é atualizado regularmente com novos cenários de troubleshooting.*