The Future of CPython Performance: Why the Experimental JIT Was Sidelined

In a decisive move that underscores the rigorous standards of the Python core development team, the experimental just-in-time (JIT) compiler for CPython is being removed from the mainline codebase. This decision, finalized following the withdrawal of Python Enhancement Proposal (PEP) 836, marks the end of a high-profile effort to bring native JIT compilation to the world’s most popular programming language. For the Python community, this development is a sobering reminder that while performance is a priority, it cannot come at the expense of long-term maintainability, stability, or the delicate balance of the CPython ecosystem.

The Core Facts: A High Bar Unmet

At its heart, the removal of the JIT compiler is a matter of administrative and technical feasibility. The Python Steering Council, the governing body responsible for the long-term health of the language, had established a clear set of requirements for any feature of such magnitude. These requirements were not merely suggestions; they were necessary benchmarks to ensure that if a JIT were to become a permanent fixture of CPython, it would not become a "technical debt trap" for future maintainers.

The primary issues leading to the removal were twofold: insufficient documentation regarding the long-term maintenance lifecycle and a lack of granular detail on how the JIT would interact with the broader ecosystem, including debugging tools, profiling suites, and external C-extension modules. While the proponents of the JIT, Brandt Bucher and Savannah Ostrowski, provided a robust technical foundation, they struggled to satisfy the Steering Council’s stringent requirements for integration and performance accountability.

A Chronology of the JIT Initiative

The rise and fall of the CPython JIT can be traced through a series of critical milestones that highlight the iterative nature of Python’s development cycle.

• Initial Prototyping: For years, the Python community has been fascinated by the potential for JIT compilation, inspired by the success of projects like PyPy. The experimental JIT was introduced as an ambitious project to bring these performance benefits directly into the CPython core.
• June 2026 – The Pause: Recognizing that the experimental implementation was drifting away from the core’s standards, the Steering Council officially paused development. They mandated that a formal PEP be authored to define the JIT’s role, maintenance, and integration strategy.
• The PEP 744 vs. PEP 836 Conflict: Bucher and Ostrowski first introduced PEP 744, which focused heavily on the technical mechanics of the JIT. However, the Council found it lacking in governance. This led to the creation of PEP 836, which attempted to address maintenance and support.
• October 19, 2026 – The Withdrawal: After continued feedback from the Steering Council indicated that the requirements for stability, performance validation, and debugging compatibility remained unmet, the authors formally withdrew PEP 836.
• Post-Withdrawal: The project is now being purged from the mainline CPython source, effectively returning the interpreter to its pre-JIT state for the upcoming releases.

Performance: The "Optimism Gap"

One of the most contentious points of the discussion was the expected performance delta. Proponents of the JIT, while technically proficient, were criticized by the Steering Council for presenting a somewhat "overly optimistic" view of the performance gains that the average Python user would experience.

Data indicated that while the JIT was highly effective in specific, constrained environments—such as executing long-running, CPU-bound tight loops—the improvements were marginal or nonexistent for the vast majority of real-world Python applications. Python, as a language, is heavily used for I/O-bound tasks, web services, and glue-code orchestration. In these domains, the overhead of a JIT compiler—including memory usage and the time taken to warm up the cache—often negated the minor execution speed gains.

The Steering Council’s critique focused on the "cost-to-benefit ratio." If a feature increases the complexity of the codebase by a significant factor, it must offer a proportional, across-the-board performance improvement. The experimental JIT failed to demonstrate that it could provide such a clear-cut advantage for the broad spectrum of Python users without introducing a significant risk of regression.

Official Responses and the "Bandwidth" Reality

The withdrawal of PEP 836 was accompanied by a candid admission from its lead maintainers. Savannah Ostrowski noted that the team simply lacked the "personal bandwidth" to navigate the exhaustive requirements set by the Steering Council.

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

This statement highlights a critical reality of open-source development: technical brilliance is not enough. Sustaining a core feature requires a long-term commitment to documentation, bug fixes, integration testing, and community support. The authors of the JIT were effectively asked to commit to a multi-year project management role, a burden that few developers, regardless of their skill, are equipped to handle alongside their primary responsibilities.

Implications for the Future of Python

What does this mean for the future of the language? First, it does not signal the end of performance-oriented development. The "Faster CPython" initiative remains a primary focus of the core team. As seen with the introduction of the adaptive interpreter in Python 3.11, the team prefers optimizations that are invisible to the user and require zero changes to existing codebases. The adaptive interpreter, which utilizes type-specialized bytecode, has already delivered meaningful performance gains, demonstrating that the "no-JIT" route is a viable and successful strategy.

Second, the door remains open for alternative implementations. Nothing stops developers from iterating on the JIT outside of the CPython mainline. Projects like PyPy, which uses a highly optimized JIT, or Meta’s CinderX, serve as specialized alternatives. The withdrawal of PEP 836 simply means that the "blessed" version of CPython will remain focused on stability and modularity rather than risky, experimental compilation techniques.

Finally, the outcome sets a precedent for how future features will be vetted. The Steering Council has solidified its role as a guardian of the "Pythonic" philosophy—a philosophy that prioritizes readability, simplicity, and maintainability above all else. Any future proposal for a JIT—or any similarly transformative architectural change—will now be measured against the high bar established during this process. Developers looking to change the core of CPython must now demonstrate not just that their code is faster, but that it is safer, more manageable, and deeply integrated with the existing tooling that millions of developers rely on every day.

Conclusion: A Measured Path Forward

The removal of the experimental JIT is not a failure of innovation, but a success of governance. It serves as a stark reminder that CPython is not merely a piece of software; it is a global infrastructure upon which countless businesses, scientific endeavors, and educational systems rely.

The decision to sideline the JIT ensures that the language remains predictable and stable. While the dream of a "JIT-powered Python" continues to flicker in the minds of many, the path to achieving it is now clearly marked: it must be a collaborative, long-term effort that satisfies the rigorous architectural and maintenance standards of the core team. For now, the focus shifts back to the incremental, highly effective optimizations that have defined Python’s steady evolution over the last decade. The quest for speed remains, but it will be a journey taken with caution, precision, and a deep respect for the stability that has made Python the world’s most enduring programming language.