Python 3.15 Enters Feature Freeze as Steering Council Mandates JIT Standards PEP
By Vatsal Shah | June 18, 2026 | 7 min read | Source: Python Official Blog
- Feature Freeze Confirmed: Python 3.15 Beta 1 marks the hard feature cutoff. No new syntax, built-in changes, or standard library additions will be accepted into the 3.15 release branch.
- JIT PEP Mandated: The Steering Council requires a published Standards Track PEP covering JIT support tiers, maintenance commitments, and platform compatibility guarantees before 3.15 goes stable.
- GIL-Free Progress: The free-threaded build (PEP 703) continues to mature in 3.15, with broader third-party library compatibility expected before the October stable release.
Lead Paragraph
REMOTE — The CPython core developer team announced that Python 3.15 has reached its Beta 1 milestone, triggering the official feature freeze for the upcoming release. From this point, the 3.15 branch accepts only bug fixes and documentation improvements, with no new features permitted until the stable October 2026 release. In a companion governance action, the CPython Steering Council issued a directive requiring that a formal Standards Track Python Enhancement Proposal (PEP) be drafted and accepted before Python 3.15 can be designated stable. This PEP must formally define the support guarantees, maintenance windows, and platform tier commitments for the experimental CPython Tier 2 JIT compiler introduced in Python 3.13.
What Happened
Python 3.15 Beta 1 marks the culmination of the development cycle that began after Python 3.14 was released. Key milestones in the 3.15 cycle:
- Beta 1 (Feature Freeze): All new language features, syntax changes, and standard library additions are locked into the release branch.
- JIT PEP Mandate: The Steering Council formally requested that the CPython core team publish a Standards Track PEP defining JIT support before 3.15 stable.
- Free-Threaded Build: The
--disable-gilfree-threaded CPython build continues to evolve, with PEP 703 adding further stability improvements targeting broader ecosystem compatibility. - Release Candidate Timeline: RC1 is expected in September 2026, with the stable October release maintaining the annual cadence.
The CPython JIT: From Experiment to Standard
The CPython Tier 2 JIT compiler was first introduced experimentally in Python 3.13. It operates as an additional optimization layer sitting above the standard bytecode interpreter, selectively compiling "hot" code paths into native machine instructions.
The JIT pipeline operates in two tiers:
Tier 1 — Specializing Adaptive Interpreter (SAI): Python's bytecode is processed by a specializing interpreter that observes runtime type information. When a function is called frequently enough, the interpreter specializes its bytecode operations for the observed types, replacing generic operations with faster type-specific variants.
Tier 2 — Uops JIT Compiler: Once a code region crosses the Tier 1 warmup threshold, the Uops optimizer translates the specialized bytecode into a compact intermediate representation called "micro-operations" (Uops). These Uops are then compiled into native machine code for the host CPU architecture by a copy-and-patch JIT backend.
import sys
class="tok-cm"># Check if the experimental JIT is available in this CPython build
class="tok-kw">def check_jit_status():
version_info = sys.version_info
class="tok-cm"># JIT is available as an opt-in compile flag from Python 3.13+
if version_info >= (3, 13):
class="tok-cm"># Check for the experimental JIT flag in the build configuration
class="tok-cm"># In Python 3.15, this is enabled by default in supported platforms
build_info = sys._base_executable
class="tok-cm"># The JIT compiler status can be queried via the internal API
try:
import _testinternalcapi
jit_enabled = hasattr(_testinternalcapi, &class="tok-cm">#039;get_optimizer')
print(fclass="tok-str">"CPython Tier 2 JIT available: {jit_enabled}")
except ImportError:
print(class="tok-str">"Running in standard CPython without JIT internals access")
else:
print(fclass="tok-str">"Python {version_info.major}.{version_info.minor} predates JIT support")
class="tok-cm"># Demonstrate how the Specializing Adaptive Interpreter warms up
class="tok-kw">def jit_warmup_example(iterations: int = 1000) -> float:
class="tok-str">""class="tok-str">"
Running this function repeatedly triggers the SAI to specialize
on the observed types (int, float), eventually elevating the hot
path to Tier 2 JIT compilation.
"class="tok-str">""
total: float = 0.0
for i in range(iterations):
class="tok-cm"># After ~50 calls, the interpreter specializes BINARY_OP for float+float
class="tok-cm"># After ~100 calls, the Tier 2 JIT may compile this loop to native code
total += float(i) * 1.0001
return total
check_jit_status()
class="tok-cm"># Warm up the JIT by calling the function many times
for _ in range(200):
result = jit_warmup_example()
print(fclass="tok-str">"Final result: {result:.4f}")Why the Steering Council Mandated a JIT PEP
The JIT compiler has shipped across three Python release cycles in an explicitly experimental state. While it shows measurable performance improvements on CPU-intensive workloads, the lack of formal support commitments has created uncertainty for downstream distributors — Linux package maintainers, cloud vendors, and enterprise Python deployments — who need to know whether to enable it by default, how long it will be maintained, and which CPU platforms it covers.
The Steering Council's directive addresses this ambiguity by requiring the PEP to formally define:
| PEP Section | Required Content |
|---|---|
| Support Tiers | Which CPU architectures receive JIT support (x86-64, ARM64, etc.) |
| Maintenance Window | Who maintains the JIT backend and for how long |
| Fallback Behavior | How CPython behaves when JIT compilation fails at runtime |
| Opt-In vs Default | Whether JIT is enabled by default or requires a compile flag |
| Performance SLO | Minimum benchmark improvements required to keep JIT in core |
This is a significant governance moment. A Standards Track PEP requires community review, core developer discussion, and a formal acceptance vote — the same process used to standardize language syntax and major library changes.
GIL-Free Execution in Python 3.15
Alongside the JIT story, Python 3.15 continues to advance the free-threaded execution model introduced by PEP 703.
In the traditional GIL model, even if a Python program spawns multiple threads, only one thread executes Python bytecode at any moment. The Global Interpreter Lock (GIL) serializes all bytecode execution to protect CPython's reference-counted memory model from race conditions.
The free-threaded build (python3.15t) removes this serialization by replacing reference counting with a thread-safe alternative. For AI and data engineering workloads — where multi-threaded NumPy operations, model inference pipelines, and concurrent HTTP clients are common — the free-threaded build offers genuine multi-core CPU utilization. Python 3.15 improves GIL-free support for:
asyncioevent loops running alongside CPU-bound threads- NumPy array operations executing concurrently across threads
- Third-party C extension compatibility via the limited API
What This Means for AI and Data Engineering Teams
For teams building AI orchestration pipelines in Python, the JIT PEP mandate represents a positive governance signal. A formally committed JIT means:
- Predictable Performance Floors: Teams can tune batch inference workloads knowing the JIT will remain active across Python upgrades.
- Stable Deployment Targets: Cloud vendors like AWS Lambda and Google Cloud Functions can enable JIT in managed runtimes without fear of it being quietly removed.
- Complementary to Free-Threading: JIT + GIL-free execution is the long-term Python performance roadmap — both features are now on stable governance tracks.
For the full Python 3.15 stable release analysis and multithreading benchmarks, see: Python 3.15 Stable Release and JIT Multithreading.
What to Watch Next
- JIT PEP Draft Publication: Watch the
python/pepsGitHub repository for the formal Standards Track PEP submission from the JIT working group. Community feedback will shape which CPU tiers get guaranteed support. - RC1 Benchmarks: When Python 3.15 RC1 lands in September 2026, independent benchmark suites (pyperformance) will reveal whether the combined JIT + free-threading changes produce measurable improvements on real-world AI workloads.
- C Extension Compatibility: The free-threaded build's compatibility with popular native extensions (Pandas, Pillow, cryptography) is the remaining barrier to broad adoption — 3.15 RC1 will be the key test.
Read the full release notes on Python Official Blog → blog.python.org
Key Takeaways
- Feature Freeze Locked: Python 3.15 Beta 1 is the hard cutoff. No new language features will enter the 3.15 branch.
- JIT PEP Required: The CPython Steering Council mandates a Standards Track PEP formally defining JIT support tiers, maintenance, and fallback guarantees before 3.15 goes stable.
- Two-Tier JIT: The Tier 1 Specializing Adaptive Interpreter feeds warm code paths to the Tier 2 Uops JIT for native machine code emission.
- GIL-Free Advances: Python 3.15 continues to improve free-threaded execution compatibility with the broader ecosystem.
- October 2026 Stable Target: RC1 expected September, stable release in October, following Python's annual cadence.
