CPython’s Experimental JIT in Python 3.15

sumit mishra — Fri, 28 Aug 2026 11:22:37 +0000

Python’s JIT compiler has been experimental since Python 3.13, but Python 3.15 is an important step in its development. The first release candidate, Python 3.15.0rc1, was released on August 4, 2026, with the final release expected in October. The main change is not simply the presence of a JIT, but a substantial improvement in how it observes and optimizes Python code.

A New Tracing Frontend

The 3.15 JIT now uses a new tracing frontend that records the execution paths a program actually takes. This gives the compiler better information about which operations are important and which paths should be optimized. Earlier versions had more limited information about the code being executed. The improvement itself is not the main performance gain, but it provides a better foundation for the optimizations that follow.

Better Use of CPU Registers

One of the more practical improvements is basic register allocation. Earlier JIT-generated code moved many intermediate values through memory between operations. Python 3.15 can keep some of these values in CPU registers across multiple operations instead. This reduces unnecessary memory traffic and is particularly useful for code with repeated arithmetic and other tight loops.

Less Reference-Counting Overhead

Reference counting is an important part of CPython's memory-management system, but it also creates work for the CPU. The new JIT can remove some reference-count operations when it can prove that they are unnecessary. This allows compiled code to spend more time doing the actual work rather than repeatedly maintaining object lifetime information.

Faster Numeric Operations

The JIT also introduces in-place optimizations for some int and float operations. When the compiler can determine that an object is not being referenced elsewhere, it can avoid creating another object for every operation. This is particularly useful in numeric loops where the same values are updated repeatedly.

Early Performance Results

The current pyperformance results show roughly 8–9% geometric-mean improvement on x86-64 Linux and around 12–13% on AArch64 macOS, compared with the corresponding non-JIT interpreter configurations. These numbers are useful indicators of progress, but they should not be read as a general claim that every Python program will become 10% faster. The actual effect depends heavily on the workload.

The JIT Is Still Experimental

Despite these improvements, the JIT is still disabled by default. It is intended for experimentation and benchmarking rather than being something most production applications should enable without testing. Some of its interfaces are also explicitly marked unstable, which reflects the fact that the implementation is still evolving.

The Bigger Question: PEP 836

The technical progress is only half of the story. On June 8, 2026, the Python Steering Council paused new JIT development on CPython's main branch and asked the developers to present a formal plan for the project's future. This resulted in PEP 836, “JIT Go Brrr: The Path to a Supported JIT Compiler for CPython.” The proposal describes a multi-release roadmap with measurable performance targets, including a proposed 20% geometric-mean improvement on the pyperformance suite for JIT plus free-threading by Python 3.17.

Where It Stands in August

As of August 2026, PEP 836 is still under discussion rather than being a settled decision. That makes the current state of CPython's JIT unusually interesting: the implementation is considerably more capable than it was in its early releases, while its long-term place in CPython is still being decided.

For now, Python 3.15 looks less like the moment when “Python gets a JIT” and more like an important experiment in whether a JIT can become a reliable part of CPython's execution model.

Python 3.15 Release Highlights

sumit mishra — Thu, 27 Aug 2026 11:23:29 +0000

Python 3.15 has reached Release Candidate 1, and the final release is expected on October 1, 2026.

I went through the changes and tried to summarize the ones that seem most relevant for everyday Python development without going through all the PEP numbers.

Faster startup with lazy imports

Python 3.15 introduces lazy imports, which means some modules can be loaded only when they are actually needed instead of being loaded immediately.

This could help applications and CLI tools that spend a noticeable amount of time importing modules before doing any actual work.

UTF-8 becomes the default

UTF-8 is becoming the default encoding, which should reduce encoding-related problems, especially when code is running on different operating systems.

This should make situations where something works on one computer but fails because of a different system encoding less common.

Built-in immutable dictionaries

Python 3.15 adds a built-in frozendict-style immutable mapping.

Similar to how a tuple provides an immutable alternative to a list, this gives Python developers a standard way to work with dictionaries that cannot be modified.

JIT improvements

The JIT compiler continues to improve in Python 3.15.

Early benchmarks show performance improvements in some workloads, including roughly 8–9% on Linux and larger improvements in some Apple Silicon tests.

These numbers will obviously depend on the workload, so I would wait for more benchmarks before making broader conclusions.

New profiler: Tachyon

Python 3.15 also introduces Tachyon, a new sampling profiler designed for very low overhead.

It can sample running programs at very high frequencies and can also be attached to an already-running process.

This could be useful for finding performance problems without having to restart an application with a profiler attached from the beginning.

Some terminal improvements

The interactive Python experience is getting a few smaller improvements, including colored error messages and prompts.

The sqlite3 command-line interface also gets SQL keyword completion.

Free-threaded Python is still opt-in

Python 3.15 does not make the no-GIL/free-threaded build the default.

It is still something you have to explicitly use.

However, free-threaded Python is becoming more mature, including improvements to ABI support that should make it easier for C extension developers to support it.

Overall, Python 3.15 doesn't look like a release that completely changes how Python is written. Most of the changes are focused on performance, tooling, and improving some long-standing parts of the language.

Since this is already RC1, the major feature set should be mostly locked and the remaining work should mainly be bug fixes and final polishing.

Has anyone here been testing the Python 3.15 beta or RC?

I'm especially interested in whether lazy imports have caused compatibility problems with existing projects.

DEV Community: sumit mishra