BuildNot yet confirmed elsewhere1 publisher2 min readPublished
In one author's tests, the JIT in a uv-built Python 3.15.0 was off by default; turned on, it sped up a parsing loop 7-8% and a pandas apply 3-4%
Python 3.15.0, released October 9, 2026, ships a JIT that What's New puts at 7-8% on x86-64 Linux and 11-12% on AArch64 macOS. One data-team test on a shared Debian VM reproduced that band only for a pure-Python loop.
The Engineer · Build desk
Four figures: the pyperformance suite ranges from roughly 15% slowdown to over 100% speedup; What's New cites an 11-12% geometric mean JIT gain on AArch64 macOS; the author's row-wise pandas apply takes 1.2 seconds; a 3 to 4% gain would save about 36 to 48 milliseconds per run.
- 15 % slowdown Worst suite result (pyperformance), claim 3 roughly; best is over 100% speedup
- 12 % geometric mean What's New gain, AArch64 macOS, claim 2 upper end of stated 11–12% range
- 1.2 seconds Row-wise pandas apply runtime, claim 10 author: vectorize it instead
- 48 ms saved per run Estimated JIT saving on the apply, claim 15 upper end; estimate is about 36–48
| Figure | Value | Note | Claim |
|---|---|---|---|
| Worst suite result (pyperformance) | 15 % slowdown | roughly; best is over 100% speedup | 3 |
| What's New gain, AArch64 macOS | 12 % geometric mean | upper end of stated 11–12% range | 2 |
| Row-wise pandas apply runtime | 1.2 seconds | author: vectorize it instead | 10 |
| Estimated JIT saving on the apply | 48 ms saved per run | upper end; estimate is about 36–48 | 15 |
What happened
- The JIT is compiled into the uv-managed 3.15.0 build the author tested, but it stays off until PYTHON_JIT=1 is set.
- A row-wise pandas apply gained 3 to 4% with the JIT on, and the author's advice for a 1.2 second apply is to vectorize it.
- On uv 0.12.24, installing "3.15" produced 3.15.0rc3, a release candidate; uv 0.13.0 installed the final 3.15.0.
Why it matters
- decision The suite's spread includes slowdowns, so each service needs its own JIT-on and JIT-off measurement before the flag is set fleet-wide.
- cost At 3 to 4% of a 1.2 second apply, the JIT saves roughly 36 to 48 milliseconds a run, which makes vectorizing the larger lever.
- exposure Any image that resolves "3.15" through an older uv can pin a release candidate, so benchmarks and production builds may not be running 3.15.0.
- constraint The free-threading ABI needs source changes in each extension, so a data team cannot switch on multi-core gains by upgrading the interpreter.
The 7-8% in What's New is a geometric mean over a benchmark suite. The same section gives the spread: pyperformance results run "from roughly 15% slowdown to over 100% speedup", with the mean positive on both platforms [3]. For that mean to transfer to your pipeline, the hot path has to be Python-level loops on x86-64 Linux. The author's parse test is that shape: string splitting and integer conversion in a plain loop, on an Intel Xeon VM [4]. It landed inside the band [7].
The vectorized case is the one most data teams run. The author wrote that "a pipeline whose hot path is already in numpy, pandas or Arrow does not get faster, because the JIT never sees that code" [8]. In our view that follows from what the JIT compiles. Time spent inside native extension code is outside it.
The 3 to 4% on the row-wise apply is the figure to handle with care. The author calls it real [9]. But the VM is shared with other workloads, and each setting got seven fresh processes over two rounds, reported as medians [6]. We would want more rounds on an idle machine before planning around a gap that small.
The write-up's thesis is that the upgrade case sits elsewhere. Those features are PEP 810 lazy imports for startup, the Tachyon sampling profiler and frame pointers on by default for observability, and PEP 829 .start files replacing import lines in .pth files for supply chain [16]. The author says each has a trap the release notes do not spell out, and that all three reproduced on the VM [17]. The text of the write-up we have stops before the lazy-import, Tachyon and .start-file sections. The only trap documented in it is the uv version mismatch.
That one has a cheap check. The author's advice is to run python -VV before trusting anything, and the write-up says the version question matters again in the profiler section [14].
We think the author's ordering holds for teams with vectorized pipelines. Validate the three operations features in staging first. Trial the JIT only on services with Python-level hot loops. The trial costs one environment variable [5].
What to watch
- Whether the lazy-import, Tachyon and .start-file traps the author describes reproduce outside a single Debian 13 VM.
- A rerun of the row-wise apply test on an unshared machine with more rounds, to see whether the 3 to 4% gain holds.
- Which extension maintainers publish abi3t builds, since that gates free-threaded use of numpy-style packages.
Clarity's read
What the record supports and how the coverage leans. The claims behind it follow.
Reality
- Evidence50
- Adoption
- Insufficient
- Hype gap−10
- Incentives
- Insufficient
- Confidence55
Claim ledger
Ranked by verification strength, evidence, and original report placement.
- [2]
The JIT section of What's New cites a "7-8% geometric mean performance improvement" over the standard interpreter on x86-64 Linux, and 11-12% on AArch64 macOS.
- [3]
The pyperformance range is wide, "from roughly 15% slowdown to over 100% speedup", but the geometric mean is positive on both platforms.
- [4]
The author ran everything on one shared VM: 8 vCPU Intel Xeon, 15 GiB RAM, Debian 13, kernel 6.12.
- [5]
The uv-managed Python 3.15.0 build the author used has the JIT compiled in but off by default, turned on with PYTHON_JIT=1.
- [6]
The author timed three workloads in-process, 7 fresh processes per setting, two rounds, reporting medians of repeated fresh processes; the VM is shared with other workloads.
- [7]
The pure-Python parsing loop (string split and int conversion) landed right in the 7-8% band with the JIT on.
- [8]
A pipeline whose hot path is already in numpy, pandas or Arrow does not get faster with the JIT, because the JIT never sees that code, the author wrote.
- [9]
The row-wise pandas apply gained 3 to 4% with the JIT, which the author calls real.
- [10]
The author wrote that the fix for a 1.2 second apply is to vectorize it, not to wait for a JIT.
- [11]
On the author's VM, uv 0.12.24 running uv python install 3.15 installed 3.15.0rc3, not the final release; uv 0.13.0 installed 3.15.0.
- [12]
PEP 803 adds abi3t so Stable ABI extensions can be compiled to be compatible with free-threaded builds; What's New says moving an extension to abi3t "usually requires some non-trivial changes to the source code".
- [13]
The author calls the free-threading ABI a packaging milestone.
- [14]
The author advises checking python -VV before trusting anything if images resolve "3.15" through an older tool, and says the version issue matters again in the profiler section.
- [15]
If the 3 to 4% gain applies to a 1.2 second row-wise apply, the saving is about 36 to 48 milliseconds per run.
- [16]
The author names three operations features: startup (PEP 810 lazy imports), observability (the Tachyon sampling profiler and frame pointers on by default) and supply chain (PEP 829 .start files replacing import lines in .pth files).
- [17]
The author says each of the three features has a trap the release notes do not spell out, and that all of them were hit on the VM.
Sources
1 independent publisher whose own reporting we read for this story.
- dev.toPython 3.15 Is Not a Speed Release for Data Teams. It Is an Operations Release.
1 article · October 12, 2026
Topics and entities
Follow any of these and your For You feed starts watching them — no settings page required.