# uv: The Fast Rust Python Package Manager Replacing pip

> Why I moved my Python projects to uv — the Rust-based package and project manager from Astral that is 10-100x faster than pip and folds pip, venv, pipx, poetry, and pyenv into one binary.

URL: https://www.matthewswong.com/en/blog/uv-python-package-manager-rust/

- Author: Matthews Wong (https://www.matthewswong.com/en/about/)
- Published: 2026-07-31
- Updated: 2026-07-31
- Category: DevOps

> **Key takeaway:** uv is an extremely fast Python package and project manager written in Rust by Astral, the makers of Ruff. It is 10 to 100 times faster than pip and replaces pip, pip-tools, virtualenv, pipx, poetry, and pyenv with one static binary that handles dependencies, lockfiles, virtual environments, Python versions, and command-line tools.

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.

## 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.

> Start with uv pip and uv venv on an existing project before committing to full project management. It is a zero-risk swap: the requirements files, the resolution result, and the virtual environment layout are all compatible, so you get the speed win immediately and can decide about pyproject.toml later.

## 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.

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.

## 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 is young and moving fast, and it is not a formal PSF standard. Pin the uv version in CI so a background upgrade cannot change your resolution, commit uv.lock, and confirm any private index, custom build backend, or plugin your team relies on is supported before you delete poetry from every repo.

## uv versus pip and poetry

| Concern | pip plus venv | Poetry | uv |
| --- | --- | --- | --- |
| Written in | Python | Python | Rust |
| Relative install speed | Baseline | Similar to pip | 10 to 100x faster |
| Scope | Install only | Project plus deps | Install, project, Python, tools |
| Lockfile | None built in | poetry.lock | uv.lock, cross-platform |
| Python version management | No — needs pyenv | No — needs pyenv | Built in |

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.

## Sources

- uv — official documentation (docs.astral.sh)
- Astral — uv launch announcement, February 2024
- Astral — uv unified Python packaging, August 2024
- astral-sh/uv — source and README on GitHub

## Source links

- https://docs.astral.sh/uv/
- https://astral.sh/blog/uv
- https://astral.sh/blog/uv-unified-python-packaging
- https://github.com/astral-sh/uv

## FAQ

### What is uv in Python?

uv is an extremely fast Python package and project manager written in Rust by Astral, the team behind the Ruff linter. It ships as a single static binary and consolidates the jobs of pip, pip-tools, virtualenv, pipx, poetry, and pyenv into one tool for installing packages, managing projects and lockfiles, and handling Python versions.

### How much faster is uv than pip?

Astral's benchmarks report uv is 8 to 10 times faster than pip without a cache and 80 to 115 times faster with a warm cache when recreating an environment. The docs summarize this as 10 to 100 times faster overall. The speed comes from parallel downloads, a Rust resolver, and an aggressive shared cache across projects.

### Can uv replace poetry and pyenv?

Yes. Since August 2024 uv offers full project management with pyproject.toml and a cross-platform uv.lock via uv init, add, lock, sync, and run, covering poetry's role. It also installs and pins interpreters with uv python install and uv python pin, which replaces pyenv. Verify your private indexes and build backends are supported before fully migrating.

### Is uv a drop-in replacement for pip?

Largely, yes, through its pip interface. Commands like uv pip install, uv pip compile, uv pip sync, and uv venv mirror pip and pip-tools with the same flags and are compatible with existing requirements files. You get the speed win immediately on an existing project without adopting uv's project management or pyproject.toml workflow.

### Who makes uv and is it free to use?

uv is built by Astral, the company that also makes the Ruff linter, and was first released in February 2024. It is open source and dual-licensed under Apache 2.0 or MIT on GitHub at astral-sh/uv, so it is free to use in commercial and personal projects. It is written in Rust and distributed as a standalone binary.

---

- HTML version: https://www.matthewswong.com/en/blog/uv-python-package-manager-rust/
- Bahasa Indonesia: https://www.matthewswong.com/id/blog/uv-python-package-manager-rust/
- Site index for agents: https://www.matthewswong.com/llms.txt
- Sitemap: https://www.matthewswong.com/sitemap.xml
- API description (OpenAPI): https://www.matthewswong.com/openapi.json