Python 3.15: JIT is still experimental—what does the new version really bring?

Python 3.15 was released on October 9, 2026, and news reports claim that it introduces a stable JIT compiler that is enabled by default and will speed up programs by about a third. Official documentation says otherwise: JIT remains experimental, is disabled by default, and performance gains range from single digits to the low tens of percent. However, the release itself brings more interesting changes than the headlines might suggest.

What’s Happening with the JIT Compiler

The JIT (Just-In-Time) compiler tracks which parts of a program are executed most frequently and compiles them into the processor’s machine code. Python introduced it as an experimental feature in version 3.13. According to the official documentation, version 3.15 significantly improves it: a new tracing front-end, basic register allocation, and other optimizations have been added.

What Are the Numbers?

According to official results from the pyperformance test suite, the JIT on x86-64 processors running Linux is, on average (geometric mean), 7 to 8% faster than the standard interpreter. On the AArch64 platform under macOS, the speedup is 11 to 12% compared to the interpreter using “tail calls.” This is an average across a number of tests, so a specific program may run faster or slower. We did not find any mention of “20 to 40% for pure loops” or “10 to 15% for web frameworks” in the official documentation.

Is JIT enabled by default?

No. According to available descriptions, JIT is optional in version 3.15 and is enabled via the environment variable PYTHON_JIT=1. The installers from python.org for Windows and macOS have it pre-compiled, while on Linux you need to build Python with the configuration flag --enable-experimental-jit. `

PYTHON_JIT=1 python3 moj_skript.py

`
We did not find the variable PYTHON_DISABLE_JIT mentioned in some descriptions was not found in the documentation. We recommend sticking to the official materials.

A Note on the Future

According to one technical analysis following the release of the 3.15 beta, the Python Steering Committee has suspended further JIT development on the main branch. This information comes from a secondary source, so please verify the status of future development in the official discussions.

What Python 3.15 Actually Brings

• Explicit lazy imports (PEP 810). The new keyword lazy defer the loading of a module until it is first used. This allows programs with a long chain of dependencies to start up faster.
• UTF-8 as the default encoding (PEP 686). This unifies behavior across Linux, Windows, and macOS and reduces issues with text file encoding.
• New built-in types. The following have been added frozendict (PEP 814) and sentinel (PEP 661).
• Unpacking * and ** in comprehensions (PEP 798).
• Frame pointers enabled by default (PEP 831) for better observability at the system level.
• The Tachyon profiler, improved error messages, and REPL.

lazy import json

What This Means for Developers

For most projects, the benefits of this release in day-to-day work will come more from lazy imports, UTF-8, and new types than from the JIT. You can test the compiler on your own workload, but the decision should be based on measurements. For tasks that wait for the network or a database, JIT does not affect the slowest part of the program—this is a general principle, not a claim from a single source.

Changing the default encoding to UTF-8 may affect programs that relied on the previous system setting. Therefore, it’s worth testing your application before upgrading to the new version.

What We Have Not Confirmed

• “Stable JIT, enabled by default.” Official documentation labels it as experimental.
• “Up to a 30% performance boost.” Official figures are 7 to 8% (Linux x86-64) and 11 to 12% (macOS AArch64) on average.
• “100% compatibility with the C API” for JIT. We did not find such a claim in the documentation. Version 3.15 introduces changes to the C API (for example, the new PyBytesWriter interface), so the compatibility of C libraries must be verified.

Conclusion

Python 3.15 is an interesting release, but not because of the “stable JIT” that would speed everything up by a third. JIT is experimental and the performance gains are modest; however, lazy imports, UTF-8, and new built-in types are changes that will affect everyday programs. The most sensible approach is to migrate to the new version with tests, and enable the JIT only where your own measurements support it.