Python 3.15 Hits Feature Freeze and Other News for June 2026

Beta 1 Marks the 3.15 Feature Freeze

Last month, the eighth and final alpha rolled out as the runway to the beta phase. With Python 3.15.0b1 on May 7 came the feature freeze, which means that from here until the final release of 3.15, the core team works only on bug fixes and polishing.

That makes the beta releases a good moment to step back and look at the headline features of 3.15, which are now locked:

• Explicit lazy imports (PEP 810) for faster startup
• A frozendict built-in (PEP 814) for immutable mappings
• A sentinel built-in (PEP 661), which you’ll dig into below
• Unpacking in comprehensions (PEP 798)
• UTF-8 as the default encoding (PEP 686)
• A stable ABI for free-threaded builds (PEP 803), plus C-API modernization (PEPs 820 and 793) that should make it easier to write C extensions that work across Python versions
• A new sampling profiler in the standard library (PEP 799) for low-overhead profiling

The JIT compiler also gets faster, with the beta announcement citing an 8–9 percent geometric-mean improvement on x86-64 Linux. If you’ve been putting off testing your code against 3.15, then now is the time to get started! The API surface won’t shift under you anymore, and your feedback will help catch regressions before the release candidate phase.

The first round of improvements already landed with beta 2 on June 2, and the next big checkpoint is the release candidate phase on August 4, with the final release expected, as usual, this fall.

A Built-in sentinel Lands in Python 3.15

Here’s the new feature that you’ll likely want to reach for. If you’ve ever needed to tell the difference between a caller passing None and a caller passing nothing at all, then you’ve probably written something like this:

_MISSING = object()

def update(value=_MISSING):
    if value is _MISSING:
        ...  # No value was provided

It works, but it has rough edges. The repr() is an unhelpful <object object at 0x7f...>, the marker can’t be used cleanly in type annotations, and its identity doesn’t survive copying or pickling. PEP 661 replaces the idiom with a new sentinel built-in:

MISSING = sentinel("MISSING")

def update(value: int | MISSING = MISSING) -> None:
    if value is MISSING:
        ...  # No value was provided

The signature is sentinel(name, /, *, repr=None), and the result is a unique truthy object whose default repr() is the name you gave it, so MISSING shows up as MISSING in tracebacks instead of a memory address.

Because the sentinel is its own type, you can drop it straight into annotations like int | MISSING without reaching for Literal. The PEP was first submitted back in 2021, so it’s satisfying to see it cross the finish line.

PEP 829 Graduates From Draft to Accepted

Last month’s roundup featured PEP 829 while it was still a draft. It’s since been accepted for Python 3.15, so the change is now official.

As a quick recap, .pth files in your site-packages directory can do two things:

1. Extend sys.path
2. Run arbitrary code through import lines that Python feeds directly to exec() at startup

That second behavior is a long-standing supply-chain vulnerability, since any installed package can run code the moment the interpreter starts.

PEP 829 – Package Startup Configuration Files starts the deprecation of the code-execution path and introduces a new <name>.start file format that names explicit entry points using the pkg.module:callable form. The directory-extending behavior of .pth files stays, but the import behavior will gradually move to separate .start files.

Other PEP Activity

A few more decisions and one release worth a quick mention:

• Python 3.14.5 shipped on May 10 with roughly 154 bug fixes. Most notably, it makes the incremental garbage collector reversion official, rolling back to the 3.13-era generational collector after reports of memory pressure in production.
• PEP 831 – Frame Pointers Everywhere reached Final status. Compiling CPython with frame pointers enabled by default makes profilers and observability tools like perf produce accurate call stacks, for a modest performance cost. It’s a quiet win if you ever need to figure out where your production Python is spending its time.
• PEP 808 – Including Static Values in Dynamic Metadata was accepted, closing a gap in pyproject.toml where a field had to be either fully static or fully dynamic.
• Several proposals were deferred to 3.16, including PEP 797, PEP 813, PEP 828, and PEP 830. The feature freeze helps to clarify what’s truly ready and what needs more time.

All in all, it was a solid month for the core language, with a mix of new features and hardening work that should make Python more robust and easier to use in the long run.

Pydantic Forks httpx

One of the more closely watched stories this month was the fork of httpx, the popular async-capable HTTP client. Development on the original project had stalled, with pull requests and performance fixes piling up unmerged, and the community started routing around the impasse.

What makes this one interesting is how it played out. A community maintainer first published a fork called httpxyz and wrote up a month-in retrospective. Then Pydantic stepped in to take over stewardship under the httpx2 name, backed by its team and ecosystem.

Rather than start a turf war, the httpxyz author endorsed httpx2 as the “blessed” fork and pledged to rally the community behind it. The httpx2 project has already swapped certifi for truststore, supports zstd-compressed responses out of the box on Python 3.14+ via the standard library, and depends on its own fork of the transport layer, httpcore2.

It’s a reminder that the health of a widely depended-upon library isn’t guaranteed by its popularity. When maintenance stalls, the open-source answer is sometimes a fork, and the graceful part here is watching two maintainers coordinate instead of compete.

The PSF Charts a Course and Honors Its Volunteers

The Python Software Foundation shared its strategic planning work this month, laying out priorities as it navigates a tighter funding environment. If your company ships Python, then it’s a good prompt to ask whether you’re contributing back to the foundation that keeps the lights on.

The PSF also announced this year’s Community Service Award recipients, recognizing the volunteers whose behind-the-scenes work keeps conferences running, working groups staffed, and newcomers welcomed. It’s the kind of labor that rarely makes a changelog but holds the whole community together.

The Django Survey Wants to Hear From You

The 2026 Django Developers Survey is open. These surveys shape how the framework evolves, from which database backends get attention to how the team thinks about async. If you write Django, then spending five minutes here is one of the lowest-effort ways to influence the roadmap.

Pyrefly Reaches 1.0

Meta’s Rust-based type checker, Pyrefly, hit version 1.0 this month. The 1.0 stamp signals that the project considers its core stable enough to depend on, and the headline pitch is speed: a checker fast enough to run on every keystroke.

It’s already the default checker for Instagram’s roughly 20-million-line codebase and is used by PyTorch and NumPy, and pyrefly init converts an existing mypy or Pyright config so you can try it without starting over.

The timing lines up with the typing conversation at PyCon US this year, where the typing summit recap captured an ecosystem that’s increasingly spoiled for choice, with Pyrefly and Astral’s ty both pushing Rust-speed type checking.

Django 6.1 Alpha and Security Releases

Django 6.1 alpha 1 marks the 6.1 feature freeze and opens the testing window, so it’s a fine time to try your project against it and file regressions early.

Separately, the team shipped security releases 6.0.5 and 5.2.14, fixing three low-severity issues. As always with security patches, the boring move is the right one: upgrade promptly even if you don’t think the affected paths apply to you.

Other Notable Releases

A few recent releases across the tooling landscape are worth a look:

• pip 26.1 arrived with support for dependency cooldowns, experimental installs from standard pylock.toml lockfiles, and the end of Python 3.9 support.
• Nuitka 4.1, the Python-to-C compiler, shipped a new release.
• PyPy 7.3.22 landed with new RPython pickle and json encoders that close much of PyPy’s serialization gap with CPython.

Depending on your stack, you might want to check out the release notes for these and other projects to see if there’s anything worth upgrading to or testing against.

AI Goes Bug-Hunting in C Code

This month, developer Daniel Diniz described running a Claude Code plugin that fans out into thirteen parallel agents, each hunting a bug class like reference-counting errors or missing exception checks in Python’s C extensions. LWN also covered the effort.

The result was more than 575 confirmed bugs across roughly a million lines of code in 44 extensions, with fixes already merged into more than a dozen projects, including Cython and Pillow.

Mozilla ran a similar play on its Firefox codebase. Its engineers built an agentic harness around a preview of Anthropic’s restricted Claude Mythos model that could generate and run reproducible test cases, and it surfaced 271 previously unknown Firefox bugs, some latent for well over a decade.

Both bug-hunting projects worked because of the human pipeline wrapped around a capable AI model, including deduplication, triage, and responsible disclosure to maintainers.

Diniz reported a 10–15 percent false-positive rate, which is why you shouldn’t dump raw model output on an open-source maintainer’s issue tracker. Used carefully, though, this can help to improve the C layers that much of Python sits on top of.

Code With Claude and the Agent-Orchestration Push

Anthropic’s Code with Claude 2026 event on May 6 focused on orchestration. The headline additions to Claude Code were multi-agent coordination, automatic CI fixes that push corrections back to a pull request, and remote control to steer a running session from your phone. You can watch the recordings of the talks on the event page linked above.

One interesting practical idea, regardless of which tools you use, is the Advisor pattern. A cheaper, faster model drives the work and calls in a heavyweight model only for the hard reasoning:

Anthropic’s demo paired Sonnet as the driver with Opus as the advisor, reporting frontier-quality output at roughly five times lower cost. As these tools mature, the skill is shifting from writing a good prompt to designing a good workflow.

Pydantic AI v2, PyTorch 2.12, and a New Gemini Flash

There were a few more releases for the AI-adjacent crowd:

• Pydantic AI v2 entered beta with a harness-first redesign built around capabilities that bundle an agent’s tools, hooks, and settings into one composable object. It’s a breaking change: provider extras are no longer installed by default, and the OpenAI integration now defaults to the Responses API. The recommended path is to clear your deprecation warnings on the latest v1 release first, then migrate. If you’ve been following along with our new Pydantic AI course, it’s worth knowing what’s changing.
• PyTorch 2.12 raised its build requirements to CUDA 12.6 and C++20, and changed the default torchrun port from a fixed 29500 to an OS-assigned one for single-node runs that don’t set --master-port, which can silently break scripts that assumed 29500.
• Gemini 3.5 Flash went generally available at Google I/O on May 19. It’s pricier than its predecessor, so benchmark before you swap model strings in a cost-sensitive app.

With the pace of change in AI tooling, it’s worth keeping an eye on the release notes for the models and frameworks you use, since even a minor version bump can include breaking changes or new features you’ll want to adopt.