uv: The Fast Rust Python Package Manager Replacing pip

Python packaging has spent a decade fragmenting into a shelf of single-purpose tools. You reach for pyenv to get the right interpreter, venv or virtualenv to isolate it, pip to install into it, pip-tools to pin a lockfile, pipx to run standalone CLIs, and poetry or hatch to manage the project itself. Each has its own config, its own cache, and its own way of being slow. I have onboarded engineers who spent a full afternoon just assembling this stack before writing a line of code.

uv collapses that whole shelf into a single binary. Astral, the team behind the Ruff linter, released it in February 2024 and it spread through the Python world faster than any tool I can remember. It is written in Rust, ships as one static executable with no Python of its own required, and is fast enough that the speed changes how you work rather than just shaving a few seconds off a build.

What uv is and how to install it

uv is a drop-in that you can adopt gradually. The install is a single script or a one-line package install, and it needs nothing else on the machine to function. On my laptops and in CI I use the standalone installer because it does not depend on an existing Python, which matters when uv is the thing that installs Python for you.

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

# Install uv on Windows (PowerShell)
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

# Or install it with pipx / pip
pipx install uv
pip install uv

# Keep it current
uv self update

The drop-in pip interface

The lowest-friction way to try uv is the pip interface. Every command you already know gets a uv prefix and the same flags: uv pip install, uv pip compile, uv pip sync, and uv venv. You keep your requirements files and your workflow, but resolution and installation run 10 to 100 times faster because uv parallelizes downloads and caches aggressively across projects. Astral measured 8 to 10 times faster than pip without a cache, and 80 to 115 times faster with a warm cache when recreating an environment.

# Drop-in pip interface — same flags, 10-100x faster
uv venv                                  # create .venv in milliseconds
uv pip install "fastapi[standard]"
uv pip install -r requirements.txt

# pip-tools style compile + sync, now built in
uv pip compile requirements.in -o requirements.txt
uv pip sync requirements.txt

Full project management with pyproject.toml

In August 2024 Astral shipped the second half of uv: end-to-end project management that competes directly with poetry. uv init scaffolds a project with a standards-based pyproject.toml. uv add and uv remove edit that file and update a universal, cross-platform uv.lock in one step. uv sync makes the environment match the lockfile exactly, and uv run executes commands inside that environment without you ever activating it manually.

# Start a managed project (writes pyproject.toml)
uv init myapp
cd myapp

# Add / remove deps — updates pyproject.toml AND uv.lock
uv add fastapi
uv add --dev pytest ruff
uv remove requests

# Resolve the lockfile, then materialize the environment
uv lock
uv sync

# Run code in the project env — no "activate" needed
uv run python main.py
uv run pytest

The lockfile is the part I care about most on a team. uv.lock is resolved to be cross-platform, so the same lockfile produces the same dependency set on Linux CI, a Mac, and a Windows box. Astral frames the whole thing as Cargo for Python, and the comparison holds: in their benchmark uv resolved the Transformers project in 7.48 seconds cold versus poetry's 47.91 seconds, and 0.14 seconds warm versus poetry's 4.32 seconds.

Python versions and tools, no pyenv or pipx needed

uv also manages the interpreter itself. uv python install downloads and manages standalone Python builds, and uv python pin writes a version file so the project always uses the interpreter you chose. For command-line tools there is uvx, a shorthand for uv tool run that executes a tool in a throwaway environment the way pipx or npx does, plus uv tool install to put one on your PATH permanently. That is pyenv and pipx retired in two subcommands.

# Install and pin Python versions — no pyenv required
uv python install 3.11 3.12 3.13
uv python pin 3.12

# Run CLI tools in throwaway envs (like pipx / npx)
uvx ruff check .

# Install a tool onto your PATH for good
uv tool install ruff

One tool instead of six

The real payoff is consolidation. A single binary, a single cache, and a single mental model replace a stack that used to need constant maintenance. Concretely, uv subsumes:

• pip and pip-tools — installing packages and compiling pinned requirements, via uv pip install and uv pip compile.
• virtualenv and venv — creating isolated environments with uv venv, roughly 80 times faster than python -m venv.
• pyenv — downloading and switching Python versions with uv python install and uv python pin.
• pipx and poetry — running throwaway CLI tools with uvx and managing projects with uv init, add, lock, sync, and run.

uv versus pip and poetry

I now start every new Python project with uv init and reach for uv pip on the legacy ones I have not migrated yet. The safe path is incremental: adopt the pip interface for the speed today, move to pyproject.toml and uv.lock when you want reproducible project management, and let uv take over Python versions and tooling last. Each step stands on its own, and none of them lock you in.