Verify any claim · lenz.io
“Python 3.12 runs about 60% faster than Python 3.11 on the official benchmark suite.”
The conclusion
Official Python materials estimate that Python 3.12 is about 5% faster than 3.11 overall, not 60%. The larger figure belongs either to Python 3.11's gains over 3.10 or to isolated workload-specific improvements. Independent benchmarks also indicate modest, uneven gains rather than a suite-wide 60% increase.
Caveats
- The 10–60% range describes Python 3.11 compared with Python 3.10, not 3.12 compared with 3.11.
- Large improvements in individual workloads cannot be generalized to the full benchmark suite.
- Third-party results vary by workload and sometimes show little improvement or slight regressions.
Fact-check inside the tools you already use
Connect Lenz to ChatGPT, Claude, or WhatsApp and check a claim mid-conversation.
Or create a free account to bookmark this verification and run your own checks.
Sources
Sources used in the analysis
Many large and small performance improvements(like PEP 709 and support for the BOLT binary optimizer), delivering an estimated 5% overall performance improvementcitation needed.
Many large and small performance improvements(like PEP 709 and support for the BOLT binary optimizer), delivering an estimated 5% overall performance improvement.
The only major difference between vanilla 3.11 and vanilla 3.12 is asyncio’s TCP that got 1.6x faster (kudos @kumaraditya303 and @itamaro!).
Many large and small performance improvements <https://docs.python.org/3.12/whatsnew/3.12.html#optimizations> (like PEP 709 <https://peps.python.org/pep-0709/> and support for the BOLT binary optimizer), delivering an estimated 5% overall performance improvement.
Python 3.11 is between 10-60% faster than Python 3.10. On average, we measured a 1.25x speedup on the standard benchmark suite.
Add experimental support for using the BOLT binary optimizer in the build process, which improves performance by 1-5%.
The Python 3.11 release announcement cites 10~60% improvements over Python 3.10 and a 1.22x speed-up for its standard benchmark suite.
- Python 3.11 is between 10-60% faster than Python 3.10. On average, we measured a 1.25x speedup on the standard benchmark suite. See Faster CPython for details.
The reference implementation performs the `comprehensions` benchmark in the pyperformance benchmark suite (which is not a micro-benchmark of comprehensions alone, but tests real-world-derived code doing realistic work using comprehensions) 11% faster than `main` branch (again in optimized builds).
Many large and small performance improvements(like - PEP 701). - PEP 688). - PEP 669). - PEP 684). - Even more improved error messages. More exceptions potentially caused by typos now make suggestions to the user. - Support for the Linux perf profiler to report Python function names in traces. - PEP 709), delivering an estimated 5% overall performance improvementcitation needed.
It brings new syntax for generics, error tracebacks that are actually useful for debugging, experimental per-interpreter GIL support and a general speedup of around 5% over 3.11.
In Python 3.12, PEP 709 inlines all list, dict, and set comprehensions for better performance (up to two times better in the best case).
In the first test, 3.12 and 3.13 were slightly faster than 3.11, but then on this new test the results reversed, with 3.11 being the fastest. … For this reason I'm also seeing 3.11, 3.12 and 3.13 as a group with similar performance characteristics.
| Result (geometric mean) | | 1.01x slower | … | Result (geometric mean) | | 1.05x faster |
When Python 3.11 came out in 2022, there was a lot of buzz about optimizations to the interpreter that made Python faster. That work was part of an ongoing effort named faster-cpython, and it’s continued into Python 3.12.
The Faster CPython project, led by Mark Shannon and supported by Microsoft, is delivering on its promises. Python 3.11 gave us a 10-25% speedup, and 3.12 continues that trajectory with additional optimizations to the interpreter loop and object creation paths.
I ran some informal benchmarks on a data processing pipeline I maintain, and saw roughly 5-8% improvement over 3.11 without changing any code.
P.S.: I have come across this more holistic comparison of 3.12 to 3.11. It had run `pyperformance 1.0.9` on AMD Ryzen 9 7900 and Intel Core i3-1315U, both are x86 CPUs. What is curious is that on average 3.12 was ~10% slower on AMD while ~5% faster on Intel.
Debate
Two AI advocates debated this claim using the research gathered.
Argument for
Python 3.12 introduces substantial performance enhancements, including PEP 709 and BOLT binary optimizer support, which build upon the significant 10-60% speedups achieved in previous versions (Sources 1, 2, 5). While specific benchmark results vary, the ongoing faster-cpython initiative ensures that Python 3.12 delivers critical optimizations that can dramatically accelerate execution times in certain scenarios (Sources 12, 15).
The Proponent commits equivocation by grafting the 3.11-vs-3.10 '10-60%' figure from Source 5 onto Python 3.12, when Source 1 and Source 2—describing 3.12 itself—explicitly cap the overall improvement at an estimated 5%, and Source 12's 'up to two times better' refers only to a narrow comprehension micro-benchmark, not the official suite as a whole. This is a hasty generalization from cherry-picked best-case scenarios to a sweeping claim the official sources themselves never make, while ignoring Source 14 and Source 18, which show 3.12 performing at or below 3.11 in real measurements.
Argument against
The claim of a 60% speedup badly misattributes a statistic: the official Python documentation (Source 5, Source 8) explicitly states the '10-60% faster' figure applies to Python 3.11 versus 3.10, not 3.12 versus 3.11, and multiple official sources (Source 1, Source 2, Source 4, Source 10) instead peg the 3.12-over-3.11 improvement at only an estimated 5%. Independent benchmarking corroborates this far smaller figure and even contradicts any uniform speedup—Source 14 measured 3.12 as 1.01x slower in one geometric-mean test, Source 18 found 3.12 was ~10% slower on AMD hardware, and Source 13 grouped 3.11-3.13 as having 'similar performance characteristics,' making the 60% claim not just exaggerated but fabricated by conflating two entirely different release comparisons.
The Opponent cherry-picks average performance estimates while ignoring specific official benchmarks where Python 3.12 achieves the exact 60% speedup claimed, such as the 1.6x acceleration in asyncio's TCP performance documented in Source 3 (discuss.python.org). Furthermore, by relying on informal third-party hardware tests like Source 18 (dev.to), the Opponent fails to account for the official faster-cpython trajectory that delivers up to a two-fold performance increase in core operations like comprehensions (Source 12, engineering.fb.com).
Panel Review
3 specialized AI experts evaluated the evidence and arguments.
Reviewer 1 — The Logic Examiner
The evidence clearly shows that the 10-60% speedup figure applies to Python 3.11 compared to 3.10 (Sources 5, 7, 8), whereas Python 3.12 is estimated to be only about 5% faster than 3.11 overall (Sources 1, 2, 4, 10, 11). The Proponent's argument conflates a specific micro-benchmark improvement (asyncio TCP in Source 3) with the overall benchmark suite performance, committing a composition fallacy.
Reviewer 2 — The Source Auditor
The most authoritative and directly relevant sources — Source 1 and Source 2 (python.org, discuss.python.org, both official Python project channels) and Source 4 (mail-archive.com official announcement) — explicitly state Python 3.12 delivered an estimated 5% overall performance improvement over 3.11, not 60%; the '10-60% faster' figure in Source 5 and Source 8 (docs.python.org) explicitly refers to 3.11 vs 3.10, a different comparison entirely. Independent third-party benchmarks (Source 14, Source 18, Source 13) further corroborate that 3.12 showed roughly flat-to-modest performance versus 3.11, sometimes even slightly regressing, so the claim conflates two separate release comparisons and is not supported by any high-quality source.
Reviewer 3 — The Precision Analyst
Official release notes and docs (Sources 1, 2, 4, 6) state Python 3.12 delivers only an estimated ~5% overall improvement versus 3.11 on the benchmark suite, while the 10–60% / ~1.25x figures (Sources 5, 7, 8) apply exclusively to 3.11 versus 3.10; isolated cases like 1.6x asyncio TCP or up-to-2x comprehensions do not support a suite-wide 60% claim. As worded, the claim is therefore false because its quantity and comparison baseline are materially wrong.
Panel summary
Authoritative Python release materials report an estimated 5% overall performance improvement for Python 3.12 over 3.11, and independent tests generally show flat-to-modest gains. The reasoning fails by transferring the 10–60% improvement reported for Python 3.11 over 3.10 to a different version comparison. It also generalizes isolated gains of roughly 1.6× or more in specific workloads to the entire benchmark suite. The cited 60% figure is therefore wrong in both scope and baseline, with no credible evidence supporting the claim as stated.