uv: The Blazing-Fast Python Package Manager Changing the Game

If you are a Python developer, you have probably struggled with slow package installations, managing virtual environments, and dealing with messy dependency workflows. These challenges are common and often annoying. uv aims to change that experience completely.

In this article, I share my personal experience and key findings while using uv. I also walk you through step-by-step instructions to help you get started and onboard uv into your workflow.

What is uv?

uv is a next-generation Python package installer and project manager written in Rust. It is designed to be much faster, simpler, and more efficient than traditional Python tools like pip, venv, or poetry.

Hands Behind uv

Created by Astral — the company founded by Charlie Marsh (the original author of Ruff, the extremely popular Python linter). uv aims to become the “Cargo for Python” (Like Rust Offers): a single, unified, dependency-free binary that can completely replace pip, pip-tools, virtualenv, poetry, pipx, pyenv, and many other tools you currently juggle.

As of late 2025, uv has reached version ~0.9.x, with production-ready features that make it suitable for everyday use and even large-scale projects.

“ uv is an absolute game-changer! I just migrated a personal git repos what used to take 5+ minutes with Poetry now finishes in under 10 seconds. Thank you Astral! 🔥”

Features Of UV:

The core promise of uv is speed, achieved through:

• A Rust-based resolver and installer (no Python bootstrap overhead)
• Aggressive caching (global wheel cache, hardlinks/CoW where possible)
• Parallel downloads and builds
• Smart, version-pinned resolution that avoids unnecessary backtracking

Benchmarks consistently show:

• 8–10× faster than pip/pip-tools without cache
• 80–115× faster with a warm cache

[embed]

What Sets uv Apart?

• Blazing-fast installs uv is routinely 10–100× faster than pip (and often faster than Poetry or pipenv too). Dependency resolution and wheel installation that used to take seconds or minutes now finish in the blink of an eye.
• One tool to rule them all uv replaces pip + venv + pip-tools + pipx + virtualenv + pyenv in a single binary. You get dependency resolution, lockfiles, virtual-environment management, isolated global tool installation, Python version management, and even script running — all through the same uv command.
• Zero-friction developer workflow Virtual environments are created and populated automatically (no more python -m venv .venv && source .venv/bin/activate). A deterministic uv.lock file is generated on the first uv sync or uv lock. Running scripts with uv run always uses the correct environment, even if you delete .venv, uv silently recreates it in milliseconds. Project scaffolding, building, and publishing are also built-in, so you can go from idea to published package without ever leaving uv.

Getting Started: Install uv in Seconds

# macOS / Linux
$> curl -LsSf https://astral.sh/uv/install.sh | sh

# Windows (PowerShell)
$> powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

# Or via pip (if you already have Python)
$> pip install uv

# Update anytime with 
$> uv self update

Core Workflows:

1. Managing Python Versions:

uv can install and manage CPython (and even PyPy) distributions automatically:

$> uv python install 3.12 3.13 3.14   # latest patches
$> uv python list                     # see what’s installed
$> uv python pin 3.13                 # set default for new projects

# As of 2025, uv supports transparent patch upgrades (preview feature becoming stable):
$> uv python upgrade 3.13   # bump 3.13.4 → 3.13.5 seamlessly

2. Starting a New Project

$> uv init my-project
$> cd my-project
$> uv add fastapi uvicorn ruff

This creates a pyproject.toml, a lockfile (uv.lock), a virtual environment (.venv), and installs everything — in milliseconds.

3. Adding / Removing Dependencies

$> uv add requests "^2.32"
$> uv add "django>=5.0" --dev
$> uv add pytest --group test
$> uv remove numpy

uv supports optional dependency groups (dev, test, docs, etc.) out of the box — something many tools still struggle with.

4. Running Scripts and One-Off Commands

$> uv run main.py                # auto-creates/uses .venv
$> uv run --with httpx script.py # inline dependencies!
$> uv run ruff check             # runs from project env

# For global tools:
$> uv tool install black         # like pipx
$> uvx ruff@latest --version     # one-off runuv python install 3.12

5. Drop-in pip Replacement (Zero Migration Effort)

$> uv pip install -r requirements.txt
$> uv pip compile requirements.in -o requirements.txt
$> uv venv .venv

Advanced Features (2025 Highlights)

• Universal lockfiles — one uv.lock works across platforms and Python versions
• Workspace support — monorepos with multiple packages
• Overrides & alternative resolvers — force versions or use “lowest-compatible” strategy
• Script metadata — add # /// script headers for inline dependencies
• Preview features → stable pipeline (e.g., native credential storage, auto Python upgrades)
• Experimental wheel variants (with PyTorch/NVIDIA collaboration) for GPU-accelerated installs

uv vs Poetry vs pip: Performance Comparison Table

Here is the most up-to-date, real-world performance data as of November 18, 2025, based on the official Astral benchmarks (v0.9.6) and widely reproduced community tests.

[embed]

[embed]

[embed]

Demo

In this demo, I compare the installation performance of pip and uv, using the exact same requirements.txt.

The script automates the full workflow for both tools:

1. Create a clean virtual environment
2. Install dependencies
3. Measure real, user, and sys install times using /usr/bin/time -p
4. Capture output and generate an easy-to-read comparison table

The benchmark uses 11 commonly used Python packages — including FastAPI, Uvicorn, NumPy, Pandas, HTTPX, Rich, Loguru, and more — to simulate a realistic development setup.

[embed]

uv is ~14x faster than pip

uv reduce installation time by ~92%

uv use less CPU

How to Adopt uv in an Existing Python Project

You already have a codebase using requirements.txt, Poetry, Pipenv, pdm, or just a plain pyproject.toml. You want the insane speed of uv without rewriting everything overnight.

Here’s the battle-tested migration path that thousands of teams (and I personally) use in late 2025. It works whether your project is 6 months or 6 years old.

Phase 0 — Install uv (One Time)

Installation steps are already mentioned.

Phase 1 — Instant Speed Boost (Zero Code Changes)

Just replace pip commands — everything else stays exactly the same.

# Instead of pip install -r requirements.txt
$> uv pip install -r requirements.txt

# Instead of pip install -e .
$> uv pip install -e .

# In CI (GitHub Actions, GitLab, etc.)
$> pip install -r requirements.txt  →  uv pip install -r requirements.txt

You instantly get 10–50x faster installs with zero risk. Your existing lockfile (requirements.txt, poetry.lock, etc.) keeps working.

Phase 2 — Switch to uv’s Native Workflow

Case A: You currently use requirements.txt (± pip-tools)

1. Compile a perfect lockfile with uv (optional but recommended):

$> uv pip compile requirements.in -o requirements.txt   # if you have .in files
# or
$> uv pip compile requirements.txt --upgrade            # re-lock everything

2. From now on just do:

$> uv pip install -r requirements.txt   # still works
# but even better:
$> uv sync             # reads requirements*.txt automatically

3. Add a .gitignore entry if you want a uv-managed venv:

# add following liner in .gitignore 
.venv/

4. Done. You’re now 100% on uv while keeping full backward compatibility.

Case B: You currently use Poetry

Option 1 — Keep Poetry for publishing, use uv for everything else (most teams)

# Daily development & CI
$> uv pip install -r requirements.txt    # export once in a while with Poetry
# or better:
$> poetry export -f requirements.txt --without-hashes -o requirements.txt
$> uv sync   # now blazing fast

Option 2 — Full migration to uv (new projects or when you’re ready)

# 1. Convert dependencies to PEP 621 format (one-time)
# Move [tool.poetry.dependencies] → [project.dependencies]
# Move dev-dependencies → [project.optional-dependencies.dev] or use uv groups

# 2. Install everything with uv
$> uv sync --frozen          # creates .venv and uv.lock if needed

# 3. Replace Poetry commands
$> poetry add → uv add
$> poetry remove → uv remove
$> poetry run → uv run
$> poetry shell → just use your shell (uv run activates automatically)

# 4. Optional: remove Poetry-specific sections
# Delete [tool.poetry] entirely — uv only needs [project] and [tool.uv]

A lot of teams just delete [tool.poetry] after the move — uv ignores it anyway.

Case C: You use Pipenv, pdm, Hatch, Flit, etc.

# Export once
$> pipenv lock -r > requirements.txt
$> pdm export -o requirements.txt
$> hatch env prune  # etc.

# Then
$> uv pip install -r requirements.txt
# Eventually switch to uv add / uv sync

Phase 3 — Go All-In (Optional but Worth It)

Add a uv.lock file and commit it (replaces poetry.lock/Pipfile.lock):

$> uv lock          # generates uv.lock (universal, works on all OS/Python versions)
$> uv sync          # installs exactly what’s in the lockfile

Recommended .gitignore & Scripts

# Virtual environments
.venv/
__pypackages__/

# uv cache is global — never commit it
# but keep the lockfile!
uv.lock

Add convenient scripts to pyproject.toml:

[tool.uv]
# optional settings

[tool.uv.scripts]   # like Poetry scripts
dev = "uv run python -m pytest"
lint = "uv run ruff check"
format = "uv run ruff format"

CI/CD Example (GitHub Actions)

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install uv
        run: curl -LsSf https://astral.sh/uv/install.sh | sh
      - name: Install dependencies
        run: uv sync --frozen   # cached globally → seconds instead of minutes
      - name: Run tests
        run: uv run pytest

How uv Manages Virtual Environments

uv makes virtual environments nearly invisible and extremely fast by combining automatic discovery, project-local defaults, and a global cache with hard links.

Key Behaviors

• If a pyproject.toml is present, uv automatically uses (or creates) .venv in the project root.
• You almost never run uv venv manually commands like uv sync, uv pip install, or uv run create/activate the environment for you.
• No activation needed for daily work: uv run script.py just works with the correct environment.

Why It is So Fast?

• Packages are downloaded once into a global cache (~/.cache/uv).
• Virtual environments are populated with hard links (or copy-on-write on Windows) to the cache → creating an environment with 100+ packages takes <100 ms and uses almost no extra disk space.

# Common Commands 
$> uv run main.py                  # uses/creates project .venv
$> uv run --with flask main.py     # temporary env with extra package
$> uv run --isolated main.py       # fresh temp env, ignores existing ones
$> uv pip install requests         # installs into project .venv (if in a project)
$> uv pip install --system requests  # installs globally, skips venvs

Cleanup

Just delete .venv uv will recreate it next time it is needed. The global cache self-cleans (uv cache prune if you want to force it).

Demo

Final Thoughts

Python development is finally catching up to the expectations set by modern languages and environments. With uv you spend less time fighting your tools, and more time actually building. The only question is — why not start your next Python project with uv?

References:

1. https://dev.to/oliver_samuel_028c6f65ad6/uv-the-next-generation-python-package-manager-13pa
2. https://realpython.com/python-uv/
3. https://devcenter.upsun.com/posts/why-python-developers-should-switch-to-uv/
4. https://www.speakeasy.com/blog/release-uv-python
5. https://dev.to/upsun/why-python-developers-should-switch-to-uv-1i4f
6. https://www.digitalocean.com/community/conceptual-articles/uv-python-package-manager
7. https://blog.appsignal.com/2025/09/24/switching-from-pip-to-uv-in-python-a-comprehensive-guide.html
8. https://github.com/astral-sh/uv
9. https://www.saaspegasus.com/guides/uv-deep-dive/
10. https://shiftmag.dev/tame-python-chaos-with-uv-the-superpower-every-ai-engineer-needs-6051/
11. https://python.plainenglish.io/uv-the-python-package-manager-that-actually-respects-your-time-cdde36e74fd4
12. https://www.datacamp.com/tutorial/python-uv
13. https://docs.astral.sh/uv/getting-started/features/
14. https://www.youtube.com/watch?v=AMdG7IjgSPM
15. https://www.youtube.com/watch?v=5rTwOt9Qgik
16. https://thedataquarry.com/blog/towards-a-unified-python-toolchain
17. https://pydevtools.com/blog/year-of-uv/

👋 If you find this helpful, please click the clap 👏 button below a few times to show your support for the author 👇

🚀Join FAUN Developer Community & Get Similar Stories in your Inbox Each Week