Python 3.15’s experimental just-in-time compiler is showing meaningful progress before the release is finalized. Preliminary alpha measurements reported on March 23, 2026, showed the JIT outperforming its comparison interpreter by about 11–12% on macOS AArch64 and 5–6% on x86_64 Linux.
Those figures are encouraging, but they are not a promise of a universal speedup or evidence that the final Python 3.15 release will behave the same way. The measurements are geometric means from results dated March 17, and individual benchmarks ranged from roughly 20% slower to more than 100% faster. For developers, the update is best understood as a progress report alongside increasingly concrete build and runtime instructions.
What changed in the Python 3.15 JIT
The Python Insider announcement reports that the CPython 3.15 alpha JIT has exceeded its reported performance targets ahead of schedule on the two platforms tested. On macOS AArch64, the JIT was approximately 11–12% faster than the tail-calling interpreter. On x86_64 Linux, it was approximately 5–6% faster than the standard interpreter.
The comparisons are platform-specific and use different baselines, so the percentages should not be treated as a single general Python performance figure. They also describe an alpha implementation rather than a finished compiler that developers can assume will improve every workload.
The benchmark results covered a wide spread. Individual measurements ranged from about a 20% slowdown to more than a 100% speedup, with the unpack_sequence microbenchmark excluded from the reported range. That spread is important: a geometric mean can summarize overall movement across a benchmark set, but it can hide regressions or unusually strong gains in particular operations.
The progress reflects work on a tracing-based frontend, dual dispatch, reference-count elimination, and daily performance testing. The announcement also credits community stewardship as an important part of keeping the project moving. Separately, the CPython planning issue identifies a 5% faster geometric mean as a must-have 3.15 goal and 10% faster as a nice-to-have goal, along with goals for JIT coverage, free-threading, and profiler and debugger support.
The JIT is still experimental
The performance announcement concerns a Python 3.15 alpha. It does not establish final Python 3.15 availability, final release performance, or the default JIT state for every release artifact and distribution.
The planning issue is useful context, but a planned goal is not proof of completion. In particular, it describes free-threading support as a pre-beta goal, while the supplied announcement and supporting account state that the JIT did not yet have proper free-threading support. Developers should therefore avoid presenting free-threading, profiler support, debugger support, or other listed goals as delivered unless later documentation confirms them.
The same caution applies to default behavior. The official CPython JIT documentation describes how to build and control the experimental feature, but the supplied evidence does not establish that it is enabled by default in every Python 3.15 build.
How developers can build and control it
For non-Windows builds, CPython can be configured with:
--enable-experimental-jitWindows builds using the PCbuild system use:
--experimental-jitBuilding the JIT requires a compatible LLVM installation. The official documentation identifies LLVM 21 as the officially supported version and lists clang, llvm-readobj, llvm-objdump, and llvm-dwarfdump among the required tools. Python 3.11 or newer is required to build the JIT.
The documentation provides build paths for Linux, macOS, and Windows. For Windows, PCbuild\build.bat can automatically download LLVM as part of the build process. The documentation also states that end users do not need to install third-party dependencies merely to use a JIT-enabled build; LLVM is needed while building part of the JIT.
Runtime behavior can be controlled with the PYTHON_JIT environment variable. It can enable or disable the JIT, including for builds where the feature is enabled or disabled by default. The documentation also describes LLVM_VERSION for selecting an LLVM version and LLVM_TOOLS_INSTALL_DIR for identifying a particular LLVM installation prefix when multiple installations are present.
What the results mean for developers
Performance-sensitive Python projects may have a reason to begin testing the experimental JIT, particularly if their workloads resemble the benchmarks that benefit from tracing and compilation. However, the reported range makes workload-specific testing essential. A headline geometric-mean improvement does not show how a web service, data-processing job, command-line tool, or long-running application will behave.
Teams should also separate three questions that are easy to conflate:
- Can the JIT be built? Yes, the CPython documentation provides experimental build options and LLVM requirements.
- Does it improve the reported benchmark sets? The March 17 alpha measurements show gains on macOS AArch64 and x86_64 Linux.
- Is it ready to assume for production or final-release planning? The supplied evidence does not establish that. The JIT remains experimental, and final availability, defaults, compatibility, memory behavior, and deployment effects remain undocumented in the supplied sources.
Administrators should be especially careful when comparing environments. The published figures cover only macOS AArch64 and x86_64 Linux, and the supplied evidence does not document the exact hardware, compiler flags, operating-system revisions, or complete benchmark command lines behind the geometric means.
What you should do now
- Use representative workloads. Measure the applications and code paths that matter to your team instead of relying on the aggregate percentages.
- Keep the JIT isolated during evaluation. Treat it as an experimental build and do not assume that the behavior of an alpha build represents the final Python 3.15 release.
- Follow the documented toolchain requirements. For a source build, use the supported LLVM 21 toolchain and the required LLVM utilities, or follow the platform-specific Windows process.
- Test both enabled and disabled modes where appropriate. The
PYTHON_JITenvironment variable provides a documented runtime control for comparative testing. - Track later CPython documentation. Revisit release documentation and subsequent performance reports before making deployment decisions that depend on JIT defaults, free-threading, profiling, debugging, or final compatibility.
Python 3.15’s JIT has moved from an uncertain performance experiment toward a more measurable and documented feature. The current results justify closer testing, but the broad benchmark spread and unfinished project goals mean developers should evaluate it as an experimental optimization rather than a guaranteed release-wide speedup.
