A melhor coisa que aconteceu ao Python em décadas está escrita em Rust

TL;DR: As ferramentas do Python são há anos um desastre fragmentado e lento. A revolução não veio de dentro do ecossistema: veio do Rust. uv, Ruff e ty — todas escritas em Rust pela Astral — substituíram meia dúzia de ferramentas e são entre 10x e 100x mais rápidas. Parece que afinal o culto do Ferris tinha razão.

Você já tentou explicar para alguém como instalar dependências em Python?

“Use o pip. Bom, mas dentro de um virtualenv. Ou venv, que é o novo. Mas se você tem várias versões do Python, precisa do pyenv. E para gerenciar o projeto, use o poetry. Ou o pipenv. Ou o pdm. Ou o conda se faz ciência de dados. Ah, e o lock file é gerado por cada ferramenta em um formato diferente. E não esqueça do setup.py. Bom, agora é pyproject.toml. Bom, às vezes as duas coisas.”

Se isso te soa familiar, você não está sozinho. Randall Munroe dedicou uma tirinha do xkcd em 2018 — um diagrama de espaguete mostrando todas as formas que o Python pode estar instalado na sua máquina. Oito anos depois, a tirinha continua relevante. Ou estava, até pouco tempo.

O cemitério de ferramentas

Vamos fazer um inventário. Para montar um projeto Python “moderno” antes de 2024, você precisava combinar — no mínimo — alguma seleção dessas peças:

Oito ferramentas — no mínimo — para o que em outros ecossistemas são uma ou duas. Cada uma com sua configuração, seu arquivo de config, suas incompatibilidades com as demais. Instalar o poetry dentro de um virtualenv criado pelo pyenv que por sua vez usa um Python instalado pelo Homebrew que acontece de ter outro pip global que… bem, você já entende.

E o pior: a cada poucos anos aparecia uma ferramenta nova que prometia unificar tudo. Pipenv seria a solução. Depois o poetry. Depois o pdm. O xkcd dos padrões ganhando vida em loop: “Temos 14 ferramentas, isso é absurdo. Vou criar uma ferramenta unificada. Agora temos 15 ferramentas.”

E então chegou um caranguejo

Em 2022, um cara chamado Charlie Marsh — ex-Khan Academy e Spring Discovery — publicou um linter de Python chamado Ruff. Escrito em Rust.

A reação da comunidade Python foi a previsível: “Legal, mais um linter”. Até que viram os números. Ruff era entre 10x e 100x mais rápido que o Flake8. Não 20% mais rápido. Não o dobro. Cem vezes mais rápido. Em uma base de código grande, um lint que demorava 30 segundos passava a demorar 300 milissegundos.

Mas o Ruff não se conformou em ser um linter rápido. Ele engoliu o Flake8, o Pylint, o isort e o Black. Uma ferramenta, um binário, zero dependências do Python. Faz lint, formata, ordena imports. E faz isso tão rápido que você pode executar a cada keystroke do editor sem notar lag.

Charlie fundou a Astral para dar estrutura ao projeto. E contratou gente interessante: entre a equipe estavam os autores do ripgrep, bat e hyperfine — ferramentas de terminal em Rust que já haviam demonstrado que reescrever utilitários clássicos em Rust não era um meme, mas uma melhoria objetiva.

uv: quando o pip parece uma conexão discada

Em fevereiro de 2024, a Astral soltou a bomba: uv. Um gerenciador de pacotes e projetos Python. Escrito em Rust.

Em termos claros: uv substitui pip, pip-tools, pipx, poetry, pyenv, virtualenv e twine. Tudo. Um único binário.

Sei o que você está pensando: “Tá bom, mais uma ferramenta que diz substituir tudo”. Mas é que os números são de ficção científica:

Isso não é um benchmark sintético. É o que você nota no seu dia a dia. O pip install que te dava tempo de buscar um café agora termina antes de você soltar o Enter.

E o uv não é apenas rápido. Tem lock files reproduzíveis, resolução de dependências multiplataforma, gestão de versões do Python integrada (uv python install 3.12 e pronto), e execução de scripts e ferramentas isoladas (uvx ruff check .). O que antes você precisava de cinco ferramentas para fazer, o uv faz com um comando.

ty: o último prego

Como se uv e Ruff não fossem o bastante, em dezembro de 2025 a Astral publicou o beta do ty: um type checker para Python. Escrito em Rust.

Os números, mais uma vez, são obscenos:

Depois de editar um arquivo no repo do PyTorch, ty recalcula os diagnósticos em 4.7 milissegundos. Pyright demora 386ms. Mypy… melhor nem perguntar.

ty tem intersection types, narrowing avançado e um language server com autocompletar, inlay hints e navegação de código. Não é um brinquedo rápido: é um type checker completo que, além disso, voa.

A tabela que dói

Vamos colocar os números lado a lado. O que você tinha antes, o que tem agora, e quanto mais rápido é:

Cinco categorias. Oito ou mais ferramentas heterogêneas substituídas por três que compartilham ecossistema, configuração e manutenção. Todas escritas em Rust. Todas da Astral.

Não é só Python: Ferris está devorando o terminal

E isso não é um fenômeno isolado do Python. Veja o que aconteceu com as ferramentas clássicas de terminal:

Cada uma dessas ferramentas segue o mesmo padrão: você pega um utilitário clássico do Unix que há 30 anos não tem uma melhoria de UX, reescreve em Rust com defaults modernos (cores, .gitignore, paralelismo), e o resultado é tão superior que as pessoas migram em uma tarde.

A ironia é linda: os mesmos desenvolvedores que diziam “reescrever em Rust é um meme” estão usando ripgrep, bat, fd e eza diariamente. Sem perceber, o culto do Ferris os converteu.

Distribuir um binário: a prova de fogo

E depois há a distribuição. Aqui é onde a diferença entre Python e Rust vai de “notável” para “obscena”.

Em Python, para distribuir um CLI para alguém que não tem Python instalado, você precisa de: setup.py + setup.cfg + pyproject.toml (qual? os três, por via das dúvidas), twine para subir ao PyPI rezando para a autenticação não falhar, PyInstaller ou Nuitka ou cx_Freeze para fazer binários (que não funcionam), um workflow de CI de 200 linhas que ninguém entende, manylinux wheels para cada versão do Python, e no final o usuário faz pip install e dá erro porque ele tem Python 3.9 e você compilou para 3.12.

Em Rust, isso é o que fiz com lql, um CLI que acabei de construir:

git tag v1.0.2 && git push origin v1.0.2

Um comando. Cinco minutos depois: 6 binários compilados para macOS (Apple Silicon + Intel), Linux (x86 + ARM + musl estático) e Windows. Instaladores gerados automaticamente: curl | sh para Mac/Linux, PowerShell para Windows, MSI para o pessoal de TI, e uma fórmula Homebrew publicada no seu tap. Tudo, a partir de uma tag no Git.

O binário pesa 4.7 MB. Sem runtime. Sem dependências. Você copia e funciona. Tenta fazer isso com Python sem desenvolver uma úlcera.

A cereja do bolo: o aluno supera o mestre

Aqui vem o que realmente explodiu minha cabeça.

As melhores ferramentas que aconteceram ao Python na última década — uv, Ruff, ty — não estão escritas em Python. Estão escritas em Rust. A linguagem que os pythonistas olhavam com desdém (“muito complicado”, “isso é para sistemas embarcados”, “borrow checker infernal”) acabou sendo a que consertou os problemas que o Python não conseguia consertar sozinho.

Por quê? Porque o gargalo dessas ferramentas não é a lógica — é o desempenho puro. Resolver um grafo de dependências com milhares de pacotes, parsear milhões de linhas de código procurando erros, verificar tipos em uma codebase de cem mil linhas. São problemas de força bruta onde cada milissegundo conta, e onde a diferença entre uma linguagem interpretada e uma compilada com zero-cost abstractions se nota.

Python é ótimo para escrever software. Mas as ferramentas que constroem, analisam e mantêm esse software precisam da velocidade que o Python não pode dar. E o Rust, com sua segurança de memória, seu sistema de tipos e seu desempenho, acaba sendo o complemento perfeito.

É como se seu carro fosse fantástico mas os mecânicos da oficina usassem ferramentas de plástico. Um dia alguém lhes deu ferramentas de aço inoxidável, e acontece que o carro continua funcionando igual mas a oficina funciona dez vezes mais rápido.

O plot twist: OpenAI entra em cena

Se você pensava que a história não podia ficar mais interessante: em 19 de março de 2026 — há uma semana — OpenAI anunciou a aquisição da Astral. A empresa por trás do uv, Ruff e ty passa a fazer parte da equipe do Codex.

A Astral prometeu manter as ferramentas open source. Mas o movimento diz muito: a OpenAI não comprou a Astral pelo linter. Comprou uma equipe que sabe construir ferramentas de desenvolvimento extremamente rápidas em Rust. E as quer para fazer os agentes de IA escreverem e gerenciarem código melhor.

A convergência é clara. As ferramentas que os humanos usam para desenvolver em Python (uv, Ruff, ty) e as ferramentas que os agentes de IA usam para escrever código (Codex) vão compartilhar DNA. E esse DNA está escrito em Rust.

O que eu faço na segunda-feira?

Se você ainda não usa o uv, a migração é trivial:

# Instalar uv
curl -LsSf https://astral.sh/uv/install.sh | sh

# Migrar um projeto existente
cd meu-projeto
uv init                     # cria pyproject.toml se não existir
uv add requests flask       # adiciona dependências
uv sync                     # instala tudo no .venv
uv run python app.py        # executa dentro do ambiente

Se você usa Flake8, Black ou isort, substitua pelo Ruff:

uv tool install ruff
ruff check .               # linter
ruff format .              # formatador

E se você é corajoso, teste o ty para verificação de tipos:

uv tool install ty
ty check .

Três comandos. Três ferramentas. Tchau para o pesadelo de oito configurações diferentes.

No final, o culto estava certo

Há anos ouço “você deveria reescrever isso em Rust” como quem ouve chover. O meme RIIR (Rewrite It In Rust) parecia o mantra de uma seita de evangelistas com camisetas de caranguejos. Deixa para lá, pensava eu, que uma hora eles se cansam.

Não se cansaram. E acontece que eles tinham razão.

Nem tudo deve ser reescrito em Rust. Mas ferramentas de desenvolvimento — linters, type checkers, gerenciadores de pacotes, utilitários de terminal — são exatamente o tipo de software onde o Rust brilha: desempenho crítico, execução frequente, zero tolerância a falhas. E os resultados falam por si.

Python continua sendo minha linguagem para escrever software. Mas as ferramentas com que escrevo esse software, cada vez mais, estão escritas em Rust. E funcionam melhor que tudo que o Python construiu para si mesmo em duas décadas.

Ferris, o caranguejo, te pede desculpas pelo borrow checker. Mas em troca te dá um pip install que demora 300 milissegundos e funciona. Eu diria que é um acordo justo.