uv is an extremely fast Python package and project manager written in Rust by Astral — the same team behind Ruff — that consolidates pip, pip-tools, pipx, poetry, pyenv, twine, and virtualenv into a single binary running 10-100× faster than the tools it replaces. We rate it 94/100 — if you write Python in 2026, you should already be using uv, and if you aren't, you are paying a real CI tax for no good reason.

What is uv?

uv is an open-source Python package and project manager built in Rust on top of the same resolver internals that power pip-tools, but rewritten for speed and ergonomics. It was first announced by Astral founder Charlie Marsh on February 15, 2024 as a drop-in replacement for pip and pip-tools, then expanded across 2024 and 2025 into a full project manager that handles Python version installation, virtual environments, lockfiles, workspaces, and tool execution. The repository at github.com/astral-sh/uv has crossed 84,000 stars, the latest stable release is 0.11.8 shipped on April 27, 2026, and uv now serves hundreds of millions of downloads per month across PyPI, Homebrew, and Astral's own installer mirror.

The specific problem uv solves is the historical fragmentation of Python tooling: a typical project in 2023 needed pyenv to manage interpreters, virtualenv to create environments, pip to install packages, pip-tools to lock them, pipx to run CLI tools, twine to publish, and poetry or hatch sitting on top of all of it. uv ships every one of those concerns in a single 30MB binary, runs roughly 10× faster than pip on warm caches and 80-115× faster on cold installs, and uses globally deduplicated package storage that recovers gigabytes of disk space across projects. On March 19, 2026, OpenAI announced it was acquiring Astral as part of the Codex team — with Charlie Marsh and the rest of the Astral engineering team joining OpenAI while continuing to build uv, Ruff, and ty in the open.

uv warm-cache install benchmark showing roughly 115x speedup over pip — uv: warm-cache install benchmark from the official Astral repository — uv finishes a Trio dependency install in ~50ms versus pip's ~5.7s.

Key Features of uv

10-100× faster than pip: Astral's published benchmarks show uv resolving and installing the Trio test suite roughly 8-10× faster than pip on a cold cache and 80-115× faster with a warm cache. The 2026 reverseBits benchmark measured cold-resolve at 1.20s for uv versus 45.50s for pip and 38.20s for Poetry on the same hardware — a real impact on CI minutes that adds up across thousands of builds.
Single binary replaces seven tools: One uv command covers what pip, pip-tools, pipx, poetry, pyenv, twine, and virtualenv used to do. uv pip install, uv venv, uv tool run, uv python install 3.12, uv lock, uv publish — all from the same binary, all sharing the same global cache.
Manages Python itself: uv python install 3.12 downloads a portable interpreter from the python-build-standalone project and registers it — no system pyenv required and no compilation. Useful in CI containers where installing pyenv was always an extra step.
Cargo-style workspaces: Multi-package monorepos get first-class support with shared lockfiles, path dependencies, and a members field in pyproject.toml that mirrors how Rust's Cargo and JavaScript's pnpm workspaces operate.
Globally deduplicated cache: Packages are content-addressed and hard-linked from a global cache, which means installing NumPy in 50 projects costs roughly the same disk space as installing it once. uv cache prune reclaims unused entries on demand.
Drop-in pip compatibility: uv pip install -r requirements.txt works identically to pip, with the same flags and the same exit codes — you can swap uv into existing CI pipelines by changing one line.
Reproducible lockfiles: uv.lock is a cross-platform, deterministic lockfile that pins every transitive dependency by hash. Unlike Poetry, it is portable across operating systems and CPU architectures by default.
Active 2026 release cadence: uv 0.11.3 (April 1, 2026) added support for ROCm 7.2, free-threaded Python (PEP 703) error reporting, and a new uv audit command with --ignore-until-fixed for tracking known CVEs.

uv warm-cache dependency resolution benchmark vs pip-compile and Poetry — uv: warm-cache dependency resolution benchmark — uv re-resolves a 100-dependency graph in ~30ms versus pip-compile's ~3.5s.

What Users Say About uv

On Hacker News, the recurring sentiment is bluntly captured by an April 2026 "Why would anyone still use Poetry now that uv exists?" thread — the most-upvoted comment praises uv's speed and the elimination of dependency-management as its own specialization, while a recurring complaint is that the project's API surface is still moving fast and breaking changes between minor versions occasionally bite. On Reddit's r/Python, a Wagtail community post showing uv overtaking Poetry in download share went viral. The consistent praise across HN, Reddit, and the Real Python blog is the developer experience: it is fast enough that it removes a class of friction from Python development. The most common honest criticism is that some niche workflows — editable installs of packages with C++ build hooks, conda-only scientific stacks — still require dropping back to pip or pixi. Production users include Anthropic, Hugging Face, Replicate, Modal, Vercel, and the Python infrastructure teams at Bloomberg and Meta, alongside the FastAPI, Pydantic, and PyTorch projects' CI pipelines.

uv Pricing

uv is dual-licensed under the MIT and Apache 2.0 licenses and is free for commercial and personal use. There is no paid tier and no enterprise license — uv is purely open source.

Plan	Price	Key Limits
Open Source	$0	MIT/Apache-2.0 dual license — unlimited use, no telemetry, no signup required

Who Should Use uv?

Best for: Any team or individual writing modern Python, especially if you are using poetry, pip-tools, or rye today and tired of slow CI. Particularly compelling for monorepos with multiple Python packages, Docker builds where image-build time matters, and ML pipelines where waiting 5 minutes for pip install torch is killing your iteration loop.

Not ideal for: Workflows that require conda's binary distribution channel for scientific packages without PyPI wheels — uv does not replace conda — or projects deeply tied to setup.py-based editable installs with custom C++ hooks. Pixi or conda remain the right call for those niches.

Pros and Cons

Pros:

10-100× faster than pip on real benchmarks — not marketing copy, this is what HN and Reddit users measure in their own CI
Single binary replaces seven separate tools — massively reduces onboarding time for new contributors
Free and open source under MIT/Apache-2.0 — no commercial gotchas, runs offline, no telemetry
Cross-platform reproducible lockfiles work without per-OS gymnastics
Active development: a new minor release roughly every 2-3 weeks, with a public changelog
Now backed by OpenAI's Codex team after the March 2026 Astral acquisition — long-term maintenance is well-resourced

Cons:

Pre-1.0 versioning means occasional minor-version breaking changes — watch the changelog before upgrading in production
Doesn't replace conda for scientific stacks that need pre-built binary distributions outside PyPI
Editable installs of packages with custom build backends still occasionally require falling back to pip
Documentation is good but assumes familiarity with pip semantics — absolute Python beginners may find Poetry's tutorial gentler

Alternatives to uv

Poetry remains the default for many existing projects but is roughly 30× slower on resolve and lacks Python interpreter management. PDM is a feature-rich PEP-582 alternative with similar ergonomics but slower than uv. Pixi from Prefix.dev is the right call when you need conda-style scientific packages and is built on the same uv resolver internals. Plain pip + venv still works for simple scripts where pulling in a project manager is overkill.

Verdict: Is uv Worth It?

Yes — without qualification. uv is the rare tool where the speed improvement is so large it changes how you work: pre-commit hooks become free, Docker builds shrink by minutes, and CI pipelines that took 4 minutes finish in 30 seconds. The only legitimate reason not to adopt uv in 2026 is if your project is fundamentally a conda-flavored scientific stack, in which case Pixi is a better fit. For everything else — web services, CLIs, ML training pipelines, internal tools, libraries published to PyPI — uv has won the Python packaging argument. We rate it 94/100; the missing six points are entirely about the pre-1.0 churn and the conda gap, both of which are solvable problems on Astral's roadmap.

Frequently Asked Questions

Is uv free?: Yes. uv is dual-licensed under MIT and Apache-2.0 and is free for commercial and personal use, with no paid tier and no telemetry.
What platforms does uv support?: uv runs on macOS, Linux, and Windows, including ARM64 builds. It can be installed via the official shell installer, Homebrew, Cargo, pip, or as a standalone binary download from GitHub releases.
How does uv compare to Poetry?: uv is roughly 10-30× faster than Poetry on dependency resolution and 80-115× faster on installs with a warm cache. uv also manages Python interpreters directly, which Poetry does not, and produces a cross-platform lockfile by default. Poetry has a longer history and slightly gentler tutorials for absolute beginners.
Is uv open source?: Yes. The full source code is available on GitHub at astral-sh/uv under MIT and Apache-2.0 licenses.
Does uv replace conda?: No. uv replaces pip, pip-tools, pipx, poetry, pyenv, virtualenv, and twine, but it does not provide conda's binary distribution channel for scientific packages without PyPI wheels. For conda-style workflows, look at Pixi (which uses uv's resolver internally).
Will OpenAI keep uv open source after acquiring Astral?: Yes. OpenAI's March 2026 announcement committed to continued open-source development of Astral's tools alongside the broader Python community, with the team continuing to ship under the existing MIT/Apache-2.0 licenses.

#package-manager

Bun

uv