The experimental just-in-time compiler is being removed from CPython over concerns about maintenance, compatibility, and performance.

The decision to excise the experimental just-in-time (JIT) compiler from the mainline CPython codebase marks a significant turning point in the Python Steering Council’s strategy for language evolution. While the ambition to accelerate the world’s most popular programming language remains a top priority, the removal highlights the rigorous, often uncompromising, standards required to merge major architectural changes into the reference implementation of Python. For the developer community, this move serves as a reminder that technical feasibility is only one component of a successful contribution; long-term sustainability and maintainability are equally critical.

The Rise and Fall of PEP 836

The trajectory of the JIT project within CPython was defined by high expectations and subsequent regulatory hurdles. The initiative, spearheaded by contributors Brandt Bucher and Savannah Ostrowski, began with the promise of bringing native, high-performance execution closer to the standard Python interpreter. The initial proposal, PEP 744, introduced the technical mechanics of the JIT, demonstrating that a specialized compiler could indeed provide speedups in specific, narrow scenarios—particularly those involving tight, long-running loops.

However, the transition from an experimental feature to a supported component of the CPython ecosystem required a shift from "how it works" to "how it survives." This led to the creation of PEP 836. Unlike its predecessor, PEP 836 was designed to address the operational lifecycle of the JIT: how it would be maintained by the core team, its impact on debugging tools, its compatibility with existing C extensions, and its integration with performance profiling suites.

By June 2026, the Steering Council had effectively hit the "pause" button on the project. The Council requested further clarification on the technical debt the JIT would impose. When the formal response—and the accompanying documentation in PEP 836—failed to satisfy the Council’s rigorous criteria for performance predictability and maintenance overhead, the project’s future within the mainline became untenable. On October 19, the proposal was officially withdrawn, signaling the end of the JIT’s tenure in the CPython source tree.

A Chronology of the CPython JIT Initiative

The timeline of the CPython JIT experiment reflects the broader tension between experimental performance features and the stability requirements of a language used by millions.

• Pre-2024: The "Faster CPython" project gains momentum, focusing on iterative, incremental performance improvements rather than radical architecture shifts.
• May 2024: PEP 744 is formally introduced, laying the conceptual groundwork for a JIT compiler in CPython.
• Late 2024 – Early 2025: The JIT code is merged into the experimental branch of CPython, generating excitement among developers seeking to compete with alternative implementations like PyPy.
• June 2026: The Python Steering Council pauses development, citing concerns over long-term maintenance, integration, and the lack of a comprehensive support strategy.
• August – September 2026: Attempts to refine PEP 836 take place, with the maintainers aiming to satisfy the Council’s concerns regarding debugging and profiling.
• October 19, 2026: PEP 836 is officially withdrawn by its authors, citing a lack of personal bandwidth to meet the high standards required by the Steering Council.

Technical Limitations and Performance Reality

One of the primary critiques leveled by the Steering Council was the discrepancy between the perceived performance gains and the actual, measurable impact of the JIT. While the term "JIT" often conjures images of massive speed improvements—as seen in projects like V8 for JavaScript or PyPy for Python—the CPython JIT was significantly more limited in scope.

Performance testing indicated that the JIT provided noticeable benefits only for specific computational patterns. In many real-world, I/O-bound, or complex object-oriented applications, the overhead of the JIT compiler itself often offset the execution time savings. The Council argued that the cost of maintaining the JIT—a massive, complex piece of infrastructure—was not justified by the marginal performance gains observed in the experimental builds. Furthermore, the JIT’s impact on debugging tools meant that developers might face significant hurdles when profiling code, as the compiler could obscure stack traces or interfere with standard instrumentation.

The Broader Landscape of Python Performance

The removal of the JIT does not signal a retreat from the "Faster CPython" initiative. In fact, the core team has been arguably more successful with non-JIT approaches over the last five years. The introduction of the "adaptive interpreter" in Python 3.11, which utilizes type-specialized bytecode to optimize execution paths dynamically, has provided tangible speed improvements across a broader range of applications without requiring the heavy maintenance burden of a full JIT.

Moreover, the ecosystem for high-performance Python remains diverse. PyPy continues to offer an alternative for users who require the speed benefits of a JIT and are willing to accept the compatibility trade-offs—particularly regarding C-extension support. Other projects, such as Facebook’s CinderX, demonstrate that specialized, high-performance forks can coexist alongside CPython, serving as an "experimental laboratory" for features that may one day mature enough to be considered for the mainline.

Official Perspectives and Community Reaction

In her statement regarding the withdrawal of PEP 836, Savannah Ostrowski expressed a pragmatic view of the situation. "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," she noted. Her comments emphasized a continued belief in the technical merit of the project, specifically noting the potential for method-based front ends and free-threaded support.

From the perspective of the Steering Council, the decision was less about the technology and more about the philosophy of language governance. For a language as foundational as Python, "experimental" status can only last so long before it must either become "supported" or be removed to prevent technical stagnation. By choosing to remove the JIT, the Council is effectively clearing the path for more sustainable, lower-risk performance improvements.

Implications for Future Contributions

The withdrawal of PEP 836 establishes a clear precedent for future contributors looking to introduce large-scale changes to CPython. The "high bar" mentioned by the authors is not merely a gatekeeping tactic; it is a defensive measure against the accumulation of unmaintainable code. Future proposals for major performance features will likely be scrutinized against the following criteria:

1. Maintenance Sustainability: Who will be responsible for the code three, five, or ten years from now?
2. Tooling Integration: Does the feature break existing debuggers, profilers, or static analysis tools?
3. Measurable Impact: Are the performance gains substantial enough to justify the complexity, or are they limited to niche, artificial benchmarks?
4. Compatibility: How does the change affect the vast library of existing C extensions that define the Python ecosystem?

Conclusion

The removal of the experimental JIT from CPython is a sobering but necessary chapter in the language’s development. It reinforces the fact that Python’s strength lies not just in its speed, but in its reliability and the predictability of its environment. While the JIT project in its current form has ended, the lessons learned regarding adaptive interpretation, bytecode optimization, and the constraints of the Python virtual machine will undoubtedly inform the next generation of performance improvements.

For the wider Python community, this outcome highlights a mature, cautious, and highly disciplined approach to language governance. As the community continues to push for faster execution, they can be assured that any major architectural changes will have to meet the same rigorous standards of excellence that have kept Python at the forefront of software development for decades. The quest for a faster Python continues, but it will be a journey defined by deliberate, sustainable engineering rather than rapid, high-risk experimentation.