The Python ecosystem is undergoing a significant moment of reflection following a major architectural decision by the Python Steering Council. The experimental just-in-time (JIT) compiler, introduced to CPython to accelerate execution speeds, is being systematically removed from the reference implementation’s mainline codebase.

This decision follows the formal withdrawal of Python Enhancement Proposal (PEP) 836 by its authors, Brandt Bucher and Savannah Ostrowski, after they missed critical formalization deadlines and failed to satisfy the Steering Council’s rigorous demands regarding long-term maintenance, tool compatibility, and demonstrable performance gains.

While the removal marks a temporary setback for native JIT integration in standard CPython, it underscores the uncompromising standards required to alter the world’s most popular dynamic programming language. The path forward for Python performance remains active, but future efforts will face an exceptionally high bar for inclusion.

Main Facts: What Happened to the CPython JIT?

The core narrative centers on the lifecycle and ultimate rejection of CPython’s experimental JIT compiler.

• The Decision: The Python Steering Council is removing the experimental JIT from CPython’s mainline repository. This follows a formal pause on JIT development initiated by the council in June 2026.
• The Catalysts: The removal was triggered by the withdrawal of PEP 836 on October 19. The proposal failed to meet the council’s requirements regarding sustainability, integration with debugging and profiling toolchains, and objective performance metrics.
• The Authors’ Stance: Maintainers Brandt Bucher and Savannah Ostrowski chose to withdraw the proposal, citing a lack of personal bandwidth to carry the current version forward against the council’s stringent expectations.
• Future Outlook: The withdrawal does not permanently kill the code. Other developers remain legally and technically free to fork or continue the work in alternative builds, though reintegrating it into mainline CPython will require meeting the same rigorous governance standards.

Chronology: A Timeline of the JIT Experiment

Understanding how CPython arrived at this juncture requires examining the sequence of events that shaped the JIT’s brief history within the reference implementation.

The Genesis: PEP 744 and Initial Integration

The journey toward a native CPython JIT began in earnest with the drafting of PEP 744 by Brandt Bucher and Savannah Ostrowski. This foundational document introduced the technical mechanics of the JIT, outlining how CPython could translate bytecode into native machine code on-the-fly. The community welcomed the initiative, as it represented a long-sought-after paradigm shift for a language traditionally known for interpretative overhead rather than raw execution speed.

The Halt: June 2026

As the experimental JIT code matured within the development branches, questions regarding its long-term viability began to mount. Recognizing that unvetted experimental features risked destabilizing the entire CPython ecosystem, the Python Steering Council stepped in. In June 2026, the council formally paused all ongoing work on the JIT. They mandated that a formal Python Enhancement Proposal must be submitted and approved, explicitly detailing how the JIT would be maintained, supported, tested, and integrated into the broader Python tooling ecosystem before any further mainline development could proceed.

The Pushback: PEP 836 and Council Skepticism

In response to the council’s demands, Bucher and Ostrowski drafted PEP 836, titled "JIT go brrr: The path to a supported JIT compiler for CPython." However, the proposal immediately hit turbulence during the review process.

The Steering Council found that PEP 836 suffered from critical informational gaps:

• It lacked concrete plans for long-term maintenance by the core team.
• It failed to provide robust strategies for how the JIT would interact with standard CPython debugging and profiling tools (such as gdb, perf, and various third-party profilers).
• It presented performance benchmarks that the council deemed overly optimistic, noting that real-world speedups were localized rather than systemic.

The Withdrawal: October 19, 2026

Faced with mounting requirements and limited developer resources, the JIT’s champions made the difficult decision to step back. On October 19, 2026, PEP 836 was officially withdrawn. Savannah Ostrowski addressed the community on the official Python discourse forums, noting that while they still believed in the architectural direction—including free-threaded support and a method-based front end—they simply lacked the institutional bandwidth to satisfy the council’s high threshold for integration.

Supporting Data: Performance Realities vs. Expectations

The friction between the JIT’s proponents and the Steering Council largely boiled down to a data-driven disagreement over cost versus benefit.

Measurable, But Narrow, Speed Improvements

Proponents pointed to the raw capability of translating Python bytecode into machine instructions as a monumental step forward. However, empirical testing revealed that the performance delta varied wildly depending on the workload:

• Tight Loops: Programs characterized by long-running, CPU-bound numerical loops saw measurable, albeit modest, performance improvements.
• General Applications: For standard I/O-bound, web-based, or heavily object-oriented applications—which make up the vast majority of Python use cases—the performance gains were negligible to nonexistent.

The Maintenance Tax

Introducing a JIT compiler is not a one-time code injection; it represents a permanent maintenance tax on every core developer working on CPython. Every time the CPython interpreter’s internal data structures, frame evaluation loops, or garbage collection mechanics change, the JIT must be updated to match.

The Steering Council evaluated this ongoing engineering cost against the narrow performance gains and concluded that the trade-off was unfavorable. Without assurances that a dedicated, well-funded team would shoulder this burden indefinitely, the risk of technical debt outweighed the incremental speed benefits.

Official Responses and Community Reactions

The decision sent ripples through the global Python developer community, drawing commentary from core maintainers, performance engineers, and alternative runtime advocates.

Statements from the Maintainers

Reflecting on the withdrawal of PEP 836, Savannah Ostrowski maintained an optimistic outlook on the underlying technology while acknowledging the realities of open-source governance:

"The Steering Council rightly sets a high bar for a proposal of this scope, and we don’t feel we have the personal bandwidth to carry the current version forward. We continue to believe in the technical direction outlined in the PEP, including free-threaded support and a method-based front end, and remain optimistic about the JIT’s potential in CPython."

The Steering Council’s Perspective

The Python Steering Council operates under a conservative philosophy designed to protect the stability and reliability of a language used by millions of enterprises, scientists, and educators worldwide. For the council, introducing a native JIT is fundamentally different from adding syntactic sugar or minor standard library modules. A broken JIT introduces silent calculation errors, segmentation faults, and debugging nightmares that can undermine trust in the entire ecosystem. By halting the JIT, the council reaffirmed its role as the ultimate steward of stability over experimental velocity.

Implications: What This Means for the Future of Python Performance

The removal of the experimental JIT does not mean that Python’s pursuit of speed is dead. Rather, it redirects attention toward alternative performance initiatives and clarifies the boundaries of what CPython is willing to adopt.

1. Alternative Implementations and Third-Party Projects

The failure of the mainline CPython JIT mirrors historical trends in the Python ecosystem. Alternative runtimes have long tackled the JIT problem with varying degrees of success:

• PyPy: Utilizing a highly optimized tracing JIT, PyPy routinely speeds up pure Python code by an order of magnitude or more. However, PyPy continues to struggle with full compatibility for complex C-extensions (such as NumPy, Pandas, and PyTorch), which limits its drop-in viability for the data science and machine learning communities.
• CinderX and Other Add-ons: Meta’s CinderX and similar enterprise forks provide JIT capabilities tailored to specific production environments. These projects demonstrate that JITs can work for Python, but they require massive corporate backing and bespoke infrastructure to maintain.

2. The Success of the Adaptive Interpreter

While the native JIT stumbled, CPython’s core team has successfully delivered other performance wins that require zero code modifications from end users.

• Introduced in Python 3.11, the adaptive interpreter uses specialized bytecode and inline caching to accelerate execution paths dynamically.
• Subsequent releases (such as Python 3.12 and 3.13) have continued to refine this approach, yielding double-digit performance gains across standard benchmarks without the massive architectural complexity or maintenance overhead of a traditional JIT compiler.

3. A High Bar for Future Proposals

The primary takeaway for future contributors is clear: getting a major architectural feature into CPython requires more than proof-of-concept code. Future proposals must provide exhaustive documentation on:

• Toolchain Integration: Seamless compatibility with debuggers, profilers, and memory analyzers.
• Long-Term Ownership: Sustainable maintenance plans backed by dedicated engineering resources.
• Generalized Benchmarks: Performance improvements that benefit a wide cross-section of Python programs, rather than narrow edge cases.

Conclusion

The removal of the experimental JIT from CPython is a classic example of open-source governance prioritizing long-term health and maintainability over short-term headline features. While disappointed developers will miss the theoretical speedups of a native JIT, the Python ecosystem remains robust, fast-evolving, and deeply committed to performance improvements via safer, more integrated avenues like the adaptive interpreter. The door remains open for future JIT innovators, but they now know precisely how high the bar has been set.