Zig e Python: Como Criar Extensões Nativas de Alta Performance

Desenvolvedores Python frequentemente enfrentam um dilema: a linguagem é produtiva e expressiva, mas quando o desempenho importa, o interpretador CPython se torna um gargalo. A solução tradicional sempre foi escrever extensões em C — mas C traz consigo gerenciamento manual de memória, undefined behavior e um ecossistema de build complexo.

A linguagem Zig oferece uma alternativa moderna e segura. Com compatibilidade nativa com a C ABI, cross-compilation embutida e sem alocações ocultas, Zig é uma candidata ideal para criar extensões Python de alta performance sem as armadilhas do C.

Neste artigo, vamos construir extensões Python com Zig passo a passo — desde uma shared library simples até integrações mais avançadas com benchmarks reais.

Por que Zig para Extensões Python?

Antes de partir para o código, vale entender por que Zig se destaca nesse cenário:

• Compatibilidade C ABI nativa: Zig pode exportar funções com export que seguem a convenção de chamada C, sem nenhum wrapper adicional. Python consegue chamar essas funções diretamente via ctypes ou cffi.
• Sem alocações ocultas: diferente de linguagens com garbage collector, Zig dá controle total sobre a memória, ideal para código de extensão onde a previsibilidade importa.
• Cross-compilation embutida: com o sistema de build do Zig, você compila para Linux, macOS e Windows a partir de qualquer plataforma.
• Sem dependências de runtime: a shared library gerada não depende de libstdc++ ou glibc específico, facilitando a distribuição.
• Segurança em tempo de compilação: o comptime permite validações em tempo de compilação que evitam bugs comuns em extensões C.

Criando uma Shared Library em Zig

O primeiro passo é criar uma biblioteca compartilhada (.so no Linux, .dylib no macOS, .dll no Windows) que exporte funções com C ABI.

Estrutura do Projeto

zig-python-ext/
  build.zig
  src/
    lib.zig
  python/
    benchmark.py
    test_extension.py

Código Zig: Funções Exportadas

Vamos criar uma função que processa um array de floats — um caso de uso comum em ciência de dados:

const std = @import("std");

// Soma vetorial otimizada
export fn soma_vetorial(ptr: [*]const f64, len: usize) f64 {
    const dados = ptr[0..len];
    var soma: f64 = 0.0;
    for (dados) |valor| {
        soma += valor;
    }
    return soma;
}

// Desvio padrão — operação comum em análise de dados
export fn desvio_padrao(ptr: [*]const f64, len: usize) f64 {
    const dados = ptr[0..len];
    const n: f64 = @floatFromInt(len);

    // Calcula a média
    var soma: f64 = 0.0;
    for (dados) |valor| {
        soma += valor;
    }
    const media = soma / n;

    // Calcula a variância
    var variancia: f64 = 0.0;
    for (dados) |valor| {
        const diff = valor - media;
        variancia += diff * diff;
    }
    variancia /= n;

    return @sqrt(variancia);
}

// Normalização min-max de um array (operação in-place)
export fn normalizar_minmax(ptr: [*]f64, len: usize) void {
    const dados = ptr[0..len];
    if (len == 0) return;

    var min: f64 = dados[0];
    var max: f64 = dados[0];

    for (dados) |valor| {
        if (valor < min) min = valor;
        if (valor > max) max = valor;
    }

    const intervalo = max - min;
    if (intervalo == 0.0) return;

    for (dados) |*valor| {
        valor.* = (valor.* - min) / intervalo;
    }
}

Observe o uso de export — essa keyword faz com que a função siga a convenção de chamada C e fique visível na tabela de símbolos da biblioteca.

Configuração do Build

O build.zig precisa criar uma shared library:

const std = @import("std");

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

    const lib = b.addSharedLibrary(.{
        .name = "zigext",
        .root_source_file = b.path("src/lib.zig"),
        .target = target,
        .optimize = optimize,
    });

    // Importante: gera a shared library no diretório de saída
    b.installArtifact(lib);
}

Para compilar com máxima performance:

zig build -Doptimize=ReleaseFast

Isso gera zig-out/lib/libzigext.so (ou equivalente no seu sistema).

Chamando Zig a Partir do Python com ctypes

O módulo ctypes da biblioteca padrão do Python é a forma mais direta de chamar funções em bibliotecas nativas:

import ctypes
import numpy as np
import os

# Carrega a biblioteca Zig
caminho = os.path.join(os.path.dirname(__file__), "../zig-out/lib/libzigext.so")
lib = ctypes.CDLL(caminho)

# Define os tipos de retorno e argumentos
lib.soma_vetorial.restype = ctypes.c_double
lib.soma_vetorial.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.c_size_t]

lib.desvio_padrao.restype = ctypes.c_double
lib.desvio_padrao.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.c_size_t]

lib.normalizar_minmax.restype = None
lib.normalizar_minmax.argtypes = [ctypes.POINTER(ctypes.c_double), ctypes.c_size_t]

# Cria dados de teste com NumPy
dados = np.random.rand(1_000_000).astype(np.float64)
ptr = dados.ctypes.data_as(ctypes.POINTER(ctypes.c_double))

# Chama as funções Zig
resultado_soma = lib.soma_vetorial(ptr, len(dados))
resultado_dp = lib.desvio_padrao(ptr, len(dados))

print(f"Soma: {resultado_soma:.6f}")
print(f"Desvio padrão: {resultado_dp:.6f}")

# Normalização in-place
lib.normalizar_minmax(ptr, len(dados))
print(f"Min após normalização: {dados.min():.6f}")
print(f"Max após normalização: {dados.max():.6f}")

A integração com NumPy é natural porque arrays NumPy são contíguos em memória — exatamente o que Zig espera receber via ponteiro.

Usando cffi para Integrações Mais Complexas

Para projetos maiores, o cffi oferece uma interface mais robusta que ctypes:

from cffi import FFI

ffi = FFI()

# Declaração das funções (como em um header C)
ffi.cdef("""
    double soma_vetorial(const double* ptr, size_t len);
    double desvio_padrao(const double* ptr, size_t len);
    void normalizar_minmax(double* ptr, size_t len);
""")

lib = ffi.dlopen("./zig-out/lib/libzigext.so")

# Cria um array com cffi
dados = ffi.new("double[]", [1.5, 2.3, 4.7, 3.1, 5.9])
resultado = lib.soma_vetorial(dados, 5)
print(f"Soma via cffi: {resultado}")

A vantagem do cffi é que a declaração das funções se parece com um header C — tornando o código mais legível e com melhor verificação de tipos.

O Projeto Pydust: Framework Zig-Native para Python

O pydust é um framework que leva a integração Zig-Python a outro nível. Em vez de usar C ABI + ctypes, ele gera módulos Python nativos diretamente a partir de Zig, similar ao que PyO3 faz para Rust.

Com pydust, você define módulos Python diretamente em Zig:

const py = @import("pydust");

pub const MeuModulo = py.module("meu_modulo");

pub fn soma_rapida(args: struct { a: f64, b: f64 }) f64 {
    return args.a + args.b;
}

// Registra a função no módulo Python
comptime {
    MeuModulo.function("soma_rapida", soma_rapida);
}

O resultado é um módulo .pyd/.so que pode ser importado diretamente no Python sem ctypes:

import meu_modulo
resultado = meu_modulo.soma_rapida(a=3.14, b=2.71)

Pydust ainda é um projeto jovem, mas demonstra o potencial do comptime do Zig para gerar layouts de tipos compatíveis com a API C do CPython em tempo de compilação.

Benchmarks: Zig vs Python vs Cython vs Rust (PyO3)

Para comparar de forma justa, implementamos o cálculo de desvio padrão em cada abordagem. O dataset contém 10 milhões de floats:

Os resultados mostram que Zig compete diretamente com Rust via PyO3, e com otimizações SIMD ativadas, pode superar todas as alternativas. O overhead do ctypes para a chamada é mínimo — na faixa de microsegundos — o que é irrelevante para operações que processam milhões de elementos.

Vale notar que NumPy já é altamente otimizado internamente (usa BLAS/LAPACK), então para operações que NumPy já implementa nativamente, a diferença pode ser menor. A vantagem do Zig aparece em operações customizadas que NumPy não oferece nativamente.

Processamento de Strings: Outro Caso de Uso

Extensões para processamento de texto são outro caso onde Zig brilha. Se você trabalha com parsing de dados, uma função que conta ocorrências de padrões pode ser muito mais rápida em Zig:

export fn contar_ocorrencias(
    texto_ptr: [*]const u8,
    texto_len: usize,
    padrao_ptr: [*]const u8,
    padrao_len: usize,
) usize {
    const texto = texto_ptr[0..texto_len];
    const padrao = padrao_ptr[0..padrao_len];

    if (padrao_len == 0 or padrao_len > texto_len) return 0;

    var contagem: usize = 0;
    var i: usize = 0;
    while (i <= texto_len - padrao_len) : (i += 1) {
        if (std.mem.eql(u8, texto[i..][0..padrao_len], padrao)) {
            contagem += 1;
        }
    }
    return contagem;
}

Para strings UTF-8 (o padrão em Python 3), Zig opera diretamente sobre os bytes sem nenhuma conversão, já que str em Python e slices de u8 em Zig compartilham a mesma representação.

Empacotamento e Distribuição

Para distribuir extensões Zig como pacotes Python, você pode usar o sistema de build do Zig integrado com setuptools:

# setup.py
import subprocess
from setuptools import setup, Extension
from setuptools.command.build_ext import build_ext

class ZigBuildExt(build_ext):
    def build_extension(self, ext):
        subprocess.check_call(["zig", "build", "-Doptimize=ReleaseFast"])
        # Copia a shared library para o diretório de saída
        ...

setup(
    name="meu-pacote-zig",
    ext_modules=[Extension("zigext", sources=[])],
    cmdclass={"build_ext": ZigBuildExt},
)

A cross-compilation do Zig simplifica a criação de wheels para múltiplas plataformas — algo notoriamente difícil com extensões C tradicionais.

Comparação: Zig vs Cython vs Rust (PyO3) vs C

A principal vantagem do Zig sobre Rust para extensões Python é a simplicidade: não há lifetime annotations, traits ou macros complexas. Se você quer migrar de C, Zig é o caminho mais natural.

Perguntas Frequentes

Zig é melhor que Cython para extensões Python?

Depende do caso de uso. Cython é mais maduro e tem melhor integração com o ecossistema Python. Porém, Zig oferece melhor performance, cross-compilation embutida e produz binários menores. Para operações numéricas e processamento de dados, Zig tende a ser superior.

Posso usar Zig com NumPy diretamente?

Sim. Arrays NumPy são contíguos em memória e podem ser passados como ponteiros via ctypes. A propriedade .ctypes.data_as() converte o array para o tipo de ponteiro correto sem cópia de dados.

O overhead de ctypes é significativo?

Para chamadas individuais, o overhead é de aproximadamente 1-5 microsegundos. Em loops Python chamando Zig milhares de vezes, esse overhead pode ser relevante — nesses casos, prefira passar arrays inteiros em vez de valores individuais, ou use cffi/pydust.

Zig suporta a API C do CPython?

Sim, como Zig tem interoperabilidade C completa, é possível incluir Python.h e usar a API C do CPython diretamente. Porém, para a maioria dos casos, ctypes ou cffi são mais simples e portáveis.

Como faço deploy de extensões Zig em produção?

Use o sistema de build do Zig para criar shared libraries otimizadas com -Doptimize=ReleaseFast. Distribua via wheel Python incluindo binários pré-compilados para cada plataforma-alvo. Para gerenciamento de dependências, use o build.zig.zon.

Conclusão

Zig oferece um caminho acessível e performático para criar extensões Python nativas. A combinação de C ABI compatível, ausência de runtime, cross-compilation embutida e segurança de memória torna Zig uma alternativa séria ao C e até ao Rust para esse tipo de trabalho.

Se você trabalha com ciência de dados, processamento de texto ou qualquer domínio onde Python é lento demais, vale experimentar Zig como sua linguagem de extensão. Com o ecossistema em crescimento e projetos como pydust amadurecendo, a integração Zig-Python tende a ficar ainda mais natural nos próximos anos.

Para ir mais fundo, explore nossos artigos sobre estratégias de alocação de memória, SIMD e testes em Zig — todos conceitos essenciais para escrever extensões robustas e performáticas.

Para aprofundar no ecossistema Python, visite nosso portal Python. Se você está avaliando alternativas para extensões nativas, veja também como Rust com PyO3 aborda o mesmo problema.

Confira também: Zig para Processamento de Dados: Parsing e Serialização de Alta Performance e Zig em Produção: Case Studies.