JustAPI: Quando o Python Encontra o Rust no Coração do Servidor

Vou começar com uma pergunta que provavelmente já passou pela cabeça de qualquer desenvolvedor que já precisou otimizar uma API Python: por que o seu framework web gasta tanto tempo fazendo coisas que não têm nada a ver com o código que você escreve?

Vamos pensar nisso. O FastAPI fica em cima do Starlette, que fica em cima do Uvicorn, que envolve um loop de eventos asyncio que gerencia tudo entre o socket e o seu handler. A cada request—antes mesmo de chegar na sua lógica de negócio—múltiplas camadas de Python são atravessadas, serialização acontece em Python, e código Python executa da mesma forma para absolutamente todas as requisições.

E se isso mudasse? E se a parte do framework—aquela que faz trabalho idêntico independente da sua aplicação—vivesse inteiramente em Rust, e Python só executasse o código que é realmente único para o que você está construindo?

Essa é a premissa por trás do JustAPI, e depois de passar um tempo com o projeto, acho que vale a pena entender não só o que ele faz, mas por que as decisões de arquitetura importam para o seu próximo projeto.

Os Números de Performance Não São O Que Você Imagina

Antes de mergulhar na arquitetura, vamos falar de números—porque claims de performance sem contexto são marketing, não engenharia.

O projeto atingiu 766.000 requisições por segundo em um teste básico de hello-world. O roteador faz buscas em aproximadamente 51 nanossegundos com uma configuração de 500 rotas. O throughput async melhorou 14 vezes depois da migração para Tokio multi-threaded com suporte a CPython free-threaded.

Mas o que esses números realmente significam na prática? Se você está rodando uma API que processa milhares de requisições por segundo, esses ganhos se acumulam. Latência menor significa menos espera para seus usuários. Throughput maior significa que seus servidores lidam com mais carga. Mas a história real não são os números brutos—é o que você não precisa gerenciar.

Sem Uvicorn. Sem Gunicorn. Sem stack de middleware ASGI para debugar quando algo dá errado às três da manhã. O pipeline inteiro de requisições vive em Rust, e seu código Python é simplesmente... o seu código.

A Arquitetura: Python Como Exceção, Não Regra

O caminho de uma requisição no JustAPI é mais ou menos assim: Kernel (epoll/io_uring) → gerenciador de conexões do Tokio → TLS via rustls → parsing HTTP via Hyper → Router (radix trie do matchit) → cadeia de middleware (auth, CORS, rate-limiting) → fronteira Python via PyO3 → seu handler → serializador Rust → Response.

Perceba onde o Python entra: apenas no ponto onde sua lógica de aplicação começa. Tudo antes disso—tudo que executa identicamente para cada requisição—é Rust.

Essa é uma distinção importante. O desenvolvedor por trás do JustAPI impôs uma regra simples durante o desenvolvimento: se uma funcionalidade pode ser implementada em Rust, ela deve ser implementada em Rust. Não "pode ser mais rápido em Rust"—pode ser implementada em Rust. Python fica reservado para a cola entre valores Rust e seus handlers.

É uma restrição que moldou o projeto inteiro e resultou em algo genuinamente diferente de outros frameworks Python que simplesmente colaram peças de Rust por cima.

O Que Isso Significa Para a Experiência do Desenvolvedor

É aqui que acho que essa abordagem fica interessante para startups e equipes em crescimento.

Você ganha um framework de API completo—HTTP/1.1 e HTTP/2, TLS, roteamento com parâmetros, serialização JSON, documentação OpenAPI automática—com 30 linhas de código que parecem Python de verdade:

from justapi import JustAPIApp

app = JustAPIApp()

@app.get("/")
def hello():
    return {"Hello": "World"}

app.run()

Mas por trás dessa superfície familiar, você está rodando um servidor Rust que gerencia TLS, conexões e serializa respostas sem nunca cruzar para Python. A experiência de desenvolvimento permanece Pythônica. A performance em runtime é Rust.

Para equipes construindo MVPs que talvez precisem escalar depois, isso importa. Você escreve Python hoje. Você ganha performance Rust sem precisar reescrever nada quando precisar lidar com mais carga.

O Fator AI: Um Parceiro de Engenharia, Não Substituto

Esse projeto foi construído com AI agentic como participante ativo—não como autocomplete, mas como um guia de engenharia que ajudou a desenhar a arquitetura, converter decisões em código, encontrar bugs e escrever testes.

Isso merece ser discutido com honestidade, porque é cada vez mais comum e raramente falado de forma transparente.

O desenvolvedor descreve a base de código em três camadas: partes que ele entende completamente, partes que ele entende bem o suficiente para manter, e partes que a AI escreveu e ele revisou e testou mas não conseguiria reproduzir de memória. Ele é direto que essa é parte de como o projeto existe.

Acho que essa é a enquadramento certo. Ferramentas de AI estão acelerando o desenvolvimento em projetos complexos, e fingir o contrário não ajuda ninguém. A chave está em entender o que você possui versus o que delegou—e ser honesto sobre qual é qual.

O Ponto Prático

Frameworks como o JustAPI representam uma mudança em como estamos pensando sobre o papel do Python em sistemas de alta performance. Python não vai a lugar nenhum para lógica de aplicação—sua legibilidade e ecossistema são valiosos demais. Mas a suposição de que o framework em si precisa rodar em Python está sendo contestada.

Seja o JustAPI se torne o seu próximo framework ou permaneça como um experimento interessante, a percepção por trás dele tem valor: olhe para o que executa igual em toda requisição na sua stack. Isso provavelmente é território para Rust. As partes que mudam? Mantenha essas na linguagem onde sua equipe é mais produtiva.

O espaço entre "funciona" e "funciona bem" continua encolhendo. Seus usuários não vão notar a arquitetura, mas vão notar a latência.

Olhando Para Frente

O JustAPI está na versão 2.0.10 com funcionalidades documentadas incluindo WebSockets, SSE, tarefas em background, um scheduler, acesso a banco via SQLx, e ferramentas operacionais como OpenTelemetry e métricas Prometheus. Está disponível no PyPI com wheels para Linux padrão, macOS, Windows, e o build free-threaded do CPython 3.14t.

Os números estão no repositório. Os testes passam. As falhas são documentadas. Esse é o tipo de transparência de engenharia que deveríamos encouraging mais.

Se você está construindo APIs Python e performance importa para você, vale dar uma olhada. O futuro dos frameworks web Python talvez não pareça com o que você está usando hoje.