Python 3.14 vs Python 3.15 – performance testing

The performance of Python 3.14.8 and Python 3.15.0 was compared on computers with the AMD Ryzen 7000 series and the 13th-generation of Intel Core processors for desktops, laptops or mini PCs. Both interpreters were 64-bit Python builds running on Windows 11. The benchmarks used pyperformance 1.14.0, with pyperf 2.10.0 as the measurement framework.

Interpretation of the results

Each timing below isthe arithmetic mean of the benchmark’s mean execution times across repeated test sessions, with each session weighted equally. Calibration and warmup values are excluded. Performance factors are calculated from these averaged times, rather than by averaging the reported speedup factors. This produces one combined result for each benchmark.

Lower times are better. Python 3.14 serves as the reference. A result of 1.50× faster means that Python 3.15 takes about two-thirds as long, or 33.33% less elapsed time. A result of 1.20× slower means 20% more elapsed time. The “Time change” column shows the percentage change relative to Python 3.14; negative values indicate shorter execution times.

The overall result is the geometric mean of the per-benchmark speedup factors. Each paired benchmark receives equal weight in this calculation, regardless of its execution time. This summarizes performance across the benchmark suite, rather than a prediction of how much faster an entire application will run. Timings are rounded for readability; all calculations use unrounded values.

Blue results indicate shorter execution times, and red results indicate longer execution times. Changes of at least 1.10× are shown in bold. † marks measurements that varied considerably or changed direction between sessions. The magnitude of these averaged results, as well as small differences near parity, should be interpreted with caution. The averaged tables are descriptive; they do not claim statistical significance for every difference.

The identical value of 1.451× in both rows is due to rounding. The calculated values are approximately 1.451413092× for AMD and 1.451321030× for Intel. The benchmark sets contain 122 and 118 tests, respectively, so they are not identical. This result does not imply the same benefit for every application or an advantage for either processor manufacturer.

AMD Ryzen 9 7900 desktop

The AMD system is a desktop with a Ryzen 9 7900 processor, DDR5 RAM and an M.2 PCIe Gen4 NVMe drive.

There are 122 paired benchmarks on this computer. The averaged results give Python 3.15 a geometric mean speedup of 1.451×, equivalent to approximately 31.1% less elapsed time in the normalized suite summary. The median benchmark speedup is 1.184×, showing that the overall average is lifted by a small number of exceptionally large improvements.

The largest gains are in base32_large (134.748× faster), ascii85_large (68.675× faster), base85_large (63.446× faster). The small-input versions of these encoding benchmarks also improve substantially.

The largest clear averaged slowdowns are in base16_large (1.223× slower), base16_small (1.222× slower), regex_effbot (1.222× slower). These regressions are particularly relevant to applications that rely heavily on those operations.

The AMD results were broadly consistent across repeated measurements. Startup without the site module stays close to parity, and logging_silent includes a noisy measurement, so their small or precise changes deserve less weight than the large, repeatable gains.

Units: sec = seconds; ms = milliseconds; us = microseconds; ns = nanoseconds. A common unit is used for both timings within each row. † indicates measurements requiring additional caution.

Performance by benchmark group

The following table summarizes benchmarks carrying the indicated pyperformance tag. Groups may overlap and do not cover every benchmark. The math group contains only three tests; it is not a summary of every numerical benchmark in the suite.

Benchmarks recorded only for Python 3.14 and excluded from the paired comparison: genshi_text, genshi_xml. The supplied data does not establish why these Python 3.15 results are absent.

13th Gen Intel Core Mobile Processor

The Intel system is a mini PC with a Core i3-1315U processor, DDR4 RAM and an M.2 PCIe Gen4 NVMe drive. The i3-1315U is a mobile processor also used in laptops.

There are 118 paired benchmarks on this computer. The averaged results give Python 3.15 a geometric mean speedup of 1.451×, equivalent to approximately 31.1% less elapsed time in the normalized suite summary. The median benchmark speedup is 1.166×, showing that the overall average is lifted by a small number of exceptionally large improvements.

The largest gains are in base32_large (142.255× faster), base85_large (62.619× faster), ascii85_large (56.825× faster). The small-input versions of these encoding benchmarks also improve substantially.

The largest clear averaged slowdowns are in base16_small (1.241× slower), base16_large (1.158× slower), regex_effbot (1.133× slower). These regressions are particularly relevant to applications that rely heavily on those operations.

The Intel measurements were more variable. In particular, the reported gains for pathlib, sphinx, scimark_sor, scimark_sparse_mat_mult and spectral_norm were sensitive to the test session. Some pathlib and thread-pool measurements contain unusually slow samples. Averaging gives a useful combined view, but those individual values should not be treated as precise estimates for another machine.

Units: sec = seconds; ms = milliseconds; us = microseconds; ns = nanoseconds. A common unit is used for both timings within each row. † indicates measurements requiring additional caution.

Performance by benchmark group

The following table summarizes benchmarks carrying the indicated pyperformance tag. Groups may overlap and do not cover every benchmark. The math group contains only three tests; it is not a summary of every numerical benchmark in the suite.

Benchmarks recorded only for Python 3.14 and excluded from the paired comparison: dask, genshi_text, genshi_xml, sqlalchemy_declarative, sqlalchemy_imperative. The supplied data does not establish why these Python 3.15 results are absent.

Encoding performance improvements

The largest changes form a clear pattern. The averaged base32_large result improves by about 135× on AMD and 142× on Intel. The large Ascii85 and Base85 benchmarks improve by roughly 57-69×, while the corresponding small-input benchmarks improve by approximately 31-41×. These are specialized operations with much larger gains than most of the suite.

This pattern is consistent with the Python 3.15 release notes: the Base32 and Ascii85/Base85 implementations were rewritten in C, and Base64 also received optimizations. These changes provide a plausible explanation for the observed improvements, although these measurements do not isolate the effect of each code change. The benchmarks measure elapsed time, so they do not establish memory savings.

Removing those six benchmarks leaves 116 paired tests on AMD and 112 on Intel. Their geometric mean speedups are 1.203× and 1.197×, respectively – equivalent to about 17% less elapsed time in these normalized summaries. This is a useful additional view for applications that do little Base32 or Base85 processing.

Implications for application performance

The application-tagged group improves by approximately 1.13× on AMD and 1.11× on Intel. Template rendering improves by about 1.20× on both systems. These results suggest worthwhile gains for some Python-heavy workloads, while also showing why a 1.45× suite average should not be applied directly to every application.

Encoding performance is mixed: the large Base32 and Base85 gains coexist with slower Base16 results. Similarly, the regular-expression group has only a small net improvement, while regex_effbot becomes slower on both computers and regex_dna becomes slower on AMD. Startup averages remain close to parity. The practical effect depends on the operations performed by an application.

The official Python documentation also describes the tail-calling interpreter used by Windows 64-bit release binaries. The tested versions record different compiler identifiers. These results compare complete interpreter builds, so individual gains cannot be attributed solely to the JIT, the compiler or a particular interpreter change.

Both computers show almost the same full-suite average, but they use different hardware and have slightly different paired benchmark sets. This does not establish that either processor vendor benefits more.

Measurement notes

The retained measurements contain 20 worker processes per benchmark per session, with 60 timing values for most benchmarks and 200 for each startup benchmark. The combined timings give equal weight to the session means. Outliers are retained, and unavailable benchmarks are excluded rather than assigned an assumed result.

A † marker is applied when the comparison factor changes by more than 10% between sessions, the mean improvement changes to a slowdown or vice versa, or a timing sample set has a coefficient of variation above 25%. This is a descriptive flag chosen for this article, rather than a formal significance test. It helps identify averages whose size (or small direction near parity) is less reliable.