---
title: "Como Instalar Zig no macOS — Homebrew, MacPorts e Manual"
url: "https://ziglang.com.br/instalacao/como-instalar-zig-no-macos-homebrew-macports-e-manual/"
markdown_url: "https://ziglang.com.br/instalacao/como-instalar-zig-no-macos-homebrew-macports-e-manual.MD"
description: "Guia completo para instalar o Zig no macOS com Homebrew, MacPorts ou download manual. Suporte para Intel e Apple Silicon (M1-M4)."
date: "2026-02-21"
author: "Zig Brasil"
---

# Como Instalar Zig no macOS — Homebrew, MacPorts e Manual

Guia completo para instalar o Zig no macOS com Homebrew, MacPorts ou download manual. Suporte para Intel e Apple Silicon (M1-M4).


# Como Instalar Zig no macOS

Este guia cobre a instalação do compilador **Zig** no **macOS**, com suporte tanto para processadores **Intel** quanto **Apple Silicon** (M1, M2, M3, M4). Apresentamos três métodos: Homebrew (recomendado), MacPorts e download manual.

Para uma visão geral de todas as plataformas, consulte o [guia completo de instalação](/instalacao/). Se você está aprendendo Zig, comece pela [introdução ao Zig](/tutoriais/introducao-ao-zig/).

---

## Método 1: Homebrew (Recomendado)

O [Homebrew](https://brew.sh/) é o gerenciador de pacotes mais popular no macOS e a forma mais simples de instalar o Zig.

### Pré-requisito: Instalar o Homebrew

Se você ainda não tem o Homebrew instalado:

```bash
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```

Siga as instruções exibidas no terminal após a instalação.

### Passo 1: Instalar o Zig

```bash
brew install zig
```

O Homebrew vai baixar, compilar (se necessário) e configurar o Zig automaticamente. O processo leva de 1 a 5 minutos dependendo da velocidade da sua conexão.

### Passo 2: Verificar a Instalação

```bash
zig version
```

Saída esperada:

```
0.14.0
```

### Passo 3: Testar com um Programa

Crie um arquivo `hello.zig`:

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

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();
    try stdout.print("Zig funcionando no macOS!\n", .{});

    // Detectar a arquitetura do sistema
    const arch = @tagName(@import("builtin").cpu.arch);
    try stdout.print("Arquitetura: {s}\n", .{arch});
}
```

Execute:

```bash
zig run hello.zig
```

Em um Mac com Apple Silicon, a saída será:

```
Zig funcionando no macOS!
Arquitetura: aarch64
```

### Atualizando o Zig via Homebrew

```bash
brew update
brew upgrade zig
```

### Instalar uma Versão Específica

Para instalar a versão mais recente de desenvolvimento (HEAD):

```bash
brew install zig --HEAD
```

> **Nota:** A versão HEAD é compilada do código-fonte e pode levar mais tempo para instalar.

### Desinstalar via Homebrew

```bash
brew uninstall zig
```

---

## Método 2: MacPorts

O [MacPorts](https://www.macports.org/) é uma alternativa ao Homebrew, popular em ambientes acadêmicos e corporativos.

### Pré-requisito: Instalar o MacPorts

Baixe o instalador em [macports.org/install.php](https://www.macports.org/install.php) e siga as instruções para sua versão do macOS.

### Instalar o Zig

```bash
sudo port install zig
```

### Verificar

```bash
zig version
```

### Atualizar

```bash
sudo port selfupdate
sudo port upgrade zig
```

### Desinstalar

```bash
sudo port uninstall zig
```

---

## Método 3: Download Manual

O download manual é útil quando você precisa de uma versão específica do Zig ou quando não quer usar gerenciadores de pacotes.

### Passo 1: Identificar sua Arquitetura

```bash
uname -m
```

- `arm64` — Apple Silicon (M1, M2, M3, M4)
- `x86_64` — Intel

### Passo 2: Baixar o Zig

Para **Apple Silicon** (M1/M2/M3/M4):

```bash
curl -LO https://ziglang.org/download/0.14.0/zig-macos-aarch64-0.14.0.tar.xz
```

Para **Intel**:

```bash
curl -LO https://ziglang.org/download/0.14.0/zig-macos-x86_64-0.14.0.tar.xz
```

### Passo 3: Extrair

Para Apple Silicon:

```bash
tar -xf zig-macos-aarch64-0.14.0.tar.xz
```

Para Intel:

```bash
tar -xf zig-macos-x86_64-0.14.0.tar.xz
```

### Passo 4: Mover para um Diretório Permanente

```bash
sudo mv zig-macos-aarch64-0.14.0 /usr/local/zig
```

### Passo 5: Adicionar ao PATH

Para **Zsh** (padrão no macOS moderno):

```bash
echo 'export PATH="/usr/local/zig:$PATH"' >> ~/.zshrc
source ~/.zshrc
```

Para **Bash**:

```bash
echo 'export PATH="/usr/local/zig:$PATH"' >> ~/.bash_profile
source ~/.bash_profile
```

### Passo 6: Verificar

```bash
zig version
```

---

## macOS Gatekeeper e Segurança

Ao baixar o Zig manualmente, o macOS pode bloquear a execução por causa do Gatekeeper (sistema de segurança). Se você receber a mensagem **"zig cannot be opened because the developer cannot be verified"**, siga estes passos:

### Opção 1: Via Preferências do Sistema

1. Abra **Ajustes do Sistema** (System Settings)
2. Vá em **Privacidade e Segurança** (Privacy & Security)
3. Role até encontrar a mensagem sobre o Zig
4. Clique em **Permitir Mesmo Assim** (Allow Anyway)

### Opção 2: Via Terminal

```bash
# Remover o atributo de quarentena de todo o diretório do Zig
xattr -r -d com.apple.quarantine /usr/local/zig
```

### Opção 3: Usando spctl

```bash
sudo spctl --master-disable
# Execute o zig uma vez
zig version
# Reative o Gatekeeper
sudo spctl --master-enable
```

> **Recomendação:** A Opção 2 é a mais segura, pois remove a quarentena apenas do Zig, sem afetar a segurança geral do sistema.

---

## Apple Silicon vs. Intel

### Rosetta 2

Se você tem um Mac com Apple Silicon e precisa usar uma versão do Zig compilada para Intel (x86_64), o Rosetta 2 traduz automaticamente. Para instalar o Rosetta 2 (se ainda não estiver instalado):

```bash
softwareupdate --install-rosetta --agree-to-license
```

No entanto, recomendamos sempre usar a versão nativa para aarch64 no Apple Silicon, pois oferece melhor desempenho.

### Cross-Compilation no macOS

Uma das grandes vantagens do Zig é a cross-compilation integrada. No seu Mac, você pode compilar para qualquer plataforma:

```bash
# Compilar para Linux x86_64
zig build-exe --target=x86_64-linux-gnu hello.zig

# Compilar para Windows
zig build-exe --target=x86_64-windows-gnu hello.zig

# Compilar para Linux ARM (Raspberry Pi)
zig build-exe --target=aarch64-linux-gnu hello.zig
```

Exemplo completo de cross-compilation:

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

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

    try stdout.print("Sistema: {s}\n", .{@tagName(builtin.os.tag)});
    try stdout.print("Arquitetura: {s}\n", .{@tagName(builtin.cpu.arch)});
    try stdout.print("ABI: {s}\n", .{@tagName(builtin.abi)});
}
```

---

## Configurando o Terminal no macOS

### iTerm2 + Zsh

A maioria dos desenvolvedores no macOS usa iTerm2 com Zsh. Para uma experiência otimizada com Zig:

1. Instale o iTerm2: `brew install --cask iterm2`
2. Adicione o Zig ao PATH no `~/.zshrc` (se instalou manualmente)
3. Considere adicionar um alias útil:

```bash
# Adicionar ao ~/.zshrc
alias zb='zig build'
alias zr='zig run'
alias zt='zig test'
```

### Xcode Command Line Tools

Embora o Zig não dependa do Xcode, algumas bibliotecas do macOS podem precisar dos headers do SDK. Instale as Command Line Tools:

```bash
xcode-select --install
```

O Zig detecta automaticamente o SDK do macOS para linkar com bibliotecas do sistema. Se precisar especificar manualmente:

```bash
# Verificar onde está o SDK
xcrun --show-sdk-path
```

---

## Instalando o ZLS no macOS

O ZLS (Zig Language Server) pode ser instalado via Homebrew:

```bash
brew install zls
```

Ou via download manual, seguindo os mesmos passos do Zig. Depois de instalar, configure seu editor:

- [Configurar VS Code para Zig](/instalacao/configurar-vscode-zig/)
- [Configurar Neovim para Zig](/instalacao/configurar-neovim-zig/)
- [Outros editores](/instalacao/configurar-sublime-emacs-zig/)

---

## Problemas Comuns no macOS

### "No such file or directory" ao compilar

Verifique se o Xcode Command Line Tools está instalado:

```bash
xcode-select -p
```

Se não estiver, instale com `xcode-select --install`.

### Erro "unable to find macOS SDK"

O Zig precisa encontrar o SDK do macOS para compilar programas que usam bibliotecas do sistema. Isso geralmente é resolvido instalando o Xcode ou as Command Line Tools.

### Performance lenta na primeira compilação

A primeira compilação pode ser mais lenta enquanto o Zig preenche seu cache. Compilações subsequentes serão significativamente mais rápidas graças ao cache incremental.

Para mais soluções, visite nossa página de [erros comuns](/erros/).

---

## Próximos Passos

Com o Zig instalado no macOS:

1. **Configure seu editor** — [VS Code](/instalacao/configurar-vscode-zig/) ou [Neovim](/instalacao/configurar-neovim-zig/)
2. **Crie seu primeiro projeto** — [Primeiro projeto Zig](/instalacao/zig-primeiro-projeto/)
3. **Aprenda a linguagem** — [Introdução ao Zig](/tutoriais/introducao-ao-zig/)
4. **Gerencie versões** — [Gerenciar versões do Zig](/instalacao/zig-gerenciar-versoes/)
5. **Veja exemplos** — [Receitas](/receitas/)

Se você também usa Docker para desenvolvimento, confira nosso guia de [Zig com Docker](/instalacao/instalar-zig-docker/).