Skip to content

Latest commit

 

History

History
590 lines (425 loc) · 37.3 KB

overview.pt.md

File metadata and controls

590 lines (425 loc) · 37.3 KB
Raw
title mobile_menu_title toc
Visão Geral em Profundidade
Visão Geral
true

Destaques

Linguagem simples e pequena

Concentre-se na depuração de sua aplicação em vez de depurar seus conhecimentos em uma linguagem de programação.

Toda a sintaxe do Zig é especificada com um Arquivo gramatical PEG de 500 linhas.

Não há nenhum fluxo de controle oculto, nenhuma alocação de memória oculta, nenhum pré-processador, e nenhuma macros. Se o código Zig não parece estar pulando para chamar uma função, então não está. Isto significa que você pode ter certeza de que o seguinte código chama apenas foo() e depois bar(), e isto é garantido sem a necessidade de saber os tipos de nada:

var a = b + c.d;
foo();
bar();

Exemplos de fluxo de controle oculto:

  • D tem funções @property, que são métodos que você chama com o que parece ser acesso de campo, então no exemplo acima, c.d poderia chamar uma função.
  • C++, D, e Rust têm sobrecarga do operador, portanto o operador + pode chamar uma função.
  • C++, D, e Go têm exceções do tipo throw/catch, portanto foo() pode lançar uma exceção, e impedir que bar() seja chamado.

Zig promove a manutenção do código e a legibilidade, fazendo com que todo o fluxo de controle seja gerenciado exclusivamente com palavras-chave do idioma e chamadas de função.

Performance and Safety: Choose Two

Zig tem quatro modos de construção, e todas elas podem ser misturadas e combinadas até a granularidade do escopo.

Parametro Debug ReleaseSafe ReleaseFast ReleaseSmall
Otimizações - melhorar a velocidade, depuração de danos, tempo de compilação de danos -O3 -O3 -Os
Verificações de segurança em tempo de execução - velocidade do dano, tamanho do dano, acidente ao invés de comportamento indefinido On On

Aqui temos Sobrecarga de Inteiros (Integer Overflow) que parece estar em tempo de compilação, independentemente do modo de construção:

{{< zigdoctest "assets/zig-code/features/1-integer-overflow.zig" >}}

Aqui está o que parece em tempo de execução, em construções verificadas em termos de segurança:

{{< zigdoctest "assets/zig-code/features/2-integer-overflow-runtime.zig" >}}

Esses rastreamentos de pilhas funcionam em todos os alvos, incluindo freestanding.

Com Zig pode-se confiar em um modo de construção safe-enabled, e desativar seletivamente a segurança nos gargalos de desempenho. Por exemplo, o exemplo anterior poderia ser modificado desta forma:

{{< zigdoctest "assets/zig-code/features/3-undefined-behavior.zig" >}}

Zig utiliza comportamento indefinido com inteligência tanto para a prevenção de bugs quanto para a melhoria do desempenho.

Por falar em desempenho, Zig é mais rápido que C.

  • A implementação de referência utiliza LLVM como um backend para as otimizações de ponta.
  • O que outros projetos chamam de "Link Time Optimization" e Zig faz automaticamente.
  • For native targets, advanced CPU features are enabled (-march=native), thanks to the fact that Cross-compiling is a first-class use case.
  • Comportamento cuidadosamente escolhido e indefinido. Por exemplo, em Zig, tanto os inteiros assinados como os não assinados têm um comportamento indefinido no transbordamento, ao contrário de apenas os inteiros assinados em C. Isto facilitates optimizations that are not available in C.
  • Zig expõe diretamente a vetores tipo SIMD, facilitando a escrita de código vetorizado portátil.

Favor notar que Zig não é uma linguagem totalmente segura. Para aqueles interessados em seguir a história de segurança do Zig, inscrevam-se para estas questões:

Zig compete com C, em vez de depender dele

A biblioteca padrão do Zig se integra com a libc, mas não depende dela. Aqui está o "Hello World":

{{< zigdoctest "assets/zig-code/features/4-hello.zig" >}}

Quando compilado com -O ReleaseSmall, símbolos de depuração são removidos (stripped), modo de thread única, isto produz um executável estático de 9,8 KiB para o alvo x86_64-linux:

$ zig build-exe hello.zig --release-small --strip --single-threaded
$ wc -c hello
9944 hello
$ ldd hello
  not a dynamic executable

No Windows é ainda menor, gerando um binário de 4096 bytes:

$ zig build-exe hello.zig --release-small --strip --single-threaded -target x86_64-windows
$ wc -c hello.exe
4096 hello.exe
$ file hello.exe
hello.exe: PE32+ executable (console) x86-64, for MS Windows

Pedir declarações independentes de alto nível

Declarações de alto nível, tais como variáveis globais, são independentes de ordem e analisadas preguiçosamente. O valor de inicialização das variáveis globais é avaliado em tempo de compilação.

{{< zigdoctest "assets/zig-code/features/5-global-variables.zig" >}}

Tipo optional em vez de ponteiros nulos

Em outras linguagens de programação, referências nulas são a fonte de muitas exceções de tempo de execução, e até mesmo são acusadas de ser o pior erro da ciência da computação.

As indicações Unadorned Zig não podem ser nulas:

{{< zigdoctest "assets/zig-code/features/6-null-to-ptr.zig" >}}

Entretanto, qualquer tipo pode ser transformado em um tipo optional prefixando-o com ?:

{{< zigdoctest "assets/zig-code/features/7-optional-syntax.zig" >}}

Para utilizar um valor opcional, pode-se utilizar orelse para fornecer um valor padrão:

{{< zigdoctest "assets/zig-code/features/8-optional-orelse.zig" >}}

Outra opção é usar if:

{{< zigdoctest "assets/zig-code/features/9-optional-if.zig" >}}

A mesma sintaxe funciona com while:

{{< zigdoctest "assets/zig-code/features/10-optional-while.zig" >}}

Gerenciamento manual de memória

Uma biblioteca escrita em Zig é elegível para ser usada em qualquer lugar:

Para conseguir isto, os programadores Zig devem gerenciar sua própria memória e devem lidar com falhas na alocação de memória.

Isto também é verdade para a Biblioteca Padrão Zig. Qualquer função que precise alocar memória aceita um parâmetro do alocador. Como resultado, a Biblioteca Padrão Zig pode ser usada até mesmo para o alvo freestanding.

Além de Uma nova tomada de controle de erros, Zig fornece defer e errdefer para tornar a gestão de todos os recursos - não apenas a memória - simples e facilmente verificável.

Por exemplo o defer, veja Integração com bibliotecas C sem FFI/bindings. Aqui está um exemplo de utilização de errdefer: {{< zigdoctest "assets/zig-code/features/11-errdefer.zig" >}}

Uma nova tomada de controle de erros

Os erros são valores, e não podem ser ignorados:

{{< zigdoctest "assets/zig-code/features/12-errors-as-values.zig" >}}

Os erros podem ser tratados com catch:

{{< zigdoctest "assets/zig-code/features/13-errors-catch.zig" >}}

A palavra-chave try é um atalho para catch |err| return err:

{{< zigdoctest "assets/zig-code/features/14-errors-try.zig" >}}

Note que é um Rastreamento do retorno de erro, não um rastreamento da pilha. O código não pagou o preço de desenrolar a pilha para chegar a esse rastreamento.

O switch palavra-chave utilizada em um erro garante que todos os erros possíveis sejam tratados:

{{< zigdoctest "assets/zig-code/features/15-errors-switch.zig" >}}

A palavra-chave unreachable é usado para afirmar que não ocorrerão erros:

{{< zigdoctest "assets/zig-code/features/16-unreachable.zig" >}}

Isto invoca um comportamento indefinido nos modos de construção inseguros, portanto, certifique-se de usá-lo somente quando o sucesso for garantido.

Rastreamento de pilha em todos os alvos

O rastreamento da pilha e rastreamento do retorno de erros mostram que nesta página funcionam todos os alvos da Tier 1 Support e alguns da Tier 2 Support. Even freestanding!

Além disso, a biblioteca padrão tem a capacidade de capturar um traço de pilha em qualquer ponto e depois despejá-la em erro padrão mais tarde:

{{< zigdoctest "assets/zig-code/features/17-stack-traces.zig" >}}

Você pode ver esta técnica sendo utilizada no projeto GeneralPurposeDebugAllocator.

Estruturas e funções genéricas de dados

Os tipos são valores que devem ser conhecidos em tempo de compilação:

{{< zigdoctest "assets/zig-code/features/18-types.zig" >}}

Uma estrutura de dados genérica é simplesmente uma função que retorna um type:

{{< zigdoctest "assets/zig-code/features/19-generics.zig" >}}

Compilar o tempo de reflexão e compilar o tempo de execução do código

A função de construção @typeInfo proporciona reflexão:

{{< zigdoctest "assets/zig-code/features/20-reflection.zig" >}}

A Biblioteca Padrão Zig usa esta técnica para implementar a impressão formatada. Apesar de ser uma Linguagem simples e pequena, A impressão formatada em Zig é implementada inteiramente em Zig. Enquanto isso, em C, os erros de compilação para impressão são codificados pelo compilador de forma arcaica. Da mesma forma, em Rust a macro de impressão formatada é codificada de forma arcaica e complexa pelo compilador.

Zig também pode avaliar funções e blocos de código em tempo de compilação. Em alguns contextos, tais como inicializações globais de variáveis, a expressão é implicitamente avaliada em tempo de compilação. Caso contrário, é possível avaliar explicitamente o código em tempo de compilação com a palavra-chave comptime. Isto pode ser especialmente poderoso quando combinado com afirmações:

{{< zigdoctest "assets/zig-code/features/21-comptime.zig" >}}

Integration with C libraries without FFI/bindings

@cImport importa diretamente tipos, variáveis, funções e macros simples para uso em Zig. Ele até traduz funções em linha de C para Zig.

Aqui está um exemplo de emissão de uma onda sinusoidal usando libsoundio:

sine.zig {{< zigdoctest "assets/zig-code/features/22-sine-wave.zig" >}}

$ zig build-exe sine.zig -lsoundio -lc
$ ./sine
Output device: Built-in Audio Analog Stereo
^C

This Zig code is significantly simpler than the equivalent C code, bem como ter mais proteções de segurança, e tudo isso é conseguido através da importação direta do arquivo de cabeçalho C - sem ligações de API.

Zig é melhor no uso de bibliotecas C do que C é no uso de bibliotecas C.

O Zig também é um compilador C

Aqui está um exemplo de Zig compilando código C:

hello.c

#include <stdio.h>

int main(int argc, char **argv) {
    printf("Hello world\n");
    return 0;
}
$ zig build-exe --c-source hello.c --library c
$ ./hello
Hello world

Você pode utilizar --verbose-cc para ver quais os comandos que o compilador C executará:

$ zig build-exe --c-source hello.c --library c --verbose-cc
zig cc -MD -MV -MF zig-cache/tmp/42zL6fBH8fSo-hello.o.d -nostdinc -fno-spell-checking -isystem /home/andy/dev/zig/build/lib/zig/include -isystem /home/andy/dev/zig/build/lib/zig/libc/include/x86_64-linux-gnu -isystem /home/andy/dev/zig/build/lib/zig/libc/include/generic-glibc -isystem /home/andy/dev/zig/build/lib/zig/libc/include/x86_64-linux-any -isystem /home/andy/dev/zig/build/lib/zig/libc/include/any-linux-any -march=native -g -fstack-protector-strong --param ssp-buffer-size=4 -fno-omit-frame-pointer -o zig-cache/tmp/42zL6fBH8fSo-hello.o -c hello.c -fPIC

Note que se eu executar o comando novamente, não há saída, e ele termina instantaneamente:

$ time zig build-exe --c-source hello.c --library c --verbose-cc

real	0m0.027s
user	0m0.018s
sys	0m0.009s

Isto se deve a Cache de Compilação. Zig analisa automaticamente o arquivo .d usando um sistema de cache robusto para evitar duplicação de trabalho.

O Zig não só pode compilar o código C, mas há uma razão muito boa para usar Zig como um compilador C: Zig embarca com a libc.

Exportar funções, variáveis e tipos definidos pelo código C para depender de

Um dos casos de uso primário para Zig é a exportação de uma biblioteca com a ABI C para outras linguagens de programação a serem utilizadas. A palavra-chave export em frente às funções, variáveis e tipos faz com que elas façam parte da API da biblioteca:

mathtest.zig {{< zigdoctest "assets/zig-code/features/23-math-test.zig" >}}

Fazer uma biblioteca estática:

$ zig build-lib mathtest.zig

Fazer uma biblioteca dinâmica:

$ zig build-lib mathtest.zig -dynamic

Eis um exemplo com o Sistema de Construção do Zig:

test.c

#include "mathtest.h"
#include <stdio.h>

int main(int argc, char **argv) {
    int32_t result = add(42, 1337);
    printf("%d\n", result);
    return 0;
}

build.zig {{< zigdoctest "assets/zig-code/features/24-build.zig" >}}

$ zig build test
1379

A compilação cruzada é um caso de uso de primeira classe

Zig pode construir para qualquer um dos alvos a partir da Tabela de Suporte com Tier 3 Support ou melhor. Nenhum "conjunto de ferramentas cruzada" precisa ser instalada ou algo parecido. Aqui está um "Hello World" nativo:

{{< zigdoctest "assets/zig-code/features/4-hello.zig" >}}

Você pode compilar para: x86_64-windows, x86_64-macosx, e aarch64v8-linux:

$ zig build-exe hello.zig -target x86_64-windows
$ file hello.exe
hello.exe: PE32+ executable (console) x86-64, for MS Windows
$ zig build-exe hello.zig -target x86_64-macosx
$ file hello
hello: Mach-O 64-bit x86_64 executable, flags:<NOUNDEFS|DYLDLINK|TWOLEVEL|PIE>
$ zig build-exe hello.zig -target aarch64v8-linux
$ file hello
hello: ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), statically linked, with debug_info, not stripped

Isto funciona em qualquer Tier 3+ alvos, para qualquer Tier 3+ alvos.

Zig embarca com libc

Você pode encontrar os alvos libc disponíveis com zig targets:

...
 "libc": [
  "aarch64_be-linux-gnu",
  "aarch64_be-linux-musl",
  "aarch64_be-windows-gnu",
  "aarch64-linux-gnu",
  "aarch64-linux-musl",
  "aarch64-windows-gnu",
  "armeb-linux-gnueabi",
  "armeb-linux-gnueabihf",
  "armeb-linux-musleabi",
  "armeb-linux-musleabihf",
  "armeb-windows-gnu",
  "arm-linux-gnueabi",
  "arm-linux-gnueabihf",
  "arm-linux-musleabi",
  "arm-linux-musleabihf",
  "arm-windows-gnu",
  "i386-linux-gnu",
  "i386-linux-musl",
  "i386-windows-gnu",
  "mips64el-linux-gnuabi64",
  "mips64el-linux-gnuabin32",
  "mips64el-linux-musl",
  "mips64-linux-gnuabi64",
  "mips64-linux-gnuabin32",
  "mips64-linux-musl",
  "mipsel-linux-gnu",
  "mipsel-linux-musl",
  "mips-linux-gnu",
  "mips-linux-musl",
  "powerpc64le-linux-gnu",
  "powerpc64le-linux-musl",
  "powerpc64-linux-gnu",
  "powerpc64-linux-musl",
  "powerpc-linux-gnu",
  "powerpc-linux-musl",
  "riscv64-linux-gnu",
  "riscv64-linux-musl",
  "s390x-linux-gnu",
  "s390x-linux-musl",
  "sparc-linux-gnu",
  "sparcv9-linux-gnu",
  "wasm32-freestanding-musl",
  "x86_64-linux-gnu",
  "x86_64-linux-gnux32",
  "x86_64-linux-musl",
  "x86_64-windows-gnu"
 ],

O que isto significa é que --library c para estes alvos não depende de nenhum arquivo do sistema!

Vejamos o exemplo hello world em C novamente:

$ zig build-exe --c-source hello.c --library c
$ ./hello
Hello world
$ ldd ./hello
	linux-vdso.so.1 (0x00007ffd03dc9000)
	libc.so.6 => /lib/libc.so.6 (0x00007fc4b62be000)
	libm.so.6 => /lib/libm.so.6 (0x00007fc4b5f29000)
	libpthread.so.0 => /lib/libpthread.so.0 (0x00007fc4b5d0a000)
	libdl.so.2 => /lib/libdl.so.2 (0x00007fc4b5b06000)
	librt.so.1 => /lib/librt.so.1 (0x00007fc4b58fe000)
	/lib/ld-linux-x86-64.so.2 => /lib64/ld-linux-x86-64.so.2 (0x00007fc4b6672000)

glibc não suporta estaticamente a construção, mas musl suporta:

$ zig build-exe --c-source hello.c --library c -target x86_64-linux-musl
$ ./hello
Hello world
$ ldd hello
  not a dynamic executable

Neste exemplo, Zig construiu musl libc a partir da fonte e depois ligou-se a ela. A construção da musl libc para x86_64-linux continua disponível graças ao sistema de caching, portanto, a qualquer momento esta libc é necessária novamente, ela estará disponível instantaneamente.

Isto significa que esta funcionalidade está disponível em qualquer plataforma. Os usuários de Windows e macOS podem criar códigos Zig e C, e vincular-se a libc, para qualquer um dos alvos listados acima. Da mesma forma, o código pode ser compilado de forma cruzada para outras arquiteturas:

$ zig build-exe --c-source hello.c --library c -target aarch64v8-linux-gnu
$ file hello
hello: ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux-aarch64.so.1, for GNU/Linux 2.0.0, with debug_info, not stripped

Em alguns aspectos, Zig é um compilador C melhor do que os próprios compiladores C!

Esta funcionalidade é mais do que o agrupamento de um conjunto de ferramentas de compilação cruzada junto ao Zig. Por exemplo, o tamanho total dos cabeçalhos da libc que o Zig envia é de 22 MiB sem compressão. Enquanto isso, os cabeçalhos para musl libc + linux em x86_64 são 8 MiB, e para glibc são 3,1 MiB (falta no glibc os cabeçalhos linux), ainda assim Zig atualmente envia com 40 libcs. Com um agrupamento ingênuo que seria de 444 MiB. No entanto, graças a isto, a ferramenta process_headers que eu fiz, e algum bom e velho trabalho manual, Os tarballs binários Zig permanecem em torno de 30 MiB no total, apesar de apoiar a libc para todos esses alvos, bem como a compiler-rt, libunwind e libcxx, e apesar de ser um compilador C compatível com o clang. Para comparação, a construção binária do próprio Windows do clang 8.0.0 do llvm.org é de 132 MiB.

Note que apenas no Tier 1 Support os alvos foram exaustivamente testados. Está previsto acrescentar mais libcs (inclusive para o Windows), e para adicionar cobertura de testes para construção em relação a todas as libcs.

Já está sendo planejado para ter um Gerenciador de Pacotes do Zig, mas isso ainda não está pronto. Uma das coisas que será possível é criar um pacote para as bibliotecas C. Isto fará com que o Sistema de Construção do Zig tornando mais atraente tanto para programadores Zig como para programadores C.

Zig Build System

O Zig vem com um sistema de construção, por isso você não precisa fazer, fabricar ou qualquer coisa do gênero.

$ zig init-exe
Created build.zig
Created src/main.zig

Next, try `zig build --help` or `zig build run`

src/main.zig {{< zigdoctest "assets/zig-code/features/25-all-bases.zig" >}}

build.zig {{< zigdoctest "assets/zig-code/features/26-build.zig" >}}

Vamos dar uma olhada nesse menu --help.

$ zig build --help
Usage: zig build [steps] [options]

Steps:
  install (default)      Copy build artifacts to prefix path
  uninstall              Remove build artifacts from prefix path
  run                    Run the app

General Options:
  --help                 Print this help and exit
  --verbose              Print commands before executing them
  --prefix [path]        Override default install prefix
  --search-prefix [path] Add a path to look for binaries, libraries, headers

Project-Specific Options:
  -Dtarget=[string]      The CPU architecture, OS, and ABI to build for.
  -Drelease-safe=[bool]  optimizations on and safety on
  -Drelease-fast=[bool]  optimizations on and safety off
  -Drelease-small=[bool] size optimizations on and safety off

Advanced Options:
  --build-file [file]         Override path to build.zig
  --cache-dir [path]          Override path to zig cache directory
  --override-lib-dir [arg]    Override path to Zig lib directory
  --verbose-tokenize          Enable compiler debug output for tokenization
  --verbose-ast               Enable compiler debug output for parsing into an AST
  --verbose-link              Enable compiler debug output for linking
  --verbose-ir                Enable compiler debug output for Zig IR
  --verbose-llvm-ir           Enable compiler debug output for LLVM IR
  --verbose-cimport           Enable compiler debug output for C imports
  --verbose-cc                Enable compiler debug output for C compilation
  --verbose-llvm-cpu-features Enable compiler debug output for LLVM CPU features

Você pode ver que uma das etapas disponíveis é executada.

$ zig build run
All your base are belong to us.

Aqui estão alguns exemplos de scripts de construção:

Concorrência via funções Async

Zig v0.5.0 introduziu funções assíncronas. Esta característica não depende de um sistema operacional host ou mesmo de uma memória alocada em pilha. Isso significa que funções assimétricas estão disponíveis para o alvo freestanding.

Zig infere se uma função é assimétrica, e permite async/await em funções não assíncronas, o que significa que as bibliotecas Zig são agnósticos de bloqueio ao invés de E/S assíncrona. Zig evita as cores das funções (inglês).

A Biblioteca Padrão Zig implementa um loop de eventos que multiplexam as funções assimétricas em um pool de threads para concorrência M:N. A segurança multithreading e a detecção de corrida são áreas de pesquisa ativa.

Ampla gama de alvos suportados

Zig utiliza um sistema de "tiers" para comunicar o nível de suporte para diferentes alvos. Note que a barra para Tier 1 Support é maior - Tier 2 Support é ainda bastante útil.

Tabela de Suporte

free standing Linux 3.16+ macOS 10.13+ Windows 8.1+ FreeBSD 12.0+ NetBSD 8.0+ DragonFly​BSD 5.8+ UEFI
x86_64 Tier 1 Tier 1 Tier 1 Tier 2 Tier 2 Tier 2 Tier 2 Tier 2
arm64 Tier 1 Tier 2 Tier 2 Tier 3 Tier 3 Tier 3 N/A Tier 3
arm32 Tier 1 Tier 2 N/A Tier 3 Tier 3 Tier 3 N/A Tier 3
mips32 LE Tier 1 Tier 2 N/A N/A Tier 3 Tier 3 N/A N/A
i386 Tier 1 Tier 2 Tier 4 Tier 2 Tier 3 Tier 3 N/A Tier 2
riscv64 Tier 1 Tier 2 N/A N/A Tier 3 Tier 3 N/A Tier 3
bpf Tier 3 Tier 3 N/A N/A Tier 3 Tier 3 N/A N/A
hexagon Tier 3 Tier 3 N/A N/A Tier 3 Tier 3 N/A N/A
mips32 BE Tier 3 Tier 3 N/A N/A Tier 3 Tier 3 N/A N/A
mips64 Tier 3 Tier 3 N/A N/A Tier 3 Tier 3 N/A N/A
amdgcn Tier 3 Tier 3 N/A N/A Tier 3 Tier 3 N/A N/A
sparc Tier 3 Tier 3 N/A N/A Tier 3 Tier 3 N/A N/A
s390x Tier 3 Tier 3 N/A N/A Tier 3 Tier 3 N/A N/A
lanai Tier 3 Tier 3 N/A N/A Tier 3 Tier 3 N/A N/A
powerpc32 Tier 3 Tier 3 Tier 4 N/A Tier 3 Tier 3 N/A N/A
powerpc64 Tier 3 Tier 3 Tier 4 N/A Tier 3 Tier 3 N/A N/A
avr Tier 4 Tier 4 N/A N/A Tier 4 Tier 4 N/A N/A
riscv32 Tier 4 Tier 4 N/A N/A Tier 4 Tier 4 N/A Tier 4
xcore Tier 4 Tier 4 N/A N/A Tier 4 Tier 4 N/A N/A
nvptx Tier 4 Tier 4 N/A N/A Tier 4 Tier 4 N/A N/A
msp430 Tier 4 Tier 4 N/A N/A Tier 4 Tier 4 N/A N/A
r600 Tier 4 Tier 4 N/A N/A Tier 4 Tier 4 N/A N/A
arc Tier 4 Tier 4 N/A N/A Tier 4 Tier 4 N/A N/A
tce Tier 4 Tier 4 N/A N/A Tier 4 Tier 4 N/A N/A
le Tier 4 Tier 4 N/A N/A Tier 4 Tier 4 N/A N/A
amdil Tier 4 Tier 4 N/A N/A Tier 4 Tier 4 N/A N/A
hsail Tier 4 Tier 4 N/A N/A Tier 4 Tier 4 N/A N/A
spir Tier 4 Tier 4 N/A N/A Tier 4 Tier 4 N/A N/A
kalimba Tier 4 Tier 4 N/A N/A Tier 4 Tier 4 N/A N/A
shave Tier 4 Tier 4 N/A N/A Tier 4 Tier 4 N/A N/A
renderscript Tier 4 Tier 4 N/A N/A Tier 4 Tier 4 N/A N/A

Tabela de suporte para WebAssembly

free standing emscripten WASI
wasm32 Tier 1 Tier 3 Tier 1
wasm64 Tier 4 Tier 4 Tier 4

Tier System

Tier 1 Support

  • Not only can Zig generate machine code for these targets, but the standard library cross-platform abstractions have implementations for these targets. Thus it is practical to write a pure Zig application with no dependency on libc.
  • The CI server automatically tests these targets on every commit to master branch, and updates the download page with links to pre-built binaries.
  • These targets have debug info capabilities and therefore produce stack traces on failed assertions.
  • libc is available for this target even when cross compiling.
  • All the behavior tests and applicable standard library tests pass for this target. All language features are known to work correctly.

Tier 2 Support

  • The standard library supports this target, but it's possible that some APIs will give an "Unsupported OS" compile error. One can link with libc or other libraries to fill in the gaps in the standard library.
  • These targets are known to work, but may not be automatically tested, so there are occasional regressions.
  • Some tests may be disabled for these targets as we work toward Tier 1 Support.

Tier 3 Support

  • The standard library has little to no knowledge of the existence of this target.
  • Because Zig is based on LLVM, it has the capability to build for these targets, and LLVM has the target enabled by default.
  • These targets are not frequently tested; one will likely need to contribute to Zig in order to build for these targets.
  • The Zig compiler might need to be updated with a few things such as
    • what sizes are the C integer types
    • C ABI calling convention for this target
    • bootstrap code and default panic handler
  • zig targets is guaranteed to include this target.

Tier 4 Support

  • Support for these targets is entirely experimental.
  • LLVM may have the target as an experimental target, which means that you need to use Zig-provided binaries for the target to be available, or build LLVM from source with special configure flags. zig targets will display the target if it is available.
  • This target may be considered deprecated by an official party, such as macosx/i386 in which case this target will remain forever stuck in Tier 4.
  • This target may only support --emit asm and cannot emit object files.

Colaboradores de pacotes

O compilador Zig ainda não é completamente auto-hospedado, mas não importa o, permanecerá exatamente 3 etapas para deixar de usar um compilador C++ no sistema para ter um compilador Zig totalmente auto-hospedado para qualquer alvo. Como observa Maya Rashish, portando o Zig para outras plataformas é divertido e rápido.

Os modos de contrução sem depuração (non-debug) são reprodutíveis/determináveis.

Há um JSON version of the download page.

Vários membros da equipe Zig têm experiência na manutenção de pacotes.