uv, um gerenciador muito rápido de pacotes e projetos Python escrito em Rust

• uv é uma ferramenta extremamente rápida, baseada em Rust, para gerenciamento de pacotes e projetos Python
• Pode substituir em um só lugar pip, pip-tools, pipx, poetry, pyenv, virtualenv e outros
• Oferece desempenho até 10 a 100 vezes mais rápido, economia de espaço em disco, cache robusto e suporte cross-platform
• Inclui suporte a um ambiente de desenvolvimento integrado para scripts, projetos, ferramentas e múltiplas versões do Python
• Torna possível um fluxo de trabalho moderno de desenvolvimento Python, otimizado para produtividade, projetos de grande porte e alta velocidade de execução

---

Introdução ao open source e pontos de diferenciação

• O uv integra em uma única ferramenta os recursos de vários utilitários de gerenciamento Python existentes, como pip, pip-tools, pipx, poetry, pyenv, virtualenv e twine
• Por ter sido desenvolvido em Rust, oferece desempenho excelente e se destaca por velocidades de instalação e sincronização 10 a 100 vezes mais rápidas em comparação ao pip tradicional
• Fornece otimização do uso de disco com cache global e eliminação de duplicação de dependências, além de oferecer uma CLI intuitiva e compatibilidade familiar com o pip
• Pode ser instalado como executável independente em várias plataformas, como macOS, Linux e Windows
• Destaca-se pela praticidade, com instalação autônoma, integração com pip e pipx, e suporte a atualização automática própria

Principais características (Highlights)

• Com uma única ferramenta, o uv pode substituir diversos recursos de pip, pip-tools, pipx, poetry, pyenv, twine e virtualenv
• Oferece desempenho de instalação/atualização/sincronização 10 a 100 vezes mais rápido que o pip tradicional
• Suporte a gerenciamento de dependências de projeto com base em lockfile, além de workspaces e universal lockfile
• Suporte a declaração inline de dependências em scripts e execução com isolamento automático de ambiente
• Suporte a gerenciamento/instalação/troca de diferentes versões do Python
• Suporte à execução e instalação de ferramentas distribuídas como pacotes Python (substituindo o pipx)
• Compatibilidade com a interface do pip e recursos extras, como sobrescrita de versão e resolução independente de plataforma
• Workspace no estilo Cargo, ideal para projetos de grande porte
• Cache global para minimizar duplicação de dependências e melhorar a eficiência no uso de espaço em disco
• Pode ser instalado e usado com curl, pip ou pipx, mesmo sem ambiente Rust/Python configurado
• Suporte multiplataforma para macOS, Linux e Windows
• Criado pela equipe por trás do Astral e do Ruff

Gerenciamento de projetos (Project Management)

• Suporte completo, no nível de projeto, a dependências, ambiente, arquivo de lock e workspace
• Inicialização automática do projeto e criação de virtualenv com o comando uv init
• Adição de dependências com uv add, e sincronização de pacotes e auditoria de segurança automatizadas com os comandos uv lock e uv sync
• Substitui recursos de ferramentas modernas de gerenciamento de projetos Python, como Poetry e Rye, garantindo processamento mais rápido
• Também oferece suporte a build e publish de projetos que não são gerenciados pelo uv

Gerenciamento de scripts (Scripts)

• Permite declarar metadados inline de dependências em scripts de arquivo único
• Suporte a isolamento automático de ambiente virtual e instalação de dependências na execução do script
• Com uv add --script, é possível gerenciar dependências por script, e com uv run, executar com isolamento de ambiente
• Ideal para uso em scripts pontuais, como os de ciência de dados e automação

Gerenciamento de ferramentas (Tools)

• Permite instalar e executar ferramentas CLI distribuídas como pacotes Python, de forma semelhante ao pipx
• Com os comandos uv tool install e uvx, é possível usar ambientes temporários ou execução global
• Suporte à verificação das ferramentas instaladas, gerenciamento de versões e atualizações

Gerenciamento de versões do Python

• Permite instalar facilmente e alternar imediatamente entre várias versões do Python
• Permite gerenciar diferentes versões em paralelo e definir pin por projeto com .python-version
• Também oferece a mesma interface para implementações alternativas, como pypy
• Instalação, definição e ativação de versões com comandos como uv python install/pin

Interface pip (Pip Interface)

• Com uv pip e uv venv, substitui completamente o pip, pip-tools e virtualenv existentes
• Inclui recursos avançados como override de versão de dependência, resolução independente de plataforma e builds reproduzíveis
• Funciona como substituto drop-in do pip sem alterar o fluxo de trabalho existente, oferecendo ganho de desempenho de 10 a 100 vezes
• Suporte à conversão de requirements.in → requirements.txt, criação de ambiente virtual e sincronização de requirements

Plataforma e política de versões

• Suporte a vários sistemas operacionais (Windows, macOS e Linux)
• Informações sobre política e plataformas suportadas podem ser consultadas na documentação oficial

Contribuição (Contributing)

• O objetivo é apoiar contribuidores de diferentes níveis, de iniciantes a especialistas, com guias relacionados

FAQ

• A pronúncia de uv é “iu-ví”
• O estilo é fixado em minúsculas: “uv”

Contexto técnico e agradecimentos (Acknowledgements)

• O algoritmo de resolução de dependências usa PubGrub
• A implementação de Git é baseada em Cargo
• A estratégia de otimização foi fortemente inspirada por ferramentas modernas de empacotamento como pnpm, Orogene, Bun e Posy

Licença

• Pode ser usado sob MIT ou Apache-2.0, à escolha do usuário
• O código contribuído também é duplamente licenciado sob as mesmas condições

[GN⁺]

Comentários no Hacker News

• Até alguns meses atrás eu achava que jamais usaria o uv, porque já estava acostumado com venv e pip e não via necessidade de outra ferramenta, mas recentemente, em um servidor compartilhado sem acesso root, vários pacotes e drivers estavam todos quebrados e eu precisava de PyTorch; depois dessa experiência, migrei completamente para o uv. O pip demorava muito, o cache ocupava espaço demais e era difícil mudar seu local; com o uv, tudo simplesmente funcionou bem. Se você ainda está em dúvida, recomendo fortemente testar por pelo menos 5 minutos.

  • A maior vantagem do uv é ser totalmente compatível com o workflow baseado em venv que eu já usava; basta rodar uv venv.
  • O uv parece muito mais fácil de explicar e especialmente de ensinar para iniciantes. A combinação pip + arquivo de configuração + venv era confusa, porque exigia lembrar de criar e usar o venv correto, além de lidar com shebangs estranhos ou ativação do ambiente a cada execução de script/teste, e as mensagens de erro nem sempre ajudavam de verdade. Ao ensinar iniciantes, essas ferramentas sempre pareciam bem incômodas; agora basta lembrar de uv run, uv add e uv sync, então a equipe também recebe isso com muito menos resistência.
  • No meu caso, usei asdf e depois migrei para mise; fiquei curioso sobre como ele se compara a ferramentas mais gerais como o uv.
  • Você comentou que o cache do pip ocupava muito espaço e que não dava para mudar seu local direito; fiquei curioso se o uv é melhor no uso de espaço de armazenamento e, se for, se isso acontece por compartilhar melhor os artefatos.
  • Recentemente vi um guia simples que começava com uv a b c em um repositório experimental e resolvi testar. Internamente parece haver bastante duplicação, mas no uso real, em um host GNU-Debian-Ubuntu padrão, não tive problema algum e tudo funcionou sem atritos.

• Quando usei o uv pela primeira vez, ele terminou tão rápido em comparação com o pip que achei que eu tinha feito algo errado ou que não tinha funcionado direito.

  • Às vezes a instalação de um pacote leva uns 200 ms, então dá para perceber um pequeno atraso entre apertar Enter e o prompt reaparecer. Já no Poetry dá tempo de ir buscar um café, então a diferença de velocidade é gritante.
  • Tive exatamente a mesma sensação. É tão fluido que nem parece Python.
  • Passei por algo parecido recentemente e isso me fez migrar de vez para o uv.
  • Eu também desconfiei, mas depois de experimentar, fiquei satisfeito a ponto de não conseguir mais voltar.

• Acho que uv e Ruff são ótimos contraexemplos ao ditado “nunca reinvente a roda”; quando o objetivo é claro, às vezes o resultado fica muito melhor que o existente.

  • Na maior parte das vezes, esse conselho faz sentido no contexto de iniciantes que não conhecem bem o que já existe. Ou seja, ele só vale quando alguém tenta reinventar algo sem entender as limitações e oportunidades de melhoria do sistema atual. Para especialistas de verdade, isso não se aplica.
  • A metáfora aqui não é que eles reinventaram a roda, mas que trocaram a velha roda de madeira por uma de material mais resistente que gira 10 vezes mais rápido.
  • Basta olhar a história do gerenciamento de pacotes em Python para ter a impressão de que todo mundo entra no jogo achando que consegue fazer melhor que o anterior.
  • Na verdade, o próprio ditado “não reinventar a roda” não faz muito sentido. Nós continuamos evoluindo as rodas reais, então não há motivo para não criar rodas melhores em software também.
  • Fugindo um pouco do tema: fico curioso por que as pessoas preferem a expressão longa “order of magnitude better” em vez do simples 10x.

• Em sistemas pequenos/de baixa potência (como um AWS T2.micro rodando Windows), o uv tenta fazer downloads simultâneos demais e isso causa timeout. Limitar a concorrência com a variável de ambiente UV_CONCURRENT_DOWNLOADS para algo como 1 ou 2 resolve. Acho a configuração padrão do uv agressiva demais e seria bom se ele melhorasse isso, talvez ajustando automaticamente por servidor com base na velocidade de download.

  • Isso não é um caso estranho de forma alguma; muita gente toca side projects em VPS baratos (eu mesmo faço isso com frequência, embora não na AWS). Obrigado por compartilhar, e tomara que a detecção automática melhore.

• Tenho testado o uv recentemente no meu notebook para uso pessoal e, para alguém acostumado com pip, a velocidade percebida é tão absurda que em várias ocasiões fiquei em dúvida se ele realmente tinha executado.

• Gosto muito de uv add <mydependencies> --script mycoolscript.py, e se você colocar #!/usr/bin/env -S uv run no topo, dá para executar scripts Python imediatamente, o que tem sido extremamente útil.

  • Ensinei esse padrão ao Claude Project com um prompt especializado, então ele consegue gerar automaticamente um script completo com dependências a partir de uma única entrada. O cutoff do Claude 4 é março de 2025; no Claude Sonnet 4 isso já funciona mesmo sem prompt adicional. Por exemplo, se você fornecer uma URL, ele gera na hora um código que faz scraping com httpx e beautifulsoup e devolve uma lista de links em CSV. material relacionado resultado do script no Claude
  • Uso esse truque junto com o app-mode do notebook Marimo.io. Se a pessoa tiver apenas o uv instalado, fica muito fácil compartilhar apps reativos e reproduzíveis quase instantaneamente e com preparação mínima. É uma combinação excelente.
  • Agora peguei o hábito de executar pequenos scripts de improviso o tempo todo. Como não preciso mais me preocupar com ambiente ou gerenciamento de dependências, tudo ficou muito mais confortável. artigo sobre the little scripter, vídeo relacionado no YouTube, ez-mcp no GitHub
  • Correção: eu tinha lido o exemplo errado. No contexto de projeto, uv add --script e apenas uv add são coisas diferentes. Também vale olhar a documentação oficial, porque há mais recursos úteis, como run --with e suporte a PEP723. guia oficial
  • O que exatamente seria mydependencies? É algo como um arquivo de configuração?

• Testei o uv no passado e me surpreendi por ele ser absurdamente rápido e fácil de usar. Hoje quase não vejo motivo para usar pip, e se você só usa Python, nem conda parece mais necessário.

  • Também parei de usar pyenv e poetry.

• Gosto muito do uv. Também gosto do Ruff, da equipe da Astral, então migrei todo o linting/formatação de pylint + Black para Ruff. Vi o tempo de lint cair de 90 segundos para menos de 1,5 segundo, fiquei impressionado.

  • Mas depois descobri, com certa decepção, que o Ruff só cobre parte das verificações do pylint e também deixa passar erros óbvios demais sem detectar nada (como código que nem executa).

• Recentemente passei a gostar muito de usar o padrão abaixo para pequenos scripts executáveis:

  #!/usr/bin/env -S uv --quiet run --script
  # /// script
  # requires-python = ">=3.13"
  # dependencies = [
  #   "python-dateutil",
  # ]
  # ///
  #
  # [python script that needs dateutil]  
  

  • A linha de shebang é difícil demais de decorar; seria ótimo se houvesse uma forma mais simples, tipo #!/usr/bin/env uvx. Toda vez que vou usar, preciso pesquisar de novo.

• Estou completamente satisfeito e não quero voltar para pip/twine/requirements.txt. Vários projetos mantinham wheels compartilhados em um GitLab interno, e o antigo YAML de 10 linhas pôde ser substituído por duas linhas: uv build e uv publish. Ficou fácil importar dependências e ver as principais dependências de uma vez, sem aquela bagunça de misturar tudo em um requirements.txt.