Les développeurs Python n'ont enfin plus besoin de choisir entre pip, poetry et pipenv. Créé par l'équipe Astral, aussi connue pour Ruff, uv est en train de transformer le paysage de la gestion de paquets Python à une vitesse impressionnante.

C'est quoi uv ?

uv est un outil de gestion de paquets et de projets Python écrit en Rust. Son objectif est unique : offrir une vitesse extrême.

Fonctionnalité Description
Installation de paquets Résolution de dépendances compatible pip
Gestion de projet Remplace poetry/pipenv, gère les environnements virtuels et les dépendances
Mécanisme de cache Cache global + liens physiques, installation répétée en quelques secondes
Multi-versions Python Installe et gère automatiquement plusieurs versions de Python
Flux de travail zéro config uv init + uv add et c'est parti
Licence MIT (entièrement open source)

L'équipe Astral a mis toute son expertise en outillage haute performance Rust dans uv. Le résultat est sans appel : 10 à 100 fois plus rapide que pip.

📦 GitHub : https://github.com/astral-sh/uv ⭐ Stars : 50k+ (mi-2026) 📄 Licence : MIT

Installer uv

L'installation d'uv est d'une simplicité remarquable, une seule ligne suffit :

BASH 
# Méthode recommandée par l'équipe — script d'installation
curl -LsSf https://astral.sh/uv/install.sh | sh

Vérifiez ensuite que tout fonctionne :

BASH 
uv --version
# uv 0.7.x

Sous Homebrew (macOS/Linux) :

BASH 
brew install uv

Ou avec pipx :

BASH 
pipx install uv

Prise en main rapide : votre premier projet

Initialiser un projet

BASH 
# Créer un nouveau projet (génère automatiquement pyproject.toml + environnement virtuel)
uv init my-app
cd my-app

Voici la structure de fichiers générée :

my-app/
├── .python-version    # Version Python verrouillée
├── pyproject.toml     # Configuration du projet
├── README.md
├── main.py
└── uv.lock            # Fichier de verrouillage des dépendances

Le contenu de pyproject.toml est d'une propreté exemplaire :

TOML 
[project]
name = "my-app"
version = "0.1.0"
description = "Add your description here"
requires-python = ">=3.12"
dependencies = []

Ajouter des dépendances

BASH 
# Ajouter des dépendances de production (résolution + installation + verrouillage automatiques)
uv add requests
uv add fastapi
uv add "pydantic>=2.0"

# Ajouter des dépendances de développement
uv add --dev pytest ruff mypy

Une seule commande pour tout faire : résolution des dépendances → téléchargement → installation → mise à jour de uv.lock. Le tout prend généralement quelques secondes seulement.

Exécuter du code

BASH 
# Exécuter un script dans l'environnement virtuel
uv run python main.py

# Exécuter des outils installés
uv run pytest
uv run ruff check .

uv run active automatiquement l'environnement virtuel du projet. Fini le source .venv/bin/activate manuel.

Fonctionnalités avancées

Gestion multi-versions Python

uv intègre un gestionnaire de versions Python qui télécharge et gère automatiquement plusieurs versions :

BASH 
# Voir les versions Python installées
uv python list

# Installer une version spécifique de Python
uv python install 3.13
uv python install 3.11

# Définir la version Python pour un projet
uv python pin 3.13

# Exécuter avec une version spécifique
uv run --python 3.11 python main.py

Ça résout un problème qui embête les développeurs Python depuis longtemps — pyenv n'est plus nécessaire.

Workspace (espace de travail)

Si votre projet comporte plusieurs paquets, la fonctionnalité workspace d'uv est parfaite :

BASH 
# Initialiser un workspace
uv init --package packages/core
uv init --package packages/cli

Dans pyproject.toml :

TOML 
[tool.uv.workspace]
members = ["packages/*"]

Gestion de scripts

uv permet de définir des alias de scripts directement dans pyproject.toml :

TOML 
[tool.uv.scripts]
dev = "uvicorn main:app --reload"
test = "pytest tests/"
lint = "ruff check . && mypy src/"

Puis les exécuter simplement :

BASH 
uv run dev
uv run test

Intégration CI/CD

Utilisation d'uv dans GitHub Actions :

YAML 
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install uv
        uses: astral-sh/setup-uv@v5
        with:
          enable-cache: true

      - name: Set up Python
        run: uv python install

      - name: Install dependencies
        run: uv sync --frozen

      - name: Run tests
        run: uv run pytest

enable-cache: true met en cache les téléchargements de paquets uv, ce qui accélère considérablement les builds en CI.

Comparaison de vitesse avec pip/poetry

Voici les résultats des benchmarks fournis par Astral (installation de Django et toutes ses dépendances) :

Outil Première installation Installation depuis le cache
pip ~15s ~3s
poetry ~20s ~5s
uv ~1.5s ~0.3s

Les raisons de cette vitesse :

  1. Implémentation Rust — le moteur de résolution de dépendances est écrit en Rust, plusieurs ordres de grandeur plus rapide que Python
  2. Cache global — les paquets sont mis en cache globalement et partagés entre projets via des liens physiques
  3. Téléchargements parallèles — téléchargement simultané de plusieurs paquets, exploitation maximale de la bande passante
  4. Cache intelligent — les résultats de résolution sont également mis en cache, ce qui évite les recalculs

Migrer depuis pip/poetry

Migrer depuis pip

BASH 
# Créer un projet à partir d'un requirements.txt existant
uv pip install -r requirements.txt

# Ou importer après avoir créé un nouveau projet
uv init
uv add -r requirements.txt

Migrer depuis poetry

BASH 
# Synchroniser les dépendances directement depuis pyproject.toml
uv sync

# Si vous avez besoin de reverrouiller
uv lock

uv est entièrement compatible avec le format pyproject.toml. La plupart des projets poetry peuvent basculer directement.

Récapitulatif des commandes utiles

BASH 
# Gestion de projet
uv init <name>           # Créer un nouveau projet
uv add <package>         # Ajouter une dépendance
uv remove <package>      # Supprimer une dépendance
uv sync                  # Synchroniser les dépendances (similaire à pip install -e .)
uv lock                  # Reverrouiller les dépendances

# Exécution
uv run <command>         # Exécuter une commande dans l'environnement virtuel
uv tool run <tool>       # Exécuter un outil temporaire (similaire à pipx run)
uv tool install <tool>   # Installer un outil global

# Gestion Python
uv python install <ver>  # Installer une version Python
uv python list           # Lister les versions installées
uv python pin <ver>      # Verrouiller la version Python du projet

# Cache
uv cache dir             # Afficher le répertoire de cache
uv cache clean           # Vider le cache

Conclusion

uv est en passe de devenir l'outil standard pour les développeurs Python. Créé par l'équipe Ruff, il est extrêmement rapide, son API est élégante, et il est entièrement open source.

Cas d'utilisation recommandés :

  • ✅ Nouveaux projets — lancez-vous directement avec uv init
  • ✅ CI/CD — le cache fonctionne parfaitement, les builds sont nettement plus rapides
  • ✅ Projets multi-versions Python — gestion de versions intégrée
  • ✅ Migration depuis poetry/pipenv — compatibilité pyproject.toml

Si vous utilisez encore pip + venv ou poetry, on vous recommande vivement d'essayer uv. Une fois que vous avez goûté aux installations en quelques secondes, impossible de revenir en arrière.

🔗 Documentation officielle : https://docs.astral.sh/uv/ 🔗 GitHub : https://github.com/astral-sh/uv