Python 3.15 Preview: Upgraded JIT Compiler

Set Up a Python 3.15 Build With the JIT Compiler

To follow along, you’ll need a pre-release of Python 3.15 with the JIT compiled in. At the time of this writing, the latest pre-release is 3.15.0b2. Once you have a JIT-capable build, you’ll opt into the JIT at runtime by setting the PYTHON_JIT environment variable to 1.

The JIT has shipped in the official Python installer on Windows and macOS since Python 3.14, so the Windows and macOS installers from python.org include it without any manual configuration step.

A handy path to a JIT-capable build is to use pyenv, which accepts the JIT configure flag through an environment variable. If you have pyenv installed, then you can run the following commands:

$ exportPYTHON_CONFIGURE_OPTS="--enable-experimental-jit=yes-off"
$ pyenvinstall3.15.0b2

With these commands, pyenv builds and installs Python 3.15.0b2 with the JIT included but switched off by default with the yes-off value. You can enable the JIT manually with PYTHON_JIT=1. If you’ve never installed a Python pre-release before, the guide How Can You Install a Pre-Release Version of Python? can walk you through the process.

$ ./configure--enable-experimental-jit=yes-off
$ make-j

With the 3.15.0b2 build in place, you can confirm that the JIT is active by checking sys._jit.is_enabled() with and without PYTHON_JIT set:

$ pyenvshell3.15.0b2

$ python-c"import sys; print(sys._jit.is_enabled())"
False
$ PYTHON_JIT=1python-c"import sys; print(sys._jit.is_enabled())"
True

In this example, you run the same one-liner twice—once without the environment variable and once with it. The sys._jit namespace is an experimental implementation detail signaled by the leading underscore, and it may change between minor releases. Treat any code that reads it as throwaway debugging code rather than production introspection.

If the command with PYTHON_JIT=1 still prints False, then the JIT wasn’t compiled into this build. Recheck your configure flags or fall back to the python.org installer.

Before you spend time building 3.15, it’s worth knowing that the JIT’s long-term future is under active discussion: the Python Steering Council recently paused new JIT development. The compiler still ships in 3.15 and keeps receiving bug and security fixes, and you’ll find the full story in Decide Whether to Enable the JIT at the end of this tutorial.

Run a Quick JIT Benchmark

Before diving into what’s new in 3.15’s JIT, you can see the speedup in action. The following quick_bench.py script runs a tight, float-heavy loop wrapped in timeit, then prints whether the JIT was enabled and the average execution time per repeat:

"""Quick benchmark: compare CPython 3.15 with the JIT off vs on.

Run twice against the same 3.15 build and compare the two timings:

    PYTHON_JIT=0 python quick_bench.py
    PYTHON_JIT=1 python quick_bench.py
"""

importsys
fromtimeitimport timeit

ITERATIONS = 20_000_000
REPEATS = 5

defworkload():
    x = 1.0
    for _ in range(ITERATIONS):
        x = x * 1.0001
    return x

defjit_enabled():
    jit = getattr(sys, "_jit", None)
    return bool(jit and jit.is_enabled())

defmain():
    seconds = timeit(workload, number=REPEATS) / REPEATS
    label = "JIT on" if jit_enabled() else "JIT off"
    print(f"{label}: {seconds:.2f} s")

if __name__ == "__main__":
    main()

In this script, you wrap workload() in timeit() and average across REPEATS runs. The function is intentionally minimal and runs a tight loop that multiplies a float by a small constant. That operation is where the new JIT’s float optimization pays off, because the JIT can reuse the same float object across iterations instead of allocating a fresh one each time.

You can run the script twice against the same Python 3.15 build, toggling PYTHON_JIT each time:

$ PYTHON_JIT=0pythonquick_bench.py
JIT off: 1.54 s

$ PYTHON_JIT=1pythonquick_bench.py
JIT on: 0.96 s

You have two numbers from the same machine and the same build: JIT off versus JIT on. In this example, dividing 1.54 by 0.96 gives about 1.6, so the JIT-on run is roughly 1.6 times faster than the JIT-off one. Cool!

Click the Run button below to watch the JIT-off and JIT-on timings race through the same loop:

Note that this is a best-case workload because the loop is small, tight, and numeric. Most real-world Python code looks nothing like this, so the speedup you see will land much closer to the pyperformance geometric mean of 8–9 percent than to the 1.6-times speedup you just measured.

Understand the JIT-Powered Speedup

Now that you’ve seen the JIT speed up a tight loop, you can explore what’s actually doing the work in 3.15. Python 3.13 introduced the JIT as a stripped-down proof of concept. Python 3.14 widened the platform support and shipped it in the official installers. Python 3.15 is the release where the optimizer itself gets serious upgrades.

The optimizer is the part of the JIT that reworks the code it records to make it run faster. Improving it speeds up many different kinds of programs. The Upgraded JIT compiler section of the Python 3.15 documentation lists each change with its tracking issue.

The reported aggregate performance gains, all preliminary at 3.15 beta, are the following:

• About 8–9 percent geometric mean over the standard CPython interpreter on x86-64 Linux
• About 12–13 percent geometric mean over the tail-calling interpreter on AArch64 macOS

Benchmark suites summarize results with a geometric mean rather than a plain arithmetic average because each benchmark contributes a speedup ratio. The geometric mean is the right way to average ratios, since it keeps a single extreme result from dominating the overall figure.

The 3.15 documentation is explicit that these numbers may shift before the final 3.15 release in October, so it’s best to treat them as a moving target.

In the following sections, you’ll walk through each user-visible upgrade that 3.15 has made to the JIT compiler, grouped into three areas: the code the JIT can trace, the machine code it emits, and the redundant work it now skips.

Trace More of Your Code

Before the optimizer can speed anything up, the JIT has to trace your code and keep it in compiled form, so the more bytecode and control flow the frontend follows, the less often your program drops back to the slower interpreter loop. The following two upgrades widen what the JIT can capture in the first place.

Emit Tighter Machine Code

The following two upgrades improve the quality of the machine code the JIT produces, rather than how much code it covers. One determines where values live, in fast CPU registers or slower memory. The other sharpens which instructions get emitted, so each compiled trace ends up smaller and quicker to execute.

Skip Redundant Work

A hot loop runs the same code over and over, so the interpreter does the same work on every pass. The three upgrades in this section let the JIT skip the following repeated work: recomputing values that never change, updating reference counts it doesn’t need to, and, where it’s safe, creating a new object for every result.

Benchmark With the Official pyperformance Suite

The quick benchmark at the beginning of this tutorial gave you an idea of the speedup on a tight numeric loop. For a fuller picture across realistic workloads, you can point your build at the canonical pyperformance suite, which is pip-installable.

Note that the full suite will take 30 to 60 minutes to complete on an average laptop. If that’s too long to wait, then skip ahead to the end of this section, where you’ll find live results from the core developers’ continuous benchmarking dashboard.

You can install pyperformance into your 3.15 environment and run it once with the JIT off and once with it on, saving the raw results to JSON:

$ python-mpipinstallpyperformance
$ PYTHON_JIT=0pyperformancerun-ojit-off.json
$ PYTHON_JIT=1pyperformancerun-ojit-on.json
$ pyperformancecomparejit-off.jsonjit-on.json

In this example, you install pyperformance, capture two JSON files with the timing data, and ask pyperformance compare to diff them. The compare step prints a table of per-benchmark deltas and a geometric mean at the bottom. That geometric mean is what the core developers quote when they report the 8–9 percent figure.

$ PYTHON_JIT=0pyperformancerun\
-p~/.pyenv/versions/3.15.0b2/bin/python-ojit-off.json

If you’d rather skip the local run entirely, then the same data is published in two places:

• doesjitgobrrr.com hosts a live dashboard with per-day runs across hardware and build configurations.
• faster-cpython/benchmarking-public commits raw pyperformance JSON, Markdown comparison tables, and violin plots straight into the repository.

Both sources stay current with the in-development 3.15 builds, so you can see how the numbers move week to week as the optimizer changes land.

Decide Whether to Enable the JIT

Now that you’ve seen the optimizer upgrades and the benchmarks, the practical question is whether to turn the JIT on for your own workloads. The table below summarizes where the JIT helps the most:

As a pragmatic rule of thumb, turn the JIT on for CPU-bound batch jobs, and leave it off for production web services until the optimizer stabilizes.

The JIT is still flagged as experimental, the numbers still shift between pre-releases, and the sys._jit interface is explicitly marked as non-public. None of that is a reason to avoid the JIT, but it’s a reason to keep a PYTHON_JIT=0 rollback handy.

The pause halts new optimizer work, not the JIT you already have—everything you measured here still runs in 3.15 and keeps receiving fixes. The open question is how much further JIT development goes, not whether it works today.

Conclusion

Python 3.15 adds another round of JIT improvements, this time focused on the optimizer itself. A new tracing frontend, basic register allocation, tighter codegen, more constant propagation, fewer reference counts, and in-place numeric ops all stack together. The result is an 8–9 percent pyperformance geometric mean on x86-64 Linux and 12–13 percent on AArch64 macOS, with float-heavy loops seeing much more.

In this tutorial, you’ve learned that:

• The Python 3.15 JIT is opt-in, and you turn it on by setting PYTHON_JIT=1.
• The tracing frontend records real execution paths, and the optimizer handles more bytecode operations than before.
• Register allocation keeps values in CPU registers, and better codegen trims the emitted machine code.
• Reference-count elimination and in-place arithmetic give the biggest gains on float-heavy loops.
• On x86-64 Linux, the official pyperformance suite measures an 8–9 percent geometric mean speedup.

The JIT is still experimental and a moving target until the 3.15 final release. However, if you have CPU-bound Python code, then this is a good release to start benchmarking your own workloads. Real Python’s Profiling Performance in Python course can help you find the functions that dominate your runtime, so you know exactly where the JIT will help most.

Frequently Asked Questions

Now that you have some experience with the upgraded Python 3.15 JIT, you can use the questions and answers below to check your understanding and recap what you’ve learned.

These FAQs are related to the most important concepts you’ve covered in this tutorial. Click the Show/Hide toggle beside each question to reveal the answer.