Zig é uma linguagem de programação multiparadigma, compilada e de tipagem estática, projetada por Andrew Kelley. Projetada para desenvolvimento de sistemas de baixo nível com foco em legibilidade e previsibilidade, a linguagem oferece suporte à programação genérica em tempo de compilação, reflexão, compilação cruzada nativa e gerenciamento manual de memória. O projeto busca servir como uma alternativa moderna à linguagem C, incorporando conceitos inspirados em linguagens como Rust.
A linguagem possui recursos específicos para programação de baixo nível, como estruturas compactadas (packed structs), inteiros de largura arbitrária e múltiplos tipos de ponteiros.
O compilador oficial é escrito em Zig e utiliza a infraestrutura LLVM como back-end principal, juntamente com um back-end próprio em desenvolvimento. Distribuído sob a licença MIT, o compilador inclui suporte integrado para a compilação de código C e C++ através dos comandos zig cc e zig c++. O ecossistema de linguagens como Nim permite o uso de zig cc como compilador C alternativo.
O desenvolvimento é mantido pela Zig Software Foundation (ZSF), uma organização sem fins lucrativos presidida por Andrew Kelley.
Filosofia de design Ausência de fluxo de controle oculto A sintaxe da linguagem foi projetada para evitar execuções implícitas de código. No exemplo a seguir, garante-se que apenas a função foo() é chamada antes de bar(), independentemente dos tipos das variáveis envolvidas:
var a = b + c.d; foo(); bar();
Diferentemente de linguagens como a linguagem D (que possui propriedades acessadas como campos) ou Rust (que permite sobrecarga de operadores), o Zig não permite que o operador + ou o acesso c.d executem chamadas de função ocultas. Da mesma forma, a linguagem não utiliza exceções baseadas em lançamentos (throw/catch), garantindo a previsibilidade na sequência de execução.
Gerenciamento explícito de memória O Zig não possui operadores ou palavras-chave dedicados à alocação dinâmica de memória no âmbito da linguagem (como a palavra-chave new ou concatenações implícitas de strings). O gerenciamento de memória é tratado explicitamente pelas aplicações e bibliotecas por meio do repasse de instâncias de alocadores (interface Allocator).
Esse modelo evita alocações implícitas comuns em outras linguagens, tais como: O uso de defer para manipulação de pilhas dinâmicas em Go; Alocações em chamadas de corrotinas em C++ ou redimensionamentos automáticos de pilhas (goroutines); Comportamentos de interrupção abrupta (panic) na biblioteca padrão de Rust sob esgotamento de memória.
A ausência de um coletor de lixo integrado permite que bibliotecas em Zig sejam utilizadas em ambientes restritos (bare-metal ou sistemas embarcados). A biblioteca padrão disponibiliza alocadores opcionais para depuração de vazamentos e gerenciamento em arena.
Autonomia e portabilidade A biblioteca padrão do Zig e a dependência da libc são de uso opcional, facilitando a implantação em sistemas embarcados.
A linguagem visa garantir a interoperabilidade direta com a ABI do C, permitindo a criação de bibliotecas portáteis sem a necessidade de camadas intermediárias complexas (bindings).
Simplicidade sintática A linguagem não possui macros ou sistemas convencionais de metaprogramação, substituindo-os por execução de código no tempo de compilação através do bloco comptime. Não há suporte para sobrecarga de operadores, métodos de propriedade ou despacho dinâmico implícito.
Arquitetura do compilador O compilador do Zig passou por um processo de reestruturação do processo de inicialização (bootstrap), substituindo a implementação inicial em C++ por uma versão auto-hospedada baseada em WebAssembly.
Estágios de desenvolvimento O desenvolvimento histórico do compilador dividiu-se nas seguintes etapas: Etapa 0: Compilador inicial escrito em C++ (utilizando a infraestrutura LLVM); Etapa 1: Compilador escrito em C++ e Zig (etapa intermediária); Etapa 2: Compilador escrito inteiramente em Zig e auto-hospedado; Etapa 3: Compilador auto-hospedado compilando o seu próprio código-fonte.
A eliminação da base de código em C++ tornou obsoletos os parâmetros de compilação referentes à Etapa 1 a partir da versão 0.11, estabelecendo o compilador auto-hospedado (Etapa 2) como padrão do ecossistema.
Representação visual alt=Diagrama do compilador Zig|centro|commoldura|Etapas do compilador Zig
Software desenvolvido em Zig
Banco de Dados Tigerbeetle – banco de dados distribuído focado em transações financeiras.
Blockchain Sig – cliente validador para a rede Solana focado em desempenho.
Sistemas Embarcados MicroZig – framework para desenvolvimento de software em microcontroladores e sistemas embarcados.
Inteligência Artificial ZML – plataforma de inferência para modelos de aprendizado de máquina em ambientes de produção.
Motores Gráficos Mach Engine – motor de jogo e motor gráfico.
Ferramentas de Compilação Hermetic_cc_toolchain – cadeia de ferramentas Bazel C/C++ para compilação cruzada.
Emuladores de Terminal Ghostty – emulador de terminal acelerado por GPU e multiplataforma.
Ambientes de Execução Bun – interpretador e ambiente de execução para JavaScript e TypeScript.
Exemplos Olá Mundo e concatenação de strings const std = @import("std");
const debug = std.debug; const heap = std.heap; const mem = std.mem;
pub fn main() !void { const ola = "Olá,";
debug.print("\n{}{}\n", .{ ola, " mundo!" });
// Método 1: Concatenação em tempo de compilação const ola_mundo_comptime = ola ++ " mundo!"; debug.print("{}\n", .{ola_mundo_comptime});
// Método 2: Concatenação via alocador de memória var buf: u8 = undefined; const allocator = &heap.FixedBufferAllocator.init(&buf).allocator;
const ola_mundo_concatenated = try mem.concat(allocator, u8, &[_][]const u8{ ola, " mundo!" }); debug.print("{}\n", .{ola_mundo_concatenated});
// Método 3: Junção de strings via biblioteca padrão const ola_mundo_joined = try mem.join(allocator, " ", &[_][]const u8{ ola, "mundo!" }); debug.print("{}\n", .{ola_mundo_joined}); }
Interoperabilidade com a linguagem C const std = @import("std").c; const c = @cImport({ @cInclude("stdio.h"); });
pub fn main() void { _ = std.printf("Chamada direta da função printf do C\n"); _ = c.printf("Inclusão de cabeçalho C via @cImport\n"); }
Sequência de Fibonacci em tempo de compilação const expect = @import("std").testing.expect;
fn fibonacci(index: u32) u32 { if (index < 2) return index; return fibonacci(index - 1) + fibonacci(index - 2); }
test "fibonacci em tempo de execução e compilação" { // Validação em tempo de execução try expect(fibonacci(7) == 13);
// Validação em tempo de compilação comptime { try expect(fibonacci(7) == 13);
Estrutura de dados genérica fn LinkedList(comptime T: type) type { return struct { pub const Node = struct { prev: ?*Node, next: ?*Node, data: T,
first: ?*Node, last: ?*Node, len: usize,
pub fn main() void { var node = LinkedList(i32).Node { .prev = null, .next = null, .data = 1234,
var list = LinkedList(i32) { .first = &node, .last = &node, .len = 1,
Ver também C (linguagem de programação) C++ Rust (linguagem de programação)
Ligações externas
Categoria:Software usando a licença MIT Categoria:Compiladores e interpretadores livres Categoria:Sistemas embarcados Categoria:Softwares multiplataformas Categoria:Linguagens de programação Categoria:Software livre multiplataforma