Python's Glow-Up: uv, Ruff, and a Modern Toolchain

Python's toolchain was famously fragmented. To start a new project you'd reach for pip, then venv (or virtualenv, or conda, or pipenv, or poetry — pick your poison), then flake8 for linting, then black for formatting, then isort for imports, then pylint for deeper checks. Seven tools for one developer experience. That era is ending.

Two tools from Astral — both written in Rust — are quietly unifying the Python workflow: uv for package and environment management, Ruff for linting and formatting.

uv: The New pip + venv

uv is a drop-in replacement for pip, pip-tools, and venv. It handles virtual environments, dependency installation, and script running — and it does all of it 10–100x faster than pip thanks to native execution and parallel downloads.

# Create a virtual environment
uv venv
 
# Install packages (reads requirements.txt or pyproject.toml)
uv pip install -r requirements.txt
 
# Add a package and update your lockfile
uv add httpx
 
# Run a script inside the venv without activating it
uv run python src/main.py

The uv run command is particularly useful in CI: no source .venv/bin/activate needed. uv finds or creates the venv and runs the command in one step.

uv also manages Python versions directly with uv python install 3.12, replacing pyenv for most workflows.

Ruff: Lint and Format in One

Ruff is a linter and formatter. One tool, one config file, one command — and it is reported to be around 25x faster than flake8 on large codebases.

[tool.ruff]
line-length = 100
target-version = "py312"
 
[tool.ruff.lint]
select = ["E", "F", "I", "UP", "B"]  # pycodestyle, pyflakes, isort, pyupgrade, bugbear
 
[tool.ruff.format]
quote-style = "double"
indent-style = "space"

Then in your terminal:

# Fix auto-fixable lint issues
ruff check --fix .
 
# Format all Python files
ruff format .

Ruff implements over 800 lint rules from flake8, pylint, isort, pyupgrade, and more — all in a single binary.

Real Type Checking Still Matters

uv and Ruff do not replace type checkers. For that, use pyright (fast, excellent VS Code integration via Pylance) or mypy (battle-tested, more configurable). Type checking with strict mode catches entire categories of bugs that linting misses.

Here is a quick example of a well-typed function — try editing it in the playground:

Putting It Together

A modern Python workflow in 2026 looks like this:

1. uv venv && uv pip install -r requirements.txt — environment and deps in seconds
2. ruff check --fix . — lint and auto-fix
3. ruff format . — consistent formatting
4. pyright . — type check before you commit or push

That is four commands replacing a sprawling ecosystem of seven-plus tools, with faster execution at every step.

The Takeaway

The Python toolchain is no longer a joke. uv makes environment management fast and predictable. Ruff makes linting and formatting something you actually run on every commit. And type checking with pyright or mypy elevates Python to production-grade reliability. The tools are stable, widely adopted, and genuinely better — there is no reason to keep reaching for the old stack.