uv (Python package manager)

Overview

uv is a modern Python package installer and dependency resolver, developed by Astral and released in 2024. It is engineered in Rust to deliver performance improvements over traditional Python package management tools like pip and pip-tools. The primary goal of uv is to provide a comprehensive, high-speed solution for managing Python project dependencies, encompassing tasks from initial project setup to deployment.

Developers who prioritize speed and efficiency in their Python workflows are the target audience for uv. It is particularly well-suited for environments where rapid dependency installation and resolution are critical, such as CI/CD pipelines, container build processes, and local development loops. uv aims to act as a direct replacement for many common pip and pip-tools commands, allowing users to transition without significant changes to their existing scripts or muscle memory. For instance, commands like pip install become uv pip install, and pip-sync functionality is integrated into uv sync.

The architecture of uv leverages Rust's performance characteristics, including its memory safety and concurrency features, to process large dependency graphs and install packages with reduced execution times. This efficiency is critical for projects with numerous dependencies or complex version constraints, where traditional tools might incur significant delays. uv also focuses on correctness in dependency resolution, aiming to prevent common issues like dependency conflicts and ensuring reproducible builds by adhering strictly to PEP 517 and PEP 660 standards for package builds and editable installs, respectively. The tool supports both wheel and source distributions, managing Python environments via virtual environments.

Furthermore, uv offers integrated support for managing Python virtual environments, including creation, activation, and removal, similar to venv. This streamlines the setup process for new projects and ensures isolated environments for dependencies. Its design considerations extend to providing clear and actionable error messages, helping developers diagnose and resolve dependency-related problems more efficiently. By combining speed, correctness, and a familiar command-line interface, uv seeks to establish itself as a foundational tool for contemporary Python development practices. The project's development is active, with continuous improvements and feature additions planned to cover more advanced package management scenarios.

Key features

• High-Speed Package Installation: Utilizes Rust's performance capabilities to significantly reduce the time required for package downloads and installation compared to pip.
• Fast Dependency Resolution: Employs a highly optimized dependency resolver that can process complex dependency graphs and identify compatible package versions rapidly.
• pip and pip-tools Compatibility: Designed as a drop-in replacement, supporting many familiar commands and workflows from both pip and pip-tools, facilitating an easier transition for existing projects. For example, uv pip install mirrors pip install behavior, and uv sync handles tasks similar to pip-sync in pip-tools for exact dependency synchronization.
• Integrated Virtual Environment Management: Provides built-in commands for creating, activating, and managing Python virtual environments, simplifying project setup and isolation, as described in the official uv documentation on environments.
• PEP Adherence: Complies with Python Enhancement Proposals (PEPs) such as PEP 517 for build system integration and PEP 660 for editable installs, ensuring broad compatibility with the Python packaging ecosystem.
• Offline Mode Support: Capable of operating in an offline mode once packages are cached, which is beneficial for environments with restricted internet access or for improving build times in CI/CD by avoiding redundant downloads.
• Cross-Platform Support: Operates consistently across various operating systems, including Linux, macOS, and Windows, offering a unified experience for development teams.
• Reproducible Environments: Supports pinning exact versions of dependencies, often through requirements.txt or pyproject.toml files, to ensure consistent and reproducible builds across different machines and deployments.

Pricing

As of April 30, 2026, uv is entirely free and open-source.

For more details on its open-source status, refer to the uv frequently asked questions.

Common integrations

• Python Virtual Environments: uv directly manages Python virtual environments, serving as a replacement for venv for creating and activating isolated project environments. Learn more about uv's environment management commands.
• pyproject.toml: Integrates with pyproject.toml for project configuration and dependency specification, aligning with modern Python packaging standards. The uv reference documentation on pyproject.toml provides additional context.
• requirements.txt: Supports standard requirements.txt files for specifying exact dependency versions, making it compatible with existing Python projects. See how to install from requirements.txt with uv.
• Continuous Integration (CI) Systems: Due to its speed, uv is suitable for integrating into CI/CD pipelines (e.g., GitHub Actions, GitLab CI) to accelerate build and test processes that involve Python dependency installation.
• Docker: Can be used within Dockerfiles to build Python application images efficiently, reducing image build times by optimizing dependency installation steps.

Alternatives

• pip: The standard package installer for Python, widely used for installing packages from PyPI.
• Poetry: A comprehensive dependency manager and packager for Python, focused on reproducible dependency management and project publishing.
• Rye: A minimalist Python toolchain installer and package manager, also based on Rust, offering similar aims of speed and environment management.
• venv: Python's built-in module for creating lightweight virtual environments, often used in conjunction with pip.
• pip-tools: A set of command-line tools that help manage pip dependencies, specifically for compiling and synchronizing exact dependency versions.

Getting started

To begin using uv, you can install it and then use it to create a new virtual environment, install packages, and manage dependencies. The following example demonstrates how to install uv, create a virtual environment, and install a common package like requests. This process replaces typical python -m venv .venv and pip install requests workflows with unified uv commands.

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

# Or, if you prefer a Python-based installation (requires pipx)
pipx install uv

# Create a new virtual environment named .venv in the current directory
uv venv

# Activate the virtual environment (syntax varies by shell)
# On Linux/macOS:
source .venv/bin/activate

# On Windows (PowerShell):
.venv\Scripts\Activate.ps1

# Install a package, e.g., requests
uv pip install requests

# Verify the installation
python -c "import requests; print(requests.__version__)"

# To exit the virtual environment
deactivate

This sequence demonstrates the core functionality of uv for environment and package management. The uv venv command initializes the virtual environment, and uv pip install handles package installation, mirroring standard package manager operations with improved performance. Further details on installation methods and system requirements can be found in the uv installation guide.