"uv is 10 to 100 times faster than pip." You've seen the claim. It's on every Python blog, in every conference talk, in uv's own marketing. So I did the unfashionable thing: I actually measured it. Fresh virtual machine, twelve real packages, caches purged, stopwatch running. Three tools, head to head: pip, uv, and Poetry.
The results were not what the hype promised. They're more useful than the hype.
The test setup
I picked a dependency set that looks like a real project rather than a toy: FastAPI, Uvicorn, Pydantic, SQLAlchemy, Alembic, Requests, HTTPX, NumPy, Pandas, pytest, Ruff, and python-multipart. Twelve packages, all pinned, including two heavy binary wheels (NumPy and Pandas) so download time actually matters.
Each run started from a completely fresh virtual environment. "Cold" means every cache purged beforehand — the packages had to come down from PyPI. "Warm" means installing the same set a second time with caches intact. Machine: a standard Ubuntu cloud VM, October 2026. Nothing exotic.
The numbers
ToolCold cacheWarm cache
pip~60 s32 s
uv32 s4 s
Poetry33 snot measured
Read that twice, because the first surprise is that uv is not ten times faster than pip here. Cold, it's roughly twice as fast. Warm, pip doesn't speed up at all — and uv drops to four seconds, which is where the legend comes from.
What the numbers actually mean
Downloads dominate everything. On a twelve-package project over a decent network, all three tools spend most of their time waiting on PyPI, not resolving or installing. That's why uv cold (32 s) merely equals pip warm (32 s): once the bytes are local, pip is perfectly quick. The fabled 10–100x gaps show up on huge dependency trees, slow networks, or ancient pip versions — real scenarios, but not this one.
uv's real trick is its cache. Four seconds warm is the number you'll actually feel day to day: reinstalling after wiping an environment, spinning up CI, switching branches. uv's global cache with hardlinks means repeat installs are nearly free. pip redoes far more work each time.
Poetry is not slow anymore. Thirty-three seconds cold while also resolving the full dependency graph and writing a lockfile puts it level with uv. The "Poetry is slow" reputation dates from the 1.x era; Poetry 2.x resolved and installed this set without drama. (One honest footnote: Poetry's installer initially choked in my sandbox because the machine's temp disk was full — an environment quirk, not a Poetry bug. After clearing space, it ran clean.)
Beyond speed: what actually differs
Speed is the headline, but it shouldn't decide for you. The tools differ in philosophy:
pip is universal. It's on every machine, in every tutorial, in every Docker image. It has no lockfile concept — you pin versions in requirements.txt yourself (or add pip-tools). Zero learning curve, zero lock-in.
uv is a drop-in pip replacement that grew into a full project manager. uv init, uv add, uv run, uv sync cover the whole workflow, and it speaks both requirements.txt and pyproject.toml. One static binary, no Python needed to install it.
Poetry is lockfile-first. poetry.lock gives your team byte-identical environments, the resolver is mature, and publishing to PyPI (poetry publish) is built in. More structure, slightly more ceremony.
Which should you use? A decision guide
New project, you value speed and simplicity: uv. The warm-cache speed is addictive, and uv run removes the "did I activate the venv?" dance entirely.
A team that needs reproducible builds and publishes packages: Poetry. The lockfile workflow is still the most battle-tested answer to "it works on my machine."
Scripts, minimal CI, or teaching beginners: pip. It's everywhere, everyone knows it, and pinned requirements are fine at small scale.
Already on pip and wondering about migration cost: low. uv reads your existing requirements.txt as-is — I ran these very benchmarks that way — so you can try it on one project without committing.
The verdict
Don't pick a package manager on speed alone; on a normal project the gap is two-fold, not a hundred-fold, and your network matters more than your tool. Pick on workflow: uv if you want the fastest daily experience, Poetry if you want the strictest reproducibility guarantees, pip if you want zero new things to learn.
My default for new projects in 2026 is uv — not because of the marketing numbers, but because of the four seconds. That number is real, I measured it, and I feel it every day.
Reproduce it yourself
# pip
python3 -m venv venv && ./venv/bin/pip install -r requirements.txt
# uv
uv venv && uv pip install -r requirements.txt --python venv/bin/python
# poetry (from a pyproject.toml with pinned deps)
poetry install
Methodology note: twelve pinned packages (fastapi 0.115.6, uvicorn 0.34.0, pydantic 2.10.4, sqlalchemy 2.0.36, alembic 1.14.0, requests 2.32.3, httpx 0.28.1, numpy 2.2.1, pandas 2.2.3, pytest 8.3.4, ruff 0.8.4, python-multipart 0.0.20). Timed with wall-clock seconds on a fresh Ubuntu VM, October 2026. Your network will shift the absolute numbers; the ranking is what travels.
Originally published on LogicStack. Run the code examples right in your browser with our free interactive Python and SQL playgrounds — no setup, no sign-up.
Top comments (0)