uv Quietly Won the Python Packaging War — Here's How to Switch in 10 Minutes

For fifteen years, "how do I install a Python package?" had at least six different answers. As of 2026, it finally has one: `uv`. I've taught Python long enough to remember walking students through `virtualenv`, then `venv`, then `pyenv`, then `pipx`, then `poetry` — and watching their eyes glaze over before we'd written a single line of actual code. The tooling was a tax you paid before the fun started. That tax is basically gone now, and I want to show you why. ## The thing that finally clicked `uv` is a package and project manager from a company called Astral — the same folks behind Ruff. It's written in Rust, ships as a single binary with zero Python prerequisites, and it absorbed the jobs of `pip`, `venv`, `pip-tools`, `pipx`, and `pyenv` into one tool. The headline everyone quotes is the speed: uv resolves and installs dependencies **10–100x faster** than pip. That number sounds like marketing until you feel it. Creating a virtual environment and installing a fat dependency tree used to be "go make tea." With uv it's done before your hand leaves the keyboard. uv pulls this off by caching package metadata aggressively and installing in parallel, with a resolver that doesn't repeatedly re-download the world. But honestly? Speed isn't even the reason I switched. The reason is that I stopped having to *think*. One tool. One mental model. One config file. And the rest of the ecosystem has voted with its feet: major projects like FastAPI, Pandas, Apache Airflow, and Hugging Face have adopted Astral's tooling. The clearest signal came in March 2026, when OpenAI announced it was acquiring Astral and folding the team into its Codex group — uv had been downloaded over 100 million times a month by then. When a frontier lab buys the company behind your package manager, the "should I switch?" debate is effectively settled. ## Install it (this is the whole setup) macOS / Linux: ```bash curl -LsSf https://astral.sh/uv/install.sh | sh ``` Windows (PowerShell): ```powershell powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex" ``` That's it. No Python required first — uv can even install Python *for* you, which we'll get to. ## The five commands that replace your whole workflow Here's a brand-new project, start to finish: ```bash uv init my-project # scaffold pyproject.toml + a sane structure cd my-project uv add requests # add a dependency (writes to pyproject.toml + lockfile) uv add --dev pytest # dev-only dependency uv run python main.py # run inside the managed env — no "activate" needed uv sync # reproduce the exact locked environment anywhere ``` Notice what's *missing*: there's no `python -m venv .venv`, no `source .venv/bin/activate`, no `pip install -r requirements.txt`, no remembering to freeze your deps. `uv run` quietly ensures the environment exists and is in sync, then runs your command inside it. The virtual environment becomes something you stop thinking about — the way you stopped thinking about where your `.pyc` files go. The lockfile (`uv.lock`) is the unsung hero here. It pins *every* transitive dependency with hashes, so `uv sync` on your laptop and in CI produce byte-for-byte identical environments. "Works on my machine" loses one of its favorite hiding spots. ## It manages Python itself, too This is the part that makes people do a double-take. uv will download and manage Python interpreters for you: ```bash uv python install 3.13 3.14 # grab multiple versions uv python list # see what's available uv run --python 3.14 main.py # run on a specific version, instantly ``` So the old `pyenv` ceremony — compiling Python from source, fiddling with shims, debugging why your shell picked the wrong version — is also folded in. Need to test your library against 3.12, 3.13, and 3.14? That's three flags, not three afternoons. ## Two tricks I use every single day **Run a tool without installing it into your project.** This replaces `pipx`: ```bash uvx ruff check . # run ruff in an ephemeral, throwaway env uvx cowsay -t "uv rules" # try any CLI tool with zero commitment ``` `uvx` (shorthand for `uv tool run`) spins up a temporary environment, runs the tool, and cleans up. I use it constantly for one-off formatters, linters, and scaffolders I don't want polluting my project. **Single-file scripts with inline dependencies.** This one feels like cheating: ```python # /// script # dependencies = ["rich", "httpx"] # /// import httpx from rich import print print(httpx.get("https://api.github.com").json()) ``` Run it with `uv run script.py` and uv reads that little comment header (it's a real standard — PEP 723), builds a throwaway environment with `rich` and `httpx`, and runs it. No project, no manual install, no leftover mess. Sharing a runnable snippet with a student used to mean a paragraph of setup instructions. Now it's one self-contained file. ## The honest caveats I'd be a bad tutor if I only sold you the upside. - **It moves fast.** uv is young and ships frequently. Pin the uv version in CI so a surprise release doesn't change behavior under you. - **Migrating from Poetry isn't always one command.** `uv` reads standard `pyproject.toml`, but Poetry's older `[tool.poetry]` sections use a slightly different layout. Budget an hour for a real project, and check the migration notes. - **Corporate proxies and private indexes** work, but you'll want to configure `UV_INDEX` / credentials deliberately rather than assuming pip's config carries over. None of these are dealbreakers. They're "read the docs for ten minutes" speed bumps, not walls. ## Your takeaways - `uv` replaces pip, venv, pyenv, pipx, and pip-tools with one fast Rust binary — and major projects (FastAPI, Pandas, Airflow, Hugging Face) have adopted Astral's tooling, with OpenAI acquiring Astral itself in March 2026. - Learn five commands — `init`, `add`, `run`, `sync`, `python install` — and you've covered 95% of daily work. - `uvx` for throwaway tools, PEP 723 inline-dependency scripts for shareable snippets. These two alone will change how you prototype. - Pin the uv version in CI, and read the migration notes if you're coming from Poetry. The best part isn't any single feature — it's that packaging stops being a *topic*. You install uv once and then you just write Python. That's the whole dream. --- *If you want to pair on migrating a real project to uv — lockfiles, CI, private indexes, the lot — I tutor 1:1 and we can do it together in a session → /book-session. Bring your messiest `requirements.txt`.*