uv (Python package manager)

Overview

uv is a command-line tool developed by Astral for managing Python packages and environments. Released in 2024, it is engineered in Rust to deliver performance advantages over traditional Python package managers like pip. The primary goal of uv is to provide a fast, reliable, and user-friendly experience for common package management tasks, including package installation, dependency resolution, and virtual environment creation.

It is designed to function as a drop-in replacement for pip and pip-tools, supporting existing workflows that rely on requirements.txt files and pyproject.toml for dependency specification. This compatibility allows developers to integrate uv into existing Python projects without extensive configuration changes. Its performance benefits are particularly noticeable in scenarios involving large dependency graphs or frequent environment setups, such as in continuous integration/continuous deployment (CI/CD) pipelines where build times are critical.

uv addresses several challenges often encountered with Python package management, including slow dependency resolution times and inconsistent environment states. By leveraging Rust's performance characteristics, uv aims to reduce the overhead associated with these operations. This makes it an option for developers and organizations seeking to optimize their Python development workflows, improve build times, and ensure reproducible environments across different development and production stages. It supports various Python versions and platforms, aiming for broad applicability within the Python ecosystem.

In addition to its speed, uv focuses on providing clear and concise output, making it easier for users to understand the state of their environments and troubleshoot issues. It supports both direct package installation and the creation of locked dependency files, similar to how pip-tools operates. This dual capability allows for flexible dependency management strategies, from simple installations to strict dependency locking for production deployments. The project maintains an open-source model, allowing community contributions and transparent development.

Key features

• Fast Dependency Resolution and Installation: Engineered in Rust, uv performs dependency resolution and package installation at speeds faster than traditional Python-based tools. This acceleration is particularly beneficial for projects with many dependencies or in CI/CD environments where build times are critical.
• pip and pip-tools Compatibility: uv is designed to be a drop-in replacement, supporting common commands and workflows associated with pip and pip-tools. It can process requirements.txt files and pyproject.toml (PEP 508 and PEP 621) for dependency management, minimizing the learning curve for existing Python developers.uv's pip and pip-tools compatibility documentation.
• Virtual Environment Management: uv can create and manage virtual environments, isolating project dependencies from the system-wide Python installation. This feature helps maintain clean and reproducible development environments.
• Dependency Locking: Similar to pip-tools, uv can generate and use lock files to pin exact versions of all transitive dependencies. This ensures that installations are reproducible across different machines and deployments, reducing potential environment inconsistencies.
• Cross-Platform Support: uv is built to operate across various operating systems, including Linux, macOS, and Windows, providing a consistent package management experience regardless of the development environment.
• Clear Output and Error Reporting: The tool prioritizes user experience with clear, concise output during operations and informative error messages to assist in troubleshooting dependency conflicts or installation issues.
• Offline Mode: uv supports an offline mode, allowing installations from a local cache without requiring an internet connection once packages have been downloaded. This can be useful in restricted network environments or for faster repeated installations.

Pricing

As of June 2026, uv is an open-source project released under the MIT License, making it free to use for both personal and commercial projects. There are no licensing fees or subscription costs associated with its use.

For detailed licensing information, refer to the uv project's license on GitHub.

Common integrations

• requirements.txt files: uv fully supports installing and managing dependencies defined in requirements.txt, making it compatible with existing Python projects. Managing requirements.txt with uv.
• pyproject.toml: It can read and interpret project metadata and dependencies specified in pyproject.toml files, adhering to PEP 621 standards. Using pyproject.toml with uv.
• Virtual Environments: uv integrates directly with Python's virtual environment concept, allowing creation and management of isolated project environments. uv virtual environment guide.
• CI/CD Pipelines: Due to its speed, uv is suitable for integration into CI/CD workflows, reducing build times for Python projects. It can be used in GitHub Actions, GitLab CI, Jenkins, and other platforms. Integrating uv into CI/CD.

Alternatives

• pip: The standard package installer for Python, widely used but generally slower for dependency resolution and installation compared to uv.
• Poetry: A comprehensive dependency management and packaging tool for Python that also handles virtual environments, publishing, and project structure.
• Rye: A portable Python development environment installer and package manager, also written in Rust, that aims to unify common Python tooling.

Getting started

To get started with uv, you can install it using pipx (recommended for global CLI tools) or directly via pip. Once installed, you can create a virtual environment and install packages.

First, ensure you have pipx installed:

python3 -m pip install --user pipx
python3 -m pipx ensurepath

Then, install uv:

pipx install uv

Alternatively, if you prefer not to use pipx:

pip install uv

Now, let's create a new project directory, set up a virtual environment, and install some packages:

# Create a project directory
mkdir my_uv_project
cd my_uv_project

# Create a virtual environment with uv
uv venv

# Activate the virtual environment
source .venv/bin/activate  # On Windows, use .venv\Scripts\activate

# Install packages (e.g., requests and rich)
uv pip install requests rich

# Verify installed packages
uv pip list

# Deactivate the virtual environment
deactivate

For projects with a requirements.txt file:

# Assuming you have a requirements.txt in your project directory
# e.g., requirements.txt containing:
# requests==2.31.0
# rich==13.7.1

uv venv
source .venv/bin/activate
uv pip install -r requirements.txt
uv pip list
deactivate

This sequence demonstrates creating an isolated environment, installing specified dependencies, and verifying the installation, showcasing uv's core functionality for managing Python project dependencies.