CPython’s Experimental JIT in Python 3.15

Python's experimental Just-In-Time (JIT) compiler has made significant strides in its development, reaching an important milestone with Python 3.15. Released on August 4, 2026, as the first release candidate, Python 3.15.0rc1 marks the beginning of a refined approach to JIT optimization. The final release is anticipated in October 2026.

What sets Python 3.15 apart is not just the presence of the JIT compiler, but a substantial enhancement in how it observes and optimizes Python code. The key improvement lies in the introduction of a new tracing frontend, which records the actual execution paths a program takes. This provides the compiler with more accurate information about which operations are critical and which paths should be optimized.

This advancement builds upon a foundation provided by earlier versions, which had more limited knowledge of the code being executed. The improvement in tracing information is not the primary driver of performance gains, but it lays a solid groundwork for subsequent optimizations.

One of the more tangible improvements in Python 3.15 is the more efficient use of CPU registers. Earlier JIT-generated code often moved many intermediate values through memory between operations, leading to unnecessary memory traffic. With Python 3.15, some of these values can be retained in CPU registers across multiple operations, reducing memory access and proving beneficial for code containing frequent arithmetic operations and tight loops.

Additionally, the new JIT compiler can minimize reference-counting overhead by removing unnecessary reference-count operations when it can prove they are not required. This allows the compiled code to focus more on performing actual computations rather than repeatedly managing object lifetime information.

In terms of numeric operations, the JIT also introduces in-place optimizations for certain int and float operations. When the compiler determines that an object is not referenced elsewhere, it can avoid creating another object for every operation. This is particularly advantageous in numeric loops where the same values are repeatedly updated.

Early performance results from pyperformance tests indicate roughly 8-9% geometric-mean improvement on x86-64 Linux and around 12-13% on AArch64 macOS compared to non-JIT interpreter configurations. While these figures indicate promising progress, they should not be interpreted as a guarantee that every Python program will become 10% faster. The actual impact depends heavily on the specific workload.

Despite these enhancements, the JIT remains disabled by default and is intended primarily for experimentation and benchmarking purposes. It is not recommended for production applications without thorough testing. Some of its interfaces are marked as unstable, reflecting the ongoing evolution of the implementation.

The decision to develop the JIT further was paused in June 2026 by the Python Steering Council, which asked the developers to present a formal plan for the project's future. This led to the creation of PEP 836, "JIT Go Brrr: The Path to a Supported JIT Compiler for CPython." The proposal outlines a multi-release roadmap with measurable performance targets, including a goal of a 20% geometric-mean improvement on the pyperformance suite for JIT plus free-threading by Python 3.17.

As of August 2026, PEP 836 remains under discussion, indicating that the future of CPython's JIT is still being determined. While the current implementation is significantly more advanced than its early releases, its integration into CPython's execution model is yet to be decided. For now, Python 3.15 appears to be an important experiment in assessing whether a JIT can become a reliable component of CPython's execution model.