Python Developer Tooling Handbook – Python Tooling Blog

If you're on mypy in 2026, Pyrefly is the obvious upgrade

Tim Hopper — Wed, 13 May 2026 11:00:00 +0000

The case for staying on mypy has often been migration cost. Pyrefly 1.0, released May 12, 2026, makes the mechanical half close to free:

uv add --dev pyrefly
uv run pyrefly init
uv run pyrefly check --baseline=pyrefly-baseline.json --update-baseline
uv run pyrefly check

pyrefly init reads an existing mypy.ini or [tool.mypy] section, writes the equivalent Pyrefly configuration, and turns on a preset called legacy that disables the checks mypy does not have. Pyrefly’s inference is more aggressive than mypy’s on the checks both tools run, so a real codebase will surface new diagnostics on the first check pass. The count depends on the codebase and how much was typed before. The baseline-snapshot step writes those errors to JSON so the final check returns clean and CI stays green while the team triages on its own schedule.

Python 3.14.5 rolls back the incremental garbage collector

Tim Hopper — Mon, 11 May 2026 09:00:00 -0400

Python 3.14.5 landed on 10 May 2026, pulled the incremental garbage collector that shipped in 3.14.0 through 3.14.4, and put the 3.13 generational collector back. Patch releases almost never reverse a major implementation change. The What’s New page names the cause: “due to a number of reports of significant memory pressure in production environments, it has been reverted back to the generational GC from 3.13.”

Recap what the incremental collector promised

CPython collects cyclic garbage with a tracing collector that runs alongside refcounting. Up through 3.13, that collector was generational with three generations. Objects that survived a collection moved up a generation, and the collector visited older generations less often. A full collection of the oldest generation traced every object the program kept alive, which on long-running processes produced multi-hundred-millisecond pauses.

mypy 2.0 picks parallelism over a rewrite

Tim Hopper — Sat, 09 May 2026 09:00:00 -0400

For most of the past year, the speed conversation around Python type checkers has had one shape: mypy is the slow incumbent, and the fast alternatives (ty, Pyrefly, Zuban) earn their speed by being written in Rust. mypy 2.0, released May 6, 2026, takes a different route. It runs across multiple cores.

Run mypy across cores

The headline feature is --num-workers N (or -nN). Pass a worker count and mypy splits type checking across processes:

Locking dependencies for PEP 723 single-file scripts in May 2026

Tim Hopper — Fri, 08 May 2026 09:00:00 -0400

PEP 723 plus uv made single-file Python scripts easy to share. Declare dependencies in a commented TOML block, drop the file in a gist, and uv run script.py builds an ephemeral environment and runs it without a project directory or activation step. Locking those dependencies so the script behaves the same six months from now is still awkward. The inline dependencies list pins the top-level requirements you specify and nothing else; the transitive graph gets re-resolved every time the script runs on a new machine.

Ruff Already Rewrites Your Python to Be More Idiomatic

Tim Hopper — Tue, 05 May 2026 00:00:00 +0000

Open any Python codebase that’s been through a few hands and you’ll find the same fossils: a for loop adding items to a set one at a time, a conditional slice that could be removesuffix(), a two-line open()/read() that pathlib handles in one call. The code works. It passes every linter you’ve enabled. And a reviewer who knows Python well would rewrite all of it.

Ruff can already do that rewriting. It ported 36 rules from refurb into a category called FURB, and every one of them ships with an auto-fix. Most projects haven’t turned them on because Ruff’s defaults only enable Pyflakes (F) and a subset of pycodestyle (E). The rules that catch non-idiomatic patterns sit behind an opt-in flag, invisible to the people who’d benefit most.

Lightning Got Owned: When `import lightning` Steals Your Credentials

Tim Hopper — Thu, 30 Apr 2026 00:00:00 +0000

import lightning shows up at the top of millions of PyTorch training scripts. On April 30, 2026, that line was enough to ship a developer’s credentials to an attacker.

Two malicious versions of the lightning PyPI package, 2.6.2 and 2.6.3, were uploaded today. Lightning averages 311 thousand downloads a day, and any CI that ran uv sync --upgrade between the upload and the takedown pulled the bad wheel. Neither version corresponds to a GitHub release on Lightning-AI/pytorch-lightning; the latest tagged release there is still 2.6.1 from January 30. The bad code was uploaded directly to PyPI, which is the same pattern as the litellm compromise six weeks ago. Socket flagged both releases 18 minutes after upload, and PyPI has since quarantined the entire project.

What Reddit taught me about why people switch to uv

Tim Hopper — Mon, 27 Apr 2026 09:00:00 -0400

A thread titled “But really, why use uv?” landed on r/Python and pulled 476 upvotes. The original poster wasn’t antagonistic. They used Python casually, installed packages two or three times a month, and couldn’t see why uv was worth adding to a setup that already worked.

The comments convinced them. Reading through the top responses surfaces something the standard uv pitch misses: the compelling case for casual users is not the same as the compelling case for power users.

ty and pyrefly find different bugs

Tim Hopper — Mon, 27 Apr 2026 00:00:00 +0000

Note

Update 2026-04-29: An earlier version of this post used a multi-line Liskov-violation panel from rich/_null_file.py as an example of ty catching a real protocol bug. That diagnostic turned out to be a ty false positive: ty reports the base parameter type as Buffer when checking overrides on subclasses of IO[str], even though the parameterization should resolve AnyStr to str. mypy and pyright are both silent on the same code. The “Where ty pulls ahead” section has been rewritten with a tuple-arity finding instead, and the conclusion’s reference to “Liskov panels” has been dropped. Thanks to a reader for the catch.

Did pip 26 close the gap with uv?

Tim Hopper — Fri, 24 Apr 2026 09:00:00 -0400

pip 26.0 closed two of uv’s clearest feature gaps in January: PEP 723 script installs and a datetime-based package filter that mirrors uv’s --exclude-newer. The October 2025 Hacker News thread that kept circling back to “pip has quietly caught up” now reads less contrarian than it did at the time, and the OpenAI acquisition of Astral in March changes the “is this safe to depend on” calculus at the same time.

Review pip’s 2025 to 2026 releases

Four pip releases have landed since April 2025, and the first three narrowed gaps uv was best known for:

How Astral Uses Its Own Tools

Tim Hopper — Thu, 23 Apr 2026 09:00:00 -0400

Astral runs ruff, uv, and ty inside the repos that build them. Their pyproject.toml, .pre-commit-config.yaml, and CI files are public, and a walk through the three shows how the people making ruff, ty, and uv wire their own toolchain into the projects that produce it.

Build ty from source and type-check Python with it

The ruff repository ships ty as part of its crate tree. Three CI steps build ty from source and run it against the repo’s own Python:

Astral told you how they secure uv. Here's what to keep.

Tim Hopper — Thu, 16 Apr 2026 00:00:00 +0000

Astral published a detailed writeup of how they secure the org that ships uv, Ruff, and ty. It’s a good post. It’s also, for most readers, the wrong post.

Most of what Astral describes is team-scale GitHub hygiene: org-wide branch protection rulesets, workflow audits with zizmor, action pinning with pinact, isolated GitHub Apps for privileged operations. If you run a project with outside contributors, read the whole thing. If you’re one person shipping a Python package, a lot of it is overkill for the threat model you actually face.

PyPI's Second Audit Found 14 Bugs. Two Remain.

Tim Hopper — Thu, 16 Apr 2026 00:00:00 +0000

PyPI completed its second external security audit today. Trail of Bits found 14 issues in the Warehouse codebase: 2 High, 1 Medium, 7 Low, 3 Informational, 0 Critical. Twelve were patched. Two were accepted as known gaps. The work was funded by the Sovereign Tech Agency, with remediation by PSF’s Mike Fiedler through Alpha-Omega support.

An audit of PyPI is an audit of the index infrastructure, not of the packages hosted on it. None of the findings describe malware in the wild. The patched bugs are the predictable part; the accepted ones are where the signal lives.

Your Python Wheels Still Target 2009 CPUs

Tim Hopper — Wed, 15 Apr 2026 00:00:00 +0000

Intel shipped AVX2 in 2013. AMD reached it with Excavator-era parts around 2015. Eleven years later, the default NumPy wheel pip downloads on an x86_64 Linux box is still compiled to run on processors from roughly 2003, the year AMD launched the Opteron and defined the AMD64 baseline. Every SIMD instruction that has shipped since is off-limits to the compiler that produced that wheel.

The reason is structural. A wheel filename encodes three pieces of compatibility metadata: Python version, ABI, and platform. “Platform” for mainstream Linux wheels is typically manylinux_2_17_x86_64, which says “works on any glibc 2.17+ x86-64 distro” and nothing about which CPU instruction sets the machine supports. When a project publishes one binary for all of those users, it has to target the lowest common denominator.

uv won developer hearts. Now it has to win READMEs.

Tim Hopper — Tue, 14 Apr 2026 09:00:00 -0400

uv ranked as the most admired technology in Stack Overflow’s 2025 Developer Survey at 74%. A recent analysis by Andrey Aleyan of the top 100,000 Python repositories on GitHub put uv adoption (measured by the presence of uv.lock) at roughly 10%. The gap between “developers love this” and “developers ship this” is wider than any tooling story in recent memory.

Aleyan’s diagnosis is that AI coding agents are the bottleneck: their training data is overwhelmingly pip install -r requirements.txt, so they emit pip install -r requirements.txt. That diagnosis is correct but incomplete. Adoption is bottlenecked by three reinforcing forces, and the AI-agent story is only one of them.

The Python Packaging Summit Returns to PyCon US

Tim Hopper — Thu, 09 Apr 2026 12:00:00 +0000

The Python Packaging Summit returns Friday, May 15, 2026 in Room 201A of the Long Beach Convention Center, running 1:45 to 5:45 PM on the Friday of PyCon US. Pradyun Gedam, C.A.M. Gerlach, and Jannis Leidel co-chair again. Attendance is capped and invite-only: submit the attendance form and topic-pitch form by April 30 (AoE). The schedule drops around May 4.

The summit puts the people who build uv, pip, Poetry, Hatch, conda, PyPI, and the major wheel-producing libraries in one room to argue through the year’s thorniest packaging questions. The notes from 2024 and 2025 are the best public window into where pyproject.toml, wheel tags, and lock files are headed.

How uv Solves Dependencies So Fast

Tim Hopper — Thu, 09 Apr 2026 00:00:00 +0000

Tip

Want more on uv? Browse every uv tutorial, how-to, reference, and explanation on the uv topic page.

Python dependency resolution is NP-hard in the formal sense: it reduces to Boolean satisfiability. In a Jane Street tech talk (YouTube), Charlie Marsh walked through why uv’s resolver has to solve this problem and the architectural decisions that let it do so 10-100x faster than pip.

LLM-Powered Copycats Are Flooding PyPI

Tim Hopper — Wed, 08 Apr 2026 00:00:00 +0000

A developer named Roman Dubrovin published repowise, a tool for generating structured wikis from codebases, as his first PyPI package. The next morning, he searched for it on PyPI and found three new packages he didn’t recognize: repowise-pro, repowise-enhanced, and repowise-next.

All three had been uploaded within a 90-minute window. All three carried the same description: “Codebase intelligence that thinks ahead — outperforms repowise on every dimension.”

They weren’t empty shells. Someone had forked Dubrovin’s AGPL-3.0 licensed source code, run it through an LLM to patch a couple of minor issues, and republished under new names without attribution or license compliance. A community member confirmed that all three packages traced back to the same person and the same GitHub repository.

In 2012, Guido Had No Idea NumPy Had Its Own Packaging System

Tim Hopper — Tue, 07 Apr 2026 00:00:00 +0000

In a recently resurfaced 2012 PyData panel discussion, Fernando Perez, Travis Oliphant, and David Cournapeau sat down with Guido van Rossum to discuss the scientific Python community’s needs. The conversation wandered through operator overloading (which eventually produced the @ matrix multiplication operator in Python 3.5) and import performance on supercomputers. The packaging segment is the one worth revisiting.

David Cournapeau, who maintained NumPy’s build infrastructure, explained that NumPy had written its own packaging layer on top of distutils that was “as much code as distutils itself.” NumPy had to override nearly every piece of distutils to handle Fortran compilers, C++ extensions, Cython, cross-platform compiler flags, and builds on exotic hardware like IBM Blue Gene supercomputers.

Migrating from mypy to ty: Lessons from FastAPI

Tim Hopper — Fri, 03 Apr 2026 00:00:00 +0000

Sebastián Ramírez, creator of FastAPI, recently announced that all his Python projects now use ty for type checking. That includes FastAPI, Typer, SQLModel, Asyncer, and FastAPI CLI.

Migrating the projects wasn’t a hard switch. It was incremental, messy in the middle, and completed at different speeds across different projects. That pattern offers a useful template for anyone considering the same move.

Ramírez didn’t rip out mypy and replace it with ty in a single PR. Instead, he added ty alongside mypy and ran both checkers in parallel. Four of his five major repos still operate this way. Only SQLModel has fully dropped mypy.

LiteLLM Got Owned, and Your Dependencies Might Be Next

Tim Hopper — Tue, 24 Mar 2026 00:00:00 +0000

Earlier today, someone published malicious versions of litellm (versions 1.82.7 and 1.82.8) to PyPI. No corresponding release appeared on GitHub. The package was uploaded directly to PyPI, bypassing the normal release process, which points to a compromised maintainer account or token.

What the malware did

The payload was a .pth file named litellm_init.pth. Python executes .pth files automatically on interpreter startup, so the malware ran without any user interaction once the package was installed.

OpenAI to Acquire Astral

Tim Hopper — Thu, 19 Mar 2026 00:00:00 +0000

OpenAI announced today that it will acquire Astral, the company behind uv, Ruff, and ty. The Astral team will join OpenAI’s Codex group after the deal closes, subject to regulatory approval.

What this means for Codex

Codex, OpenAI’s coding agent, has grown to over 2 million weekly active users, with 3x user growth and 5x usage increase since the start of 2026. Acquiring Astral gives OpenAI direct ownership of tools that millions of Python developers already depend on. OpenAI plans to integrate Astral’s tools more deeply into Codex so the agent can interact with the toolchain developers already use.

Charlie Marsh on uv, Coding Agents, and the Changing Open Source Contract

Tim Hopper — Tue, 24 Feb 2026 12:00:00 -0500

Charlie Marsh (founder of Astral, creator of ruff, uv, and ty) joined Michael Chow and Wes McKinney on The Test Set. They covered uv’s adoption strategy, how coding agents are changing Astral’s development process, and what’s happening to open source when writing code becomes cheap.

uv’s compatibility layer was the point

When uv first shipped, it only had uv pip install and uv venv. Some people found this odd. Charlie says it was deliberate:

Seven Claude Code Skills for Python from the Creator of spaCy

Tim Hopper — Mon, 16 Feb 2026 08:00:00 -0500

atthew Honnibal, co-founder of Explosion and creator of spaCy, has published a collection of Claude Code skills for Python development. It’s one of the more thoughtful skill collections I’ve seen.

Claude Code skills are markdown files you place in ~/.claude/commands/. When you type /<skill-name> in Claude Code, the file’s contents are injected as instructions. Think of them as reusable prompts that give Claude a specific methodology for a task, rather than leaving it to improvise.

Pydantic Monty: A Secure Python Interpreter for AI Agents

Tim Hopper — Fri, 06 Feb 2026 10:00:00 -0500

Pydantic has released Monty, a minimal Python interpreter written in Rust for safely executing LLM-generated code.

AI agents that generate code face a tradeoff: trust the generated code completely, or spin up containers for isolation. Containers are slow and resource-intensive. Trusting arbitrary code is risky. Monty sidesteps both by sandboxing execution at the interpreter level, blocking dangerous operations while running Python in microseconds.

How It Works

Monty provides a straightforward API:

FOSDEM Talk: Modern Python Monorepo with uv, Workspaces, and prek

Tim Hopper — Thu, 05 Feb 2026 08:00:00 -0500

Jarek Potiuk, Apache Airflow PMC member and the project’s top committer, gave a talk at FOSDEM 2026 on how Airflow manages its massive Python monorepo. The recording is now available.

Airflow ships over 120 separate Python distributions from a single repository, with 700+ dependencies and 3,600+ contributors. That scale forced the team to modernize their tooling. The talk walks through how they did it.

uv Workspaces for Monorepo Management

The new setup centers on uv workspaces. Rather than splitting 120 distributions across separate repositories or bundling everything into an unmanageable monolith, Airflow uses uv’s workspace feature to let distributions depend on each other via local sources instead of pulling from PyPI.

uvx.sh: Install Python tools without uv or Python

Tim Hopper — Thu, 22 Jan 2026 12:00:00 -0500

Astral has released uvx.sh, a service that generates installation scripts for any Python tool on PyPI. With a single curl or PowerShell command, users can install tools like ruff or pytest without having uv or Python already installed on their system.

How It Works

uvx.sh dynamically generates installation scripts for any PyPI package. The URL pattern is simple:

uvx.sh/{package}/install.sh     # macOS/Linux
uvx.sh/{package}/install.ps1    # Windows

For example, to install ruff:

Teaching Claude Code Quality Patterns with a Custom Skill

Tim Hopper — Fri, 09 Jan 2026 09:00:00 -0500

Dagster’s dignified-python-313 skill guides Claude Code to write Python 3.13 code that matches their project conventions.

What It Covers

Modern Python 3.13 Patterns: Use native type syntax (list[str], str | None) instead of older alternatives. Skip from __future__ import annotations since Python 3.13 doesn’t need it.

CLI Development: Build Click interfaces with proper error handling. Use click.echo() for output, direct errors to stderr, and treat CLI commands as error boundaries that catch exceptions and exit with SystemExit(1).

ty is Built with AI

Tim Hopper — Fri, 02 Jan 2026 08:00:00 -0500

Tool creators are building their tools with AI coding assistants.

Boris Cherny, creator of Claude Code, didn’t open an IDE in December but wrote 200 PRs with Claude Code. Charlie Marsh, creator of ruff, uv, and ty, noted that all his PRs to ty were created with Claude Code. The tools building themselves.

Integration with Python Tooling

The handbook’s Modern Python Project Setup Guide for AI Assistants provides structured guidance so AI tools default to uv and modern patterns rather than falling back to pip commands.

How uv Achieved Its Performance

Tim Hopper — Fri, 26 Dec 2025 18:00:00 +0000

Andrew Nesbitt’s “How uv got so fast” explains that uv’s speed comes less from Rust and more from eliminating work entirely.

Speed Through Elimination

Rather than optimizing slow code paths, uv just removes them:

No .egg support
No pip.conf
No bytecode compilation by default
Ignoring requires-python upper bounds reduces resolver backtracking

Rust-Independent Optimizations

Many of uv’s performance gains could work in pip:

Parallel downloads instead of sequential
Smart HTTP range requests for metadata

uv got fast by launching when PEP 658 infrastructure was ready and by skipping backward compatibility requirements that slow down pip.

ty: Astral's New Python Type Checker Released

Tim Hopper — Tue, 16 Dec 2025 22:43:00 -0500

Astral released ty, a Python type checker written in Rust, today. The company behind uv and Ruff designed ty as an alternative to mypy and pyright, with performance as a primary focus.

Speed Benchmarks

According to Astral’s benchmarks:

ty checks the home-assistant project in 2.19 seconds (20x faster than mypy’s 45.66 seconds)
After editing a file in PyTorch, ty recomputes diagnostics in 4.7ms (80x faster than pyright’s 386ms)

Key Features

ty includes several design choices that distinguish it from existing type checkers:

Teaching LLMs Python Best Practices

Tim Hopper — Fri, 21 Nov 2025 09:00:00 -0500

Large language models possess extensive Python knowledge from training data, yet they consistently struggle with modern tooling practices. Despite being trained on massive amounts of Python code, frontier models often default to outdated patterns like direct python or pip commands instead of using virtual environments and modern tools like uv.

how is it, that despite every frontier LLM being insanely python maxxed they rarely use virtural envs, and even adding rules like "we are using uv, do everything with uv" they ignore it and think the system python is broken. like, every time. that's actually an accomplishment

Claude Code Hooks for uv Projects

Tim Hopper — Tue, 11 Nov 2025 06:00:00 -0500

Claude Code supports custom hooks that guide the AI agent toward project-specific workflows. For Python projects using uv, hooks can prevent Claude from falling back to pip and python commands.

Note

This post builds on the interceptor approach for teaching AI agents about uv. Interceptors provide runtime feedback; hooks prevent problematic commands before execution.

Sync with uv: Eliminate Pre-commit Version Drift

Tim Hopper — Fri, 26 Sep 2025 15:01:00 -0400

anaging tool versions across multiple configuration files creates persistent headaches in Python development. When you upgrade ruff in your pyproject.toml, you must remember to manually update the pre-commit hook version in .pre-commit-config.yaml. This version drift causes inconsistent behavior between local development and pre-commit checks.

The sync-with-uv library solves this by automatically synchronizing tool versions between uv’s lockfile and .pre-commit-config.yaml.

The Problem

Consider this common scenario:

# pyproject.toml
[dependency-groups]
lint = ["ruff>=0.1.0", "mypy>=1.0.0"]

# .pre-commit-config.yaml
repos:
- repo: https://github.com/astral-sh/ruff-pre-commit
  rev: v0.1.5  # Must manually sync with pyproject.toml
  hooks:
    - id: ruff

When uv lock --upgrade updates ruff to 0.1.8, the pre-commit hook stays pinned to 0.1.5. This creates confusing behavior where local checks differ from pre-commit results. The same gap applies to mypy and any other tool pinned in both files.

Analysis of the New Wave of Python Type Checkers

Tim Hopper — Wed, 17 Sep 2025 20:31:00 -0400

Rob Hand’s comparison of emerging type checkers is the first comprehensive look at three new Rust-based tools: ty (Astral), pyrefly (Meta), and zuban (David Halter).

Key Findings

Performance drives the rewrite. All three abandon Python implementations for Rust, targeting the bottlenecks that slow existing checkers on large codebases.

Conformance scores don’t predict usefulness. ty passes only 15% of the typing conformance suite’s tests but works well for everyday Python. The suite apparently focuses on edge cases most developers never hit.

prek: pre-commit, but fast

Tim Hopper — Tue, 16 Sep 2025 10:40:00 -0400

pre-commit is an essential tool in my development workflow for running ruff and other tools. However, nobody wants to wait for their commits to be saved, and pre-commit isn’t always the fastest.

prek is a Rust-based drop-in replacement that runs 10x faster while using half the disk space.

Replacing pre-commit with prek is painless:

Install with uv tool install prek
Run pre-commit uninstall && prek install

That’s it. No configuration changes, no compatibility issues.

uv format: Code Formatting Comes to uv (experimentally!)

Tim Hopper — Thu, 21 Aug 2025 16:08:00 -0400

The latest uv release (0.8.13) quietly introduced an experimental new command that Python developers have been waiting for: uv format. This addition brings code formatting directly into uv’s toolkit, eliminating the need to juggle multiple tools for basic Python development workflows.

What is uv format?

The uv format command provides Python code formatting through uv’s interface. Under the hood, it calls Ruff’s formatter to automatically style your code according to consistent standards.

Google Sunsets Pytype: The End of an Era for Python Type Checking

Tim Hopper — Thu, 21 Aug 2025 10:48:00 -0400

Google announced that Pytype, their Python static type checker, will end support with Python 3.12. After 13 years of development, Google is shifting resources toward “new typing approaches” rather than continuing to maintain their bytecode-based analyzer.

Pytype’s fundamental architecture became its limitation. Built on bytecode analysis, the tool struggled with Python’s evolving type system. As Google noted, “bytecode’s inherent instability and propensity to change” made implementing new typing PEPs increasingly difficult.

ty's Breakthrough: Why Incremental Analysis Matters for Python

Tim Hopper — Mon, 11 Aug 2025 09:22:00 -0400

In a recent PyBytes podcast interview, Astral’s Charlie Marsh shared insights into what makes their new type checker ty unique and how it aims to address longstanding challenges in Python type checking.

What is ty?

ty serves dual purposes: it functions as a standalone command-line type checker (similar to mypy) and as a language server that powers IDE features like go-to-definition, code completion, and real-time diagnostics.

“We wanted to build a great type checker and a great language server, and they have things that are in common but they also have very different requirements,” Marsh explained. “If you don’t think about both of those from the start, you end up in a little bit of trouble.”

How Python's RFC Process Paved the Way for uv, Ruff, and Ty

Tim Hopper — Fri, 01 Aug 2025 15:22:00 -0400

Astral, an independent startup, has taken the Python world by storm over the last few years with three fast, robust Python developer tools:

ruff (linter and formatter)
uv (packaging and project management)
ty (static type checker, still under development)

These tools came from the mind of Charlie Marsh, who is neither a Python core developer nor directed by the Python Steering Council. While being independently developed, these tools work seamlessly within the established Python ecosystem. This success stems partly from Astral’s attention to guidelines established by the Python Enhancement Proposal (PEP) process over the last twenty-five years.

Interview with the Pybites podcast

Tim Hopper — Wed, 30 Jul 2025 09:20:00 -0400

Bob Belderbos invited me on the Pybites podcast where I talked about the handbook, uv, and more. I hope you enjoy it.

Use Interceptors to teach Claude Code to use uv

Tim Hopper — Mon, 28 Jul 2025 09:34:00 -0400

AI coding agents like Claude Code, Cursor, or GitHub Copilot often default to using system Python interpreters instead of using uv.

Armin Ronacher, creator of Flask and Jinja, shared an elegant solution to this problem: creating dummy Python interpreter that actively redirect AI agents toward better tooling choices.

Tip

uvhow: Get uv upgrade instructions for your uv install

Tim Hopper — Tue, 22 Jul 2025 20:18:00 -0400

I’ve released uvhow, a simple command-line tool that detects how uv was installed on your system and provides the correct upgrade instructions.

uv can be installed through multiple methods. When it’s time to upgrade, users often struggle to remember which installation method they used, leading to confusion about the correct upgrade command.

uvhow automatically detects your uv installation method and tells you exactly how to upgrade:

uvx uvhow

The tool works across Windows, macOS, and Linux and supports all major installation methods including:

uv 0.8 Release: Automatic Python Installation to PATH

Tim Hopper — Sat, 19 Jul 2025 09:27:00 -0400

[!TIP]

Check out our guide to upgrading uv

uv 0.8 stabilizes one of the most significant workflow improvements in Python tooling: automatic installation of Python executables to your PATH. This means you can finally install Python versions with uv python install and use them system-wide without wrestling with environment activation.

Global Python Access Without the Hassle

The headline feature addresses a long-standing frustration in Python development. When you run:

Python is good now!

Tim Hopper — Wed, 16 Jul 2025 13:43:00 -0400

love César Soto Valero’s recent post I’m Switching to Python and Actually Liking It.

To my great surprise, I’ve found that Python, and everything around it, has really improved a lot over the last decades.

Here are just three examples:

Python has created a very complete ecosystem of libraries and tools for processing and analyzing data.

Python has gotten faster with optimized static compilers like Cython.

Python has done a good job of hiding its legacy ugliness (such as __init__, __new__, and similar aberrations), sweetening its syntax to accommodate developers with good taste.

Read the whole post.

Why isn't Python packaging part of core development?

Tim Hopper — Wed, 16 Jul 2025 10:51:00 -0400

In a video interview with bitecode.dev, Python core developer Brett Cannon explains why packaging was never part of core development. The answer is disarmingly simple: the people in charge weren’t interested.

Basically, they’re separate because Guido doesn’t care about packaging. That’s really what it comes down to. When packaging started to become a thing, we just didn’t have any interest in it, and so it never became a core dev concern. It just never came up—it was just not our thing. So the community in various ways stepped up to fill that void.

Hynek Schlawack's uv Workflow Guide

Tim Hopper — Mon, 07 Jul 2025 10:21:00 +0000

{< youtube TiBIjouDGuI >}}

Hynek Schlawack’s new video “uv: Making Python Local Workflows FAST and BORING in 2025” demonstrates practical uv workflows using real examples.

He covers:

Replacing pip/virtualenv/pyenv with a single tool
Dependency management and lock files
Testing and linting integration
just integration for cross-platform commands

If you missed Part 1 of Hynek’s series, it’s available here.

The uv build backend is now stable

Tim Hopper — Thu, 03 Jul 2025 01:29:29 +0000

For about a year, uv has had a uv build command for generating distributable wheels and source distributions on pypi and elsewhere.

However, uv has relied on other tools for the build backend, i.e. the actual piece constructing the wheel or sdist as defined by PEP 517. By default, uv uses hatchling as the build backend.

As of this week, the uv team has now declared the uv build backend as stable and, most notably, really, really fast. Charlie Marsh’s benchmarks suggest that it’s 10 to 35 times faster than flit, hatchling, and setuptools. While I’ve never really needed my package builds to be faster, I’ve learned that faster tools often enable new things I didn’t imagine possible; I’m interested to see what those might be here.

Managing Python Versions In Your uv Projects

Tim Hopper — Wed, 25 Jun 2025 10:09:00 +0000

One of the many ways the package manager uv has changed Python is by making it painless to install and run different versions of the Python interpreter.

That said, I’ve occasionally gotten tripped up configuring this correctly in my development environments. I’ve written a few articles to try to clarify things:

How to install Python with uv. Before you can pin a Python version, you need to have it installed.
What is a .python-version file? Not unique to uv, a .python-version file specifies which Python version should be used for a particular project or directory.
.python-version vs requires-python in pyproject.toml. The former is for development environments, while the latter is for package metadata.
How to change the python version of a uv project. If uv run isn’t using the version of Python you expected or wanted, here is what you can do.

The goal of the handbook is to help you understand the ecosystem of tools used to make Python development easier and more productive. What are some missing topics you’d like to see included?

Comparison of the Two New Typecheckers

Tim Hopper — Wed, 28 May 2025 07:29:00 +0000

At PyCon 2025’s Typing Summit, participants saw the first demonstrations of Meta’s Pyrefly and Astral’s ty, two new Python type checkers with significant speed and analysis improvements.

Edward Li helpfully took notes and provided a right-up.

Here are some takeaways:

Both tools show substantial speed gains
- Pyrefly claims up to 1.8 million lines/sec (35× faster than Pyre, 14× faster than MyPy/pyright), while ty benchmarks show it running 2–3× faster than Pyrefly on real-world codebases.
The tools differ in their approach to type inference

Pyrefly: Meta's New Type Checker for Python

Tim Hopper — Wed, 30 Apr 2025 14:45:00 +0000

Meta has announced Pyrefly, a new static type checker built in Rust to deliver fast performance and scalability for large Python codebases.

While inspired by Meta’s earlier tool Pyre, Pyrefly is not a rewrite: it’s a clean-slate implementation with a new type inference engine, a custom incremental computation model, and cross-platform support.

Despite the maturity of tools like mypy, pyright, and Pyre, Meta found that scaling static analysis across massive codebases required a faster, more flexible foundation. Pyrefly is designed to deliver instant IDE feedback with strong type inference.