I Timed uv Against pip on a Clean Windows CI Box — Here's What's Actually Faster

uv gets praised as "the Python package manager that's 10–100× faster than pip." That's Astral's own published claim — but published benchmarks are run on someone else's hardware. I wanted numbers from a machine I control, with nothing to prove. So I installed a real package with both tools, on the same interpreter, and wrote down the wall-clock time.

This isn't a sponsored post and there's no affiliate link. Below are the actual commands and the actual times, followed by the caveats that the hype videos skip.

The setup (so you can reproduce it)

• Host: a clean Windows CI box, no IDE, no pre-warmed caches beyond what uv already had.
• Interpreter: the exact same CPython 3.13.12 for both sides — uv pointed at the system interpreter, pip ran inside a python -m venv built from that same interpreter.
• Package: fastapi[standard] — a non-trivial dependency tree (pydantic, starlette, uvicorn, httpx, email-validator, and friends), not a toy single-file wheel.
• Timing: time.perf_counter() around each subprocess, single run each. I did not average — a single run is honest about variance, and I flag that below.

The toolchain under test:

$ uv --version
uv 0.11.12 (63c5f57d3 2026-05-08 x86_64-pc-windows-msvc)

# uv is a Rust binary from Astral (the team behind Ruff and ty):
# GitHub linguist reports ~19.1M bytes of Rust vs ~0.3M of Python in the repo.

The numbers

End to end, from zero to an installed, importable environment: uv took ~4.6s (0.061 + 4.529) versus ~16.5s for the classic venv + pip path (4.267 + 12.189) on this box.

What the commands actually looked like

Create the environment:

$ uv venv --python "C:/Program Files/Python313/python.exe" myenv
Using CPython 3.13.12 interpreter at: C:\Program Files\Python313\python.exe
Creating virtual environment at: myenv
Activate with: myenv\Scripts\activate
# wall-clock: 0.061s

Install cold, then reinstall warm from uv's global cache:

$ time uv pip install --python myenv/Scripts/python.exe "fastapi[standard]"
# resolved + downloaded + linked in 4.529s

$ uv cache dir
C:\Users\Admin\AppData\Local\uv\cache

# wipe the venv, recreate, reinstall the same tree:
$ time uv pip install --python myenv/Scripts/python.exe "fastapi[standard]"
# 1.284s  (cache hit — no re-download)

And the killer feature for reproducible builds — one command resolves and pins the entire tree:

$ uv pip compile req.in -o req.lock
# 0.275s

$ head -n 14 req.lock
# This file was autogenerated by uv via the following command:
#    uv pip compile req.in -o req.lock
annotated-doc==0.0.4
    # via fastapi
annotated-types==0.7.0
    # via pydantic
anyio==4.14.2
    # via starlette
fastapi==0.139.0
    # via -r req.in
idna==3.18
    # via anyio
pydantic==2.13.4
    # via fastapi

That lockfile is the part I'd actually pay for. pip freeze dumps your environment; uv pip compile resolves your requirements into a hash-pinnable, platform-aware lock — the thing pip-tools does, but without the 30-second "why is it still resolving" pause.

The bonus: uvx runs tools without touching your env

Need ruff or any CLI right now, without pip install polluting a project?

$ uvx --version
uvx 0.11.12 (63c5f57d3 2026-05-08 x86_64-pc-windows-msvc)

$ uvx ruff --version     # downloads ruff to an ephemeral env, runs it, done
ruff 0.11.12

One Rust binary now replaces virtualenv, pip, pip-tools, pyenv (mostly), and pipx. That's the real story — not just "faster," but fewer tools to think about.

Where this fits in your workflow

If you build AI agents locally — Ollama, LangGraph, AutoGen, MCP servers — you're constantly spinning up clean Python environments to isolate one experiment from the next. A 4.5-second cold install vs 12 seconds, and a 60ms venv vs 4 seconds, is the difference between "I'll just reuse the same messy env" and "I'll actually isolate this." Cheap environments get used; expensive ones get skipped. That's the whole game for agent iteration speed.

It also pairs naturally with the DevFlow automation bundle we ship — same philosophy, different layer: remove the friction between "I had an idea" and "it's running in a clean, reproducible environment." uv handles the Python side; the bundle handles scaffolding, CI gating, and release.

The bottom line

uv is genuinely faster in every operation I measured, and the gap widens the more you repeat the work (that cache is the quiet MVP). The "10–100×" marketing line is real but context-dependent — for a single small-ish install you'll see 2–3×, and for repeated, cached, large-tree workflows you'll see far more. Either way: on this clean Windows box, uv went from nothing to a working fastapi environment in under five seconds. pip took triple that. I'm switching my default.