├── mymath/                     # Pacote Python puro (wheel independente de plataforma)
│   ├── pyproject.toml
│   └── mymath/
│       ├── __init__.py
│       └── operations.py
├── mymath_fast/                # Pacote com extensão em C (wheel específico de plataforma)
│   ├── pyproject.toml
│   ├── setup.py
│   └── mymath_fast/
│       ├── __init__.py
│       └── _native.c
├── mymath_zig/                 # Pacote que compila C usando Zig (wheel específico de plataforma)
│   ├── pyproject.toml
│   ├── setup.py
│   └── mymath_zig/
│       ├── __init__.py
│       └── lib/
│           └── math.c
└── integration/                # App de exemplo simples
    ├── pyproject.toml
    └── main.py

# (Opcional) instale a ferramenta de build
python -m pip install --upgrade build

# Construa os wheels deste repositório
cd mymath && python -m build && cd ..
cd mymath_fast && python -m build && cd ..
cd mymath_zig && python -m build && cd ..

# Compare os tamanhos dos wheels gerados
ls -lh mymath/dist/*.whl mymath_fast/dist/*.whl mymath_zig/dist/*.whl

# Veja o que há dentro de cada wheel
unzip -l mymath/dist/mymath-0.1.0-py3-none-any.whl
unzip -l mymath_fast/dist/mymath_fast-0.1.0-*.whl
unzip -l mymath_zig/dist/mymath_zig-0.1.0-*.whl

# Instale e teste o wheel de Python puro
pip install ./mymath/dist/mymath-0.1.0-py3-none-any.whl
python -c "from mymath import add, multiply; print(f'2 + 3 = {add(2, 3)}'); print(f'4 × 5 = {multiply(4, 5)}')"

# Instale e teste o wheel de extensão em C
pip install ./mymath_fast/dist/mymath_fast-0.1.0-*.whl
python -c "from mymath_fast import fast_add, fast_multiply; print(f'2 + 3 = {fast_add(2, 3)} (C)'); print(f'4 × 5 = {fast_multiply(4, 5)} (C)')"

# Instale e teste o wheel que usa Zig para compilar C
pip install ./mymath_zig/dist/mymath_zig-0.1.0-*.whl
python -c "import mymath_zig as mz; print(f'2 + 3 = {mz.add_int(2, 3)} (Zig/C)'); print(f'4 × 5 = {mz.multiply_int(4, 5)} (Zig/C)')"

O nome do arquivo do wheel de Python puro: mymath-0.1.0-py3-none-any.whl

• py3 = Python 3.x
• none = Sem dependência de ABI
• any = Funciona em QUALQUER plataforma (Linux, Mac, Windows, etc.)
• Tamanho: 2 KB

O nome do arquivo do wheel de extensão em C: mymath_fast-0.1.0-cp312-cp312-linux_x86_64.whl

• cp312 = CPython 3.12 especificamente
• cp312 = Tag ABI (deve corresponder à compilação do Python)
• linux_x86_64 = Funciona apenas no Linux x86_64
• Tamanho: 10 KB (5x maior para um exemplo trivial!)

1. Leia este README e explore os diretórios mymath, mymath_fast e mymath_zig
2. Examine o código de exemplo nos três pacotes
3. Construa, instale e teste os wheels (acima)

1. Modifique o exemplo de Python puro (adicione novas funções)
2. Reconstrua: cd mymath && python -m build
3. Modifique a extensão em C (adicione fast_subtract)
4. Reconstrua e veja a compilação acontecer

1. Entenda o exemplo mymath_zig e como o build com Zig funciona
2. Concentre-se no "Exemplo de Inchaço (Bloat) do PyPI no Mundo Real"
3. Entenda por que o numpy precisa de 500 MB por release

1. Instale o Zig: https://ziglang.org/download/
2. Tente fazer a compilação cruzada de um arquivo C simples
3. Migre a extensão _native.c para Zig
4. Faça a compilação cruzada para múltiplos alvos

Em Python com extensões em C, atualmente você faz isso:

# Precisa de uma máquina Linux
docker run --platform linux/amd64 python:3.12 python -m build
docker run --platform linux/arm64 python:3.12 python -m build

# Precisa de uma máquina macOS (não é possível fazer compilação cruzada a partir do Linux)
ssh mac-builder "cd project && python3.12 -m build"

# Precisa de uma máquina Windows (não é possível fazer compilação cruzada a partir do Linux)
ssh windows-builder "cd project && python.exe -m build"

Isso é insano!

Você precisa de mais de 3 máquinas para construir para 3 plataformas, e precisa repetir isso para cada versão do Python (3.8, 3.9, 3.10, 3.11, 3.12, etc).

Com Zig, você poderia fazer isso (a partir de UMA máquina):

zig build-lib native.zig -target x86_64-linux
zig build-lib native.zig -target aarch64-linux
zig build-lib native.zig -target x86_64-macos
zig build-lib native.zig -target aarch64-macos
zig build-lib native.zig -target x86_64-windows
# Tudo construído a partir do seu laptop Linux em < 5 minutos

• Instalações mais rápidas (downloads menores)
• Menos erros de "falha na compilação"
• Mais plataformas suportadas (IoT, sistemas embarcados, etc.)

• CI/CD mais simples (uma máquina em vez de 3-5)
• Releases mais rápidas (5 min em vez de 2 horas)
• Custos mais baixos (redução de 80% no uso de CI/CD)

• Custos de armazenamento mais baixos (redução de 40-70%)
• Custos de largura de banda mais baixos
• Melhor sustentabilidade

• Incentiva mais extensões em C (mais fáceis de distribuir)
• Melhor suporte cross-platform
• Moderniza as ferramentas do Python

1. ✅ Entender o que são wheels (leia este README)
2. ✅ Ver o problema do inchaço em primeira mão (compare os tamanhos dos wheels)
3. ⬜ Testar os wheels construídos

1. ⬜ Instalar o Zig
2. ⬜ Migrar a extensão C para Zig
3. ⬜ Fazer a compilação cruzada para múltiplos alvos
4. ⬜ Comparar tamanhos de binários e tempos de construção

1. ⬜ Escolher um pacote PyPI real, mas simples, com extensões em C
2. ⬜ Criar uma ferramenta de construção baseada em Zig para ele
3. ⬜ Benchmark: tempo de construção, tamanho do binário, desempenho em tempo de execução
4. ⬜ Documentar as descobertas

1. ⬜ Escrever uma PEP (Python Enhancement Proposal)
2. ⬜ Construir apoio da comunidade
3. ⬜ Criar ferramentas para adoção mais ampla
4. ⬜ Trabalhar com pacotes principais (numpy, scipy, pandas)

• PEP 427: https://peps.python.org/pep-0427/ (Especificação do formato Wheel)
• PEP 491: https://peps.python.org/pep-0491/ (Melhorias mais recentes no Wheel)
• PEP 517: https://peps.python.org/pep-0517/ (Interface do sistema de construção)

• Referência da Linguagem Zig: https://ziglang.org/documentation/master/
• Zig Learn: https://ziglearn.org/
• Guia de cross compilation: https://zig.news/kristoff/cross-compile-a-c-c-project-with-zig-3599

Wheel: Um pacote Python pré-compilado (como um .deb ou .rpm para Python)

Wheel específico para plataforma: Contém código C/C++/Rust compilado, funciona apenas em OS/arquitetura específicos

Inchaço (Bloat) do PyPI: Resultado da necessidade de wheels separados para cada combinação de Versão do Python × OS × Arquitetura

Compilação cruzada (Cross-compilation): Construir para a Plataforma B enquanto está na Plataforma A (Zig se destaca nisso)

Construção Hermética (Hermetic build): Construção reproduzível que não depende do estado do sistema hospedeiro (Zig oferece isso)