Python 3.15 Benchmark: JIT Wins 20% on Recursion, Free-Threading 4.5x on Four Threads

A single-developer benchmark published on October 5, 2026 finds that Python 3.15's standard interpreter is "at best a fairly minor improvement over 3.14". Its two clear wins are the experimental JIT, which cut a recursive Fibonacci run from 6.94 to 5.76 seconds, and the free-threaded build, which ran four threads 4.5 times faster than the standard build.

What Grinberg ran

Miguel Grinberg's post calls the test informal. It has two programs: fibo.py, which computes the first 40 Fibonacci numbers by recursion, and bubble.py, which bubble-sorts 10,000 random numbers. Each runs single-threaded and on four threads. The machine is an Intel Core i5 running Gentoo Linux, and each figure is the average of three runs.

He tested CPython 3.10 through 3.15, with JIT and free-threaded variants from 3.13 on, plus PyPy 3.12, Node.js 26.3 and Rust 1.97 as outside reference points.

The numbers

Test	Version	Seconds
fibo(40), 1 thread	3.10	15.9442
fibo(40), 1 thread	3.15	6.9361
fibo(40), 1 thread	3.15 JIT	5.7625
bubble(10000), 1 thread	3.10	3.9918
bubble(10000), 1 thread	3.15	1.9716

Against 3.10, 3.15 is about 2.3 times faster on fibo and about 2 times on bubble sort, computed from those figures. Most of that gain arrived in earlier releases, which is why Grinberg's verdict on the latest step is muted.

1. 3.15 standard build32.54 s
2. 3.15 free-threaded build7.24 s

Source: Miguel Grinberg, How Fast is Python 3.15?, October 5, 2026; Intel Core i5, Gentoo Linux, mean of three runs

On the same four-thread test, bubble sort fell from 8.4514 seconds on the standard build to 4.8549 on the free-threaded one, a 1.74 times gain. The free-threaded build helps most when the work is pure computation spread over threads. Grinberg lists the standard 4-thread fibo run at 0.98 times the speed of a single standard run in his own comparison column, so the threads bought nothing there.

Why the JIT figure is not the JIT team's figure

The 20% single-thread JIT gain on fibo is a best case. A recursive function with small integer arithmetic is the shape of code a JIT handles well.

The JIT team's own numbers are lower. Ken Jin, a volunteer contributor and core member of the CPython JIT team, wrote on March 23 that the JIT was "about 11-12% faster on macOS AArch64 than the tail calling interpreter" and "5-6% faster than the standard interpreter on x86_64 Linux". Both are labelled preliminary geometric means from measurements dated March 17, 2026.

The same post warns that results range from "a 20% slowdown to over 100% speedup (ignoring the unpack_sequence microbenchmark)". A geometric mean of 5 to 6% and a single benchmark at 20% are consistent. Code that is not hot loops can run slower.

What else is in the release

The 3.15 documentation, at release candidate 3 when read, lists lazy imports (PEP 810), unpacking in comprehensions (PEP 798), frame pointers on by default (PEP 831) and the Tachyon sampling profiler (PEP 799). Grinberg says he plans to adopt 3.15 for comprehension unpacking and lazy imports, not for speed.

Neither benchmark covers a framework, a database driver or a data-frame workload. For the Python library side of performance, see our report on Polars 2.0; for another developer-tool story, see Headstart.

What to check before upgrading

Grinberg writes that he does not "feel I'm losing anything by staying on 3.14 for a few more months". The reference points he includes frame the ceiling: PyPy 3.12 ran single-threaded fibo 5.54 times faster than 3.15, and Rust 1.97 ran it 77.24 times faster.

A Python 3.15 final release date was not in the documentation read. Grinberg's numbers are one machine and two toy programs, so rerun your own workload with the JIT on and off before changing a production interpreter.