For years, Python’s JIT compiler was a running joke. “It’s slower than the interpreter!” critics would say — and they were right. Python 3.13 shipped with an experimental JIT that often underperformed the standard interpreter. 3.14 tried to fix this with a tail-calling interpreter, but Windows x86-64 had its own problems. The Faster CPython team lost funding. The future of Python’s JIT looked uncertain.
Then something changed in 2026. In March, Ken Jin — the core developer behind Python’s JIT efforts — posted an update that surprised everyone: the JIT was not just back on track, it was 11-12% faster on macOS AArch64 and 5-6% faster on x86-64 Linux. And it happened months ahead of schedule.
Here’s the full story of what happened, what the benchmarks actually mean, and whether you should care about Python’s JIT in 2026.
Page Contents
The Backstory: When Python Got a JIT
Python’s JIT journey started with the Faster CPython project, funded by Microsoft and later other sponsors. The goal was ambitious: add a tracing JIT compiler to CPython that could speed up Python code without the complexity of something like PyPy.
Python 3.13 (October 2024) shipped with the first experimental JIT — but it was opt-in, only enabled when building CPython with --enable-experimental-jit. And the results were… disappointing. In many cases, the JIT was actually slower than the standard interpreter.
Then came Python 3.14 with a new approach: the tail-calling interpreter. Instead of a traditional JIT that compiles Python bytecode to machine code, this interpreter used a clever trick — it used musttail (a compiler hint on x86-64 and AArch64) to implement interpreter-level tail calls. This meant the interpreter loop itself ran faster, without needing complex bytecode compilation.
The tail-calling interpreter shipped enabled by default on Windows 64-bit in Python 3.15 alpha builds. But it had a rocky start — especially on Windows x86-64, where a bug caused crashes and poor performance. Ken Jin eventually fixed this, but the damage to perception was done.
Q1 2026 Benchmarks: What the Numbers Actually Mean
The March 2026 update from Ken Jin on the Python Insider blog showed geometric mean benchmarks comparing Python 3.15 alpha JIT builds against the standard interpreter:
| Platform | Performance vs. Standard Interpreter |
|---|---|
| macOS AArch64 (Apple Silicon) | 11-12% faster than tail-calling interpreter |
| x86-64 Linux | 5-6% faster than standard interpreter |
But here’s the important nuance: these are geometric means across the pyperformance benchmark suite. The actual range is staggering — from roughly 20% slowdown to over 100% speedup depending on the workload. Some code gets significantly slower, other code doubles in speed.
As Ken Jin himself noted: “I cannot overstate how tough this was. There was a point where I was seriously wondering if the JIT project would ever produce meaningful speedups.”
The community effort is what turned things around. After the Faster CPython team lost its main sponsor in late 2025, Ken Jin raised the idea of community stewardship. At a CPython core sprint in Cambridge, the JIT team wrote a plan for 5% faster JIT by 3.15 and 10% by 3.16.
They exceeded the goal on macOS AArch64 — hitting 11-12% — months ahead of schedule.
The Tail-Calling Interpreter: Why It Matters
The key breakthrough wasn’t just fixing bugs — it was rewriting the JIT frontend to use trace recording. The initial prototype took 3 days to write, but a month to get it working without test failures. The results were initially 6% slower on x86-64 Linux.
Then a “lucky accident” happened: Ken Jin misinterpreted a suggestion from Mark Shannon, which turned out to be the key insight that unlocked the performance gains. Combined with breaking down complex JIT problems into manageable tasks (each labeled “try optimizing a single instruction”), the team attracted 11 contributors working on converting the interpreter to an easily optimizable form.
The tail-calling interpreter works by replacing the traditional Python interpreter loop — which uses a goto dispatch pattern — with actual tail calls. On platforms that support musttail (x86-64 and AArch64), this allows the CPU’s return stack predictor to work more effectively, reducing branch misprediction overhead.
Practical Implications: When You’d Actually Feel the Speedup
Here’s the honest answer: most Python code won’t see dramatic improvements. The 5-12% gains are measured across the pyperformance benchmark suite, which includes CPU-bound Python code. Real-world applications — especially I/O-bound ones like web servers — won’t see proportional gains.
Where the JIT will help:
- Numeric computation — NumPy-heavy code, data pipeline transformations, list comprehensions doing arithmetic
- Recursive algorithms — Tree traversals, graph algorithms, divide-and-conquer problems
- Tight Python loops — Code that does significant computation in pure Python without calling into C extensions
- Long-running batch jobs — The JIT’s warmup cost pays off over time
Where it won’t help much:
- Web applications — Dominated by I/O wait, network latency, and C-extension overhead (Django, Flask, FastAPI)
- Short-lived scripts — JIT warmup time may exceed the script’s total runtime
- Code already calling C libraries — NumPy, pandas, TensorFlow operations already run in C
How to Test Your Own Code Against Python 3.15 Alpha
Python 3.15 is scheduled for release in October 2026. Alpha builds are available now. Here’s how to test:
Option 1: Official Alpha Binaries
Download Python 3.15 alpha builds from python.org/downloads. Look for “Python 3.15.0a8” or later. The JIT is enabled by default on supported platforms.
# Check if Python was built with JIT support python3.15 -c "import sys; print(sys.experimental_jit_support)" # Should print: True # Or check the version info python3.15 --version # Python 3.15.0a8
Option 2: Build from Source
# Clone CPython source git clone https://github.com/python/cpython cd cpython # Checkout the 3.15 branch git checkout 3.15 # Configure with JIT enabled (default in 3.15) ./configure --enable-experimental-jit # Build (takes a while) make -j4 # Test ./python -c "import sys; print(sys.version)"
Benchmarking Your Code
import time
def your_function():
# Your code here
total = 0
for i in range(1_000_000):
total += i ** 2
return total
# Warm up
for _ in range(5):
your_function()
# Time it
start = time.perf_counter()
result = your_function()
elapsed = time.perf_counter() - start
print(f"Result: {result}")
print(f"Time: {elapsed:.4f}s")
For more rigorous benchmarking, use the pyperformance package which the CPython team uses for official benchmarks:
# Install pyperformance python3.15 -m pip install pyperformance # Run a specific benchmark python3.15 -m pyperformance run -b json_loads -o jit_results.json # Compare with standard Python python3.14 -m pyperformance run -b json_loads -o interpreter_results.json # Compare the two python3.15 -m pyperformance compare jit_results.json interpreter_results.json
What’s Coming Next
The JIT team has roadmap goals for Python 3.16:
- 10% faster JIT on x86-64 Linux (up from 5-6% in 3.15)
- Free-threading support — proper JIT optimization for Python’s free-threaded builds (no GIL)
- Better warmup time — reducing the JIT’s startup/cold-start penalty
The free-threading goal is particularly significant. Currently, the JIT doesn’t properly support Python’s experimental free-threaded builds (enabled with --disable-gil). That’s the next major frontier.
Summary
- Python’s JIT went from “often slower than the interpreter” (3.13) to 11-12% faster on Apple Silicon and 5-6% faster on Linux in 3.15 — months ahead of schedule
- The turnaround was driven by community stewardship after the original sponsor withdrew funding
- The key technical change was rewriting the JIT frontend with trace recording
- Practical gains vary wildly: 20% slowdown to 100% speedup depending on workload
- Web apps and I/O-bound code won’t see much benefit; numeric/recursive Python code will
- Free-threading JIT support is the next major goal for 3.16
