---
title: "Target Not Supported — Como Resolver em Zig"
url: "https://ziglang.com.br/erros/target-not-supported-como-resolver-em-zig/"
markdown_url: "https://ziglang.com.br/erros/target-not-supported-como-resolver-em-zig.MD"
description: "Entenda o erro de alvo de compilação não suportado em Zig. Veja como configurar targets corretos para cross-compilation e resolver incompatibilidades."
date: "2026-02-21"
author: "Zig Brasil"
---

# Target Not Supported — Como Resolver em Zig

Entenda o erro de alvo de compilação não suportado em Zig. Veja como configurar targets corretos para cross-compilation e resolver incompatibilidades.


# Target Not Supported — Como Resolver em Zig

## O Que Este Erro Significa

O erro de alvo não suportado ocorre quando o código ou uma dependência não é compatível com a plataforma de destino da compilação. Zig suporta dezenas de arquiteturas e sistemas operacionais, mas nem todo código funciona em todas as combinações. O erro pode vir do próprio Zig, de bibliotecas do sistema ou de recursos específicos de plataforma.

Mensagens típicas:

```
error: unsupported target: aarch64-windows
```

```
error: OS-specific code not available for this target
```

```
error: target does not support feature
```

## Causas Comuns

### 1. Código Específico de Plataforma

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

pub fn main() !void {
    // ERRO em plataformas não-Linux:
    const fd = try std.posix.open("/dev/null", .{}, 0);
    // std.posix não existe no Windows
    _ = fd;
}
```

### 2. Especificar Target Inválido

```bash
# Target que não existe
$ zig build-exe main.zig -target sparc-hurd-gnu
# ERRO: unsupported target
```

### 3. Biblioteca de Sistema Não Disponível para o Target

```zig
// build.zig
const exe = b.addExecutable(.{
    .name = "meu-projeto",
    .root_source_file = b.path("src/main.zig"),
    .target = b.resolveTargetQuery(.{
        .cpu_arch = .aarch64,
        .os_tag = .linux,
    }),
    .optimize = optimize,
});
// Biblioteca do sistema pode não existir para aarch64
exe.linkSystemLibrary("ssl");
```

### 4. Recurso de CPU Não Suportado

```zig
// build.zig
const target = b.resolveTargetQuery(.{
    .cpu_arch = .x86_64,
    .cpu_features_add = .{ .avx512f = true },
    // ERRO se o target não suporta AVX-512
});
```

### 5. ABI Incompatível

```bash
$ zig build-exe main.zig -target x86_64-linux-gnueabihf
# ERRO: ABI gnueabihf não é válida para x86_64
```

## Como Corrigir

### Solucao 1: Usar Código Portável com Detecção de Plataforma

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

pub fn main() void {
    if (builtin.os.tag == .linux) {
        // Código específico para Linux
        std.debug.print("Rodando no Linux\n", .{});
    } else if (builtin.os.tag == .windows) {
        // Código específico para Windows
        std.debug.print("Rodando no Windows\n", .{});
    } else if (builtin.os.tag == .macos) {
        // Código específico para macOS
        std.debug.print("Rodando no macOS\n", .{});
    } else {
        @compileError("Plataforma não suportada");
    }
}
```

### Solucao 2: Listar Targets Disponíveis

```bash
# Ver todos os targets suportados
$ zig targets

# Filtrar por arquitetura
$ zig targets | python3 -m json.tool | grep x86_64
```

### Solucao 3: Usar Target Correto no build.zig

```zig
// build.zig
const std = @import("std");

pub fn build(b: *std.Build) void {
    // Usar standardTargetOptions permite --target via CLI
    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});

    const exe = b.addExecutable(.{
        .name = "meu-projeto",
        .root_source_file = b.path("src/main.zig"),
        .target = target,
        .optimize = optimize,
    });

    b.installArtifact(exe);
}
```

```bash
# Compilar para o host (padrão)
$ zig build

# Cross-compile para Linux ARM64
$ zig build -Dtarget=aarch64-linux

# Cross-compile para Windows x86_64
$ zig build -Dtarget=x86_64-windows

# Cross-compile para macOS ARM64
$ zig build -Dtarget=aarch64-macos
```

### Solucao 4: Código Condicional com comptime

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

fn abrirArquivoTemp() !std.fs.File {
    const caminho = if (builtin.os.tag == .windows)
        "C:\\Temp\\dados.tmp"
    else
        "/tmp/dados.tmp";

    return std.fs.cwd().createFile(caminho, .{});
}
```

### Solucao 5: Vincular Bibliotecas Condicionalmente

```zig
// build.zig
const std = @import("std");

pub fn build(b: *std.Build) void {
    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});

    const exe = b.addExecutable(.{
        .name = "meu-projeto",
        .root_source_file = b.path("src/main.zig"),
        .target = target,
        .optimize = optimize,
    });

    // Vincular bibliotecas condicionalmente
    if (target.result.os.tag == .linux) {
        exe.linkSystemLibrary("epoll");
    } else if (target.result.os.tag == .macos) {
        exe.linkFramework("CoreFoundation");
    }

    exe.linkLibC();
    b.installArtifact(exe);
}
```

### Solucao 6: Usar musl para Cross-Compilation Linux

```bash
# musl é estaticamente linkada — funciona em qualquer Linux
$ zig build -Dtarget=x86_64-linux-musl
$ zig build -Dtarget=aarch64-linux-musl
```

## Targets Comuns

| Target | Descrição |
|--------|-----------|
| `x86_64-linux` | Linux 64-bit Intel/AMD |
| `aarch64-linux` | Linux ARM64 (Raspberry Pi 4, servidores ARM) |
| `x86_64-windows` | Windows 64-bit |
| `aarch64-macos` | macOS Apple Silicon |
| `x86_64-macos` | macOS Intel |
| `wasm32-freestanding` | WebAssembly |
| `x86_64-linux-musl` | Linux com libc estática |

## Verificar Recursos em Comptime

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

pub fn main() void {
    comptime {
        if (builtin.cpu.arch != .x86_64 and builtin.cpu.arch != .aarch64) {
            @compileError("Este programa requer x86_64 ou aarch64");
        }
    }

    std.debug.print("Arch: {}\n", .{builtin.cpu.arch});
    std.debug.print("OS: {}\n", .{builtin.os.tag});
}
```

## Erros Relacionados

- [build.zig not found](/erros/erro-build-zig-not-found/) — Arquivo de build não encontrado
- [Linker error](/erros/erro-linker-error/) — Erro de linker
- [@cImport failed](/erros/erro-c-import-failed/) — Falha ao importar cabeçalho C

## Links Úteis

- [Documentação oficial do Zig — Cross-compilation](https://ziglang.org/documentation/master/#Cross-compilation)
- [Documentação oficial do Zig — Targets](https://ziglang.org/documentation/master/#Targets)
- [Receitas de cross-compilation](/receitas/)
- [Tutorial sobre build system](/tutoriais/)