uv vs pip
uv vs pip compared for 2026: uv 0.13.9 (Astral, Rust, MIT/Apache-2.0, package + project + Python manager) vs pip 26.3 (PyPA, the installer bundled with CPython, MIT). Includes resolve and install timings from runs we did on the same machine, pylock.toml interop in both directions, the compatibility differences that bite during a switch, and a clear pick.
Quick Answer
pip is the installer that ships with Python; uv is a Rust rewrite from Astral that covers pip, pip-tools, virtualenv, pipx and Python version management in one binary. On 22 November 2026 we resolved and installed the same 86-package set (FastAPI, Django, pandas, boto3, Celery and friends) with uv 0.13.9 and pip 26.3: both picked identical versions, but uv resolved in 0.83 s cold against 7.9 s for pip lock, installed into an empty environment in 1.5-2.6 s against 11.9-13.7 s, and reinstalled from a warm cache in under half a second against roughly 10 s. With bytecode compilation on for both, the gap shrank to 7-8.5 s versus 27 s. The two now interoperate through PEP 751 pylock.toml files, which each tool read from the other in our test. Pick uv for new projects, CI and Docker builds, and anyone who wants lockfiles and Python versions handled by one tool. Keep pip where it is the only tool you can assume, where pip.conf, --user or exact pip behaviour matter, and inside minimal images that already have it.
Last updated November 22, 2026. Covers uv 0.13.9 (17 November 2026) and pip 26.3 (2 November 2026); documentation and release notes read on 22 November 2026, plus same-machine resolve, install and interop runs we did that day.
| Feature | uv | pip |
|---|---|---|
| Licence & Maintainer | MIT OR Apache-2.0; Astral; astral-sh/uv ~92.6k GitHub stars | MIT; Python Packaging Authority; pypa/pip ~10.3k GitHub stars |
| Latest Release (Nov 2026) | 0.13.9 on 17 Nov 2026 (0.13.8 on 12 Nov, 0.13.7 on 3 Nov) | 26.3 on 2 Nov 2026 (26.2.2 on 20 Oct, 26.2 on 29 Jul) |
| Python Support | PyPI package needs Python 3.8+ to install; the standalone installer needs no Python; macOS, Linux and Windows | Python 3.10+ (3.9 dropped in 26.1); bundled with CPython through ensurepip |
| Implementation | Rust, one static binary (uv, uvx) | Pure Python, runs inside the target interpreter (or targets one with --python) |
| What It Manages | Packages (uv pip), projects (add, lock, sync, run), workspaces, tools (uvx), Python versions, scripts, build and publish | Install, uninstall, download, wheel, freeze, list, check; experimental lock |
| Virtual Environment Handling | Installs only into an active virtual environment or a .venv found in the current or a parent directory; --system or --python to opt out | Installs into the interpreter that runs it; does not search for an inactive .venv |
| Python Version Management | uv python install, list and pin; downloads managed CPython builds | None |
| Lockfiles | uv.lock (universal, project mode); uv pip compile to requirements.txt or pylock.toml | Experimental pip lock writes pylock.toml (25.1+); -r pylock.toml installs (experimental, 26.1+); requirements.txt with hashes |
| Resolver Behaviour | Deterministic; may choose different but equally valid versions than pip when specifiers are loose (documented) | Backtracking resolver |
| Multiple Indexes | first-index by default: candidates only from the first index that has the package; --index-strategy unsafe-best-match for pip-like merging | Combines candidates from all indexes and picks the best version |
| Configuration | uv.toml, [tool.uv] in pyproject.toml, UV_* environment variables; does not read pip.conf or PIP_* | pip.conf / pip.ini and PIP_* environment variables |
| Bytecode Compilation | Off by default; --compile-bytecode or UV_COMPILE_BYTECODE=1 | On by default (--no-compile to skip) |
| Cache & Disk Use | Global cache, hardlinked on Linux and reflinked on macOS; 284 MB cache shared by all environments in our run | HTTP and wheel cache; each environment holds full copies (88 MB cache + 264 MB environment in our run) |
| pylock.toml Interop | Writes pylock.toml (uv pip compile -o pylock.toml) and installs one (uv pip sync pylock.toml) | Installs uv's pylock.toml with -r pylock.toml (experimental warning); pip lock output is readable by uv |
| Supply-Chain Controls | Hashes in lockfiles, --exclude-newer date cut-off, first-index default, on-sync OSV malware check (preview) | --require-hashes, --uploaded-prior-to (26.0; durations such as P3D since 26.1), --only-binary; no built-in vulnerability audit |
| Versioning & Stability | 0.x; minor version bumped for breaking changes; uv.lock schema changes only in minor releases | 26.x line in 2026: 26.0 (Jan), 26.1 (Apr), 26.2 (Jul), 26.3 (Nov); deprecations announced in release notes |
| Our Run: resolve 86 packages | 0.83 s cold, 0.05 s warm (uv pip compile), 86 packages | 7.88 s cold, 3.79 s warm (pip lock), same 86 versions |
| Our Run: install, empty cache | 1.49-2.60 s (no bytecode) | 11.85-13.70 s (no bytecode) |
| Our Run: reinstall, warm cache | 0.38-0.49 s; 7.3-8.5 s with --compile-bytecode | 9.45-11.91 s; 26.6-27.5 s with --compile |
| Our Run: peak memory | 59 MB warm reinstall, 129-135 MB cold install | ~150 MB warm reinstall, ~167 MB cold install |
uv
uv is a Python package and project manager written in Rust by Astral, the company behind Ruff. It ships as a single binary and has two faces: a pip-compatible interface (uv pip install, uv pip compile, uv pip sync) that Astral describes as a drop-in replacement for common pip and pip-tools workflows, and a project interface (uv init, uv add, uv lock, uv sync, uv run) built around pyproject.toml and a cross-platform uv.lock. It also installs Python versions, runs tools with uvx and handles scripts with inline metadata. uv is dual-licensed MIT or Apache-2.0 and still versioned 0.x; 0.13.9 was released on 17 November 2026.
Pros
- Much faster in our run: 0.83 s to resolve 86 packages cold (pip lock took 7.9 s), 1.5-2.6 s to install them into an empty environment (pip 11.9-13.7 s) and under 0.5 s to reinstall from cache (pip about 10 s)
- One tool for installs, lockfiles, virtual environments, Python versions (we installed CPython 3.14.10 in 1.24 s), command-line tools and scripts
- Global cache linked into environments: a second virtual environment with the same 86 packages added 19 MB and took 0.18 s, because files are hardlinked on Linux
- Safer defaults: refuses to install outside a virtual environment unless you pass --system, and stops at the first index that has a package to blunt dependency-confusion attacks
- Universal uv.lock for projects plus pylock.toml export and import, so pip users can install from what uv resolves
- Lower memory: 59 MB peak on a warm reinstall versus about 150 MB for pip
Cons
- Not an exact pip clone: it ignores pip.conf and PIP_* variables (our PIP_INDEX_URL was silently ignored), lacks options such as --user and --trusted-host, and only supports the subprocess keyring provider
- Skips bytecode compilation by default, which makes installs look faster than they are; turning it on for production images cost 7-8.5 s in our run
- Still 0.x with minor releases reserved for breaking changes, so pin the uv version in CI
- Stricter about malformed indexes and metadata than pip, so a few old packages that pip accepts may fail until upgraded
- A separate binary to install and trust, rather than something every Python already has
Best For
New projects, CI pipelines and Docker builds where install time matters, teams that want lockfiles and Python versions managed by one tool, and developers who juggle many virtual environments on one machine.
pip
pip is the package installer maintained by the Python Packaging Authority and the one Python itself bootstraps through the ensurepip module. It installs and uninstalls packages from PyPI or other indexes, local paths and version control, builds wheels, and reads requirements files. It is written in Python and runs inside an interpreter, and it deliberately stays an installer: virtual environments come from venv, Python versions from elsewhere. Recent releases added PEP 735 dependency groups (--group, 25.1), an experimental pip lock command that writes PEP 751 pylock.toml (25.1), and experimental installs from pylock.toml (26.1). pip is MIT-licensed; 26.3 was released on 2 November 2026 and supports Python 3.10 and newer.
Pros
- Already there: bundled with CPython via ensurepip, so every tutorial, Dockerfile and CI image can assume it
- The reference behaviour that tools and package authors test against, with pip.conf, PIP_* variables, --user and keyring providers all supported
- Compiles bytecode by default, so installed code starts without a first-run .pyc cost
- Moving towards standards: dependency groups, pylock.toml output and input, and --uploaded-prior-to for date-limited installs
- Picked exactly the same 86 versions as uv in our run, so switching tools does not change what you get when specifiers are tight
Cons
- Slow by comparison: 7.9 s to resolve 86 packages cold and 11.9-13.7 s to install them in our run, and about 10 s even with a warm cache
- No project management, lockfile workflow or Python version management of its own; pip lock and -r pylock.toml are still labelled experimental and print a warning
- Each virtual environment gets full copies of every package (264 MB per environment in our run) instead of links to a shared cache
- Merges candidates from all configured indexes, which leaves dependency confusion to your index setup
Best For
Environments where only stock Python can be assumed, scripts and docs that must work for everyone, setups that rely on pip.conf, --user installs or keyring auto-discovery, and minimal images where adding another binary is not worth it.
What we measured on the same machine
On 22 November 2026 we installed pip 26.3 and uv 0.13.9 into a Python 3.13.18 virtual environment on a 2-vCPU Linux sandbox (ext4) and used one requirements.in with eight top-level packages: fastapi[standard], django, sqlalchemy, pandas, requests, boto3, pytest and celery. Every run used its own fresh cache directory where the test called for a cold cache, and a new empty virtual environment each time. Resolution first: uv pip compile produced a requirements.txt with 86 pinned packages in 0.83 s from an empty cache and 0.05 s warm; pip lock produced a pylock.toml with the same 86 packages at identical versions (FastAPI 0.165.0, Django 6.1.3, pandas 3.1.1, NumPy 2.5.5, boto3 1.44.9) in 7.88 s cold and 3.79 s warm. Installing those pins into an empty environment took pip 11.85 and 13.70 s and uv 1.49 and 2.60 s. Reinstalling with a warm cache took pip 9.45-11.91 s over three runs and uv 0.38-0.49 s. Peak memory was about 150-167 MB for pip and 59 MB for a warm uv install. The network sat behind a proxy, so cold numbers include download time that will differ on your connection; the warm numbers are the cleaner comparison. These are single short runs on a shared machine, not a benchmark suite.
The bytecode caveat that changes the headline
The sandbox had pip's compile setting turned off globally, so our first round compared pip without bytecode against uv without bytecode, which is uv's default. That is the comparison most blog benchmarks show without saying so. pip normally compiles every installed .py file to .pyc during installation; uv does not, and its compatibility guide recommends turning compilation on for Docker images to improve start-up time. So we repeated the warm reinstall with pip --compile and uv --compile-bytecode. Both environments ended up with about 6,000 .pyc files and 375 MB on disk. pip took 26.6 and 27.5 s, uv 7.3 and 8.5 s. uv is still more than three times faster, and its CPU time was about twice its wall time on two cores while pip's matched its wall time, which points to uv using both cores for the work, but the gap is no longer twenty-fold. The practical rule: in development, leave compilation off and let Python write .pyc files lazily on import; in production images, set UV_COMPILE_BYTECODE=1 so the first request after a deploy does not pay for it. If you compare tools yourself, check whether each one compiled, or you will be measuring a setting rather than a tool.
Compatibility differences that bite during a switch
Astral's own compatibility page is candid that uv is not an exact clone of pip, and four of its differences cause most migration surprises. First, configuration: uv does not read pip.conf, pip.ini or PIP_* variables. In our test, PIP_INDEX_URL pointed at a dead address made pip fail with no matching distribution, while uv installed from PyPI anyway; UV_INDEX_URL with the same address made uv fail. A private index configured only for pip is therefore silently bypassed. Second, environments: uv pip install refuses to run without an active virtual environment or a .venv in the current or a parent directory, and printed exactly that error for us; pip installs into whatever interpreter runs it. Third, multiple indexes: uv takes candidate versions only from the first index that has a package, preferring extra indexes over the default, to stop a public package shadowing an internal one; pip merges all indexes and picks the highest version. Use --index-strategy unsafe-best-match only if you really want pip's behaviour. Fourth, missing options: --user and --trusted-host are tracked as open issues, and only the subprocess keyring provider is supported. uv is also stricter about invalid index HTML and metadata, so a handful of old packages may need upgrading.
Lockfiles, pylock.toml and mixed teams
For years the honest answer to locking with pip was pip-tools or a pip freeze of a working environment. That has changed. pip 25.1 added an experimental pip lock command that writes a PEP 751 pylock.toml, pip 26.1 added experimental installs from one with -r pylock.toml, and pip 26.2 and 26.3 added upload-time filtering, extras and non-default groups for those files. Both commands still print a warning that the feature may change without notice. uv has two locking modes: uv.lock, a universal lockfile for projects that records resolutions for every platform and Python version the project supports, and uv pip compile, which can now write either requirements.txt or pylock.toml. We tested the handover both ways. pip 26.3 installed uv's pylock.toml for all 86 packages in 3.63 s and pip check reported no broken requirements; uv pip sync installed pip's pylock.toml in 1.06 s and uv pip check agreed. That makes pylock.toml a workable contract for teams where some developers or deployment targets still run plain pip. Keep uv.lock for uv projects, since it carries more information, and export pylock.toml where a pip-only consumer needs it.
Disk, caches and what uv replaces
The other large difference is how installed files reach an environment. pip downloads into its HTTP and wheel cache and then copies files into each virtual environment, so in our run every new environment cost the full 264 MB on top of an 88 MB cache. uv unpacks wheels once into a global cache and links them into environments: on Linux we saw pandas files with a link count of two, one in the cache and one in the environment, and a second environment with the same 86 packages took 0.18 s and only 19 MB of extra space. The cache itself was 284 MB, because it stores unpacked files rather than wheels. If you keep many environments, that trade strongly favours uv; if you build a single throwaway Docker layer, mount the cache during the build so it does not end up in the image. Beyond installs, uv also replaces venv or virtualenv (uv venv), pyenv (uv python install, which fetched and installed CPython 3.14.10 for us in 1.24 s), pipx (uvx and uv tool) and pip-tools (uv pip compile and sync). Our uv init plus uv add fastapi pandas produced a 16-package universal uv.lock, and uv run executed code in the project environment without activating anything.
Verdict
Pick uv for new projects, CI and container builds. In our run it resolved the same 86-package set about ten times faster than pip lock, installed it five to eight times faster from an empty cache and more than twenty times faster from a warm one, and it gives you virtual environments, a universal lockfile and Python versions in the same binary. Pin the uv version, add --compile-bytecode (or UV_COMPILE_BYTECODE=1) to production images, and move any pip.conf settings to uv.toml or UV_* variables before you switch, because uv will not read them. Stay on pip when you cannot add a binary, when your workflow depends on --user installs, keyring auto-discovery or exact pip behaviour, or when you write instructions that must work on any stock Python. If you need both, standardise on pylock.toml: uv can write it and pip 26.x can install from it, which worked in both directions in our test.