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

The trajectory of Python development reached a significant inflection point this month as the community signaled the formal withdrawal of the experimental just-in-time (JIT) compiler from the CPython codebase. This decision, finalized on October 19, marks the conclusion of a high-stakes effort to bring native JIT acceleration to the world’s most popular programming language. The removal of the feature from the mainline CPython repository follows a period of rigorous scrutiny by the Python Steering Council, which ultimately determined that the proposal failed to meet the stringent requirements necessary for long-term integration into the language’s core.

A Chronology of the JIT Initiative

The quest for a native JIT in CPython has been characterized by both technical ambition and the conservative stewardship that defines the Python ecosystem. The formal journey began with the submission of PEP 744, authored by Brandt Bucher and Savannah Ostrowski. This proposal aimed to integrate a JIT compiler directly into CPython, leveraging the "tier 2" interpreter optimizations that had been gaining traction in recent releases.

However, the Steering Council—the body responsible for the governance and evolution of the language—found that while the technical implementation of the JIT was innovative, the administrative and maintenance roadmap was underdeveloped. In June 2026, the council took the rare step of pausing work on the JIT, demanding a comprehensive plan for how the compiler would be maintained, how it would interact with existing profiling and debugging tools, and how it would maintain compatibility with the vast, heterogeneous landscape of C-extensions that define the Python ecosystem.

Following the pause, proponents introduced PEP 836, intended to bridge the gap between experimental code and a supported feature. Despite these efforts, the council remained unconvinced. Critics noted that the documentation failed to provide a clear path for the long-term support of the JIT, nor did it offer a sufficiently robust framework for performance evaluation across a broad spectrum of workloads. Consequently, the proponents made the difficult decision to withdraw the proposal, effectively pulling the plug on the JIT’s immediate inclusion in the mainline branch of CPython.

The Performance Dilemma and Technical Skepticism

At the heart of the debate was the elusive nature of performance gains. While JIT compilation is widely recognized in the software engineering industry as a mechanism for significant performance acceleration—most notably in engines like V8 for JavaScript or the Java Virtual Machine—the results within the CPython context were less definitive.

Proponents of the CPython JIT argued that it could provide substantial benefits, particularly for applications characterized by long-running, CPU-intensive loops. However, the Steering Council expressed skepticism regarding the scope of these improvements. In their assessment, the performance gains were deemed "small" and limited to specific classes of programs. Furthermore, there were concerns that the complexity introduced by the JIT would outweigh the marginal speed increases for the average Python user.

This skepticism is rooted in the unique architectural constraints of CPython. Unlike languages designed with JITs in mind, CPython’s design prioritizes stability and the seamless integration of C-based extension modules. Introducing a JIT that might break compatibility with legacy modules or complicate the debugging process for developers created a high barrier to entry. The council’s decision serves as a reminder that in the Python ecosystem, architectural purity and ease of maintenance often take precedence over raw execution speed.

Comparative Landscapes: PyPy and CinderX

The conversation surrounding the CPython JIT is not occurring in a vacuum. The Python community has long experimented with alternative implementations that utilize JIT technology. The most prominent example is PyPy, an alternative Python interpreter that utilizes a sophisticated JIT to achieve performance gains that often reach an order of magnitude higher than standard CPython.

However, the success of PyPy has been tempered by its own set of challenges. Because PyPy is a separate implementation, it frequently lags behind the mainline CPython version in terms of compatibility and support for the latest language features. This divergence has created a "split" in the ecosystem, where developers must choose between the speed of PyPy and the compatibility of CPython. Furthermore, many critical third-party C-extensions are optimized specifically for the CPython API, making them difficult or impossible to use with PyPy without significant modification.

Other projects, such as Meta’s CinderX, have also explored JIT compilation as an add-on. While these projects have demonstrated that a JIT can indeed make Python faster, they have remained experimental, intended for specific, controlled environments rather than general-purpose use. The withdrawal of the JIT from CPython highlights the difficulty of reconciling these high-performance experimental models with the rigorous, consensus-driven development process of the official language release.

Official Responses and the Path Forward

In the wake of the withdrawal of PEP 836, Savannah Ostrowski released a statement acknowledging the decision while reaffirming a commitment to the core concepts behind the JIT. "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. She expressed continued optimism regarding the technical direction, specifically citing the potential of "free-threaded support" and a "method-based front end."

This statement underscores a vital reality: the death of a PEP does not mean the death of an idea. The code remains available for those who wish to pursue it, and the modular nature of the Python ecosystem means that the work done on the JIT can potentially be repurposed or integrated into future projects. For the developers who spent months building the JIT, the experience provided invaluable insights into the limitations of the current CPython runtime, which will likely inform future performance-oriented PEPs.

The Broader Impact on Python’s Evolution

The removal of the JIT should not be interpreted as a retreat from the goal of a faster Python. In recent years, the CPython core team has made significant strides in performance, most notably through the introduction of the adaptive interpreter in Python 3.11. This technology, which uses type-specialized bytecode to speed up execution, has delivered measurable performance improvements without the maintenance overhead or compatibility risks associated with a traditional JIT.

This shift in strategy represents a move toward "pragmatic optimization." Rather than attempting a "big bang" upgrade to the interpreter, the core team is focusing on incremental, high-impact changes that benefit the widest possible range of users. This approach has allowed Python to maintain its dominance in fields like data science, machine learning, and web development, where performance is critical but reliability is non-negotiable.

Implications for Future Contributions

For developers and contributors, the saga of the CPython JIT serves as a case study in the requirements for successful feature integration. The Steering Council has signaled that any future performance-related proposal will need to meet a high bar in three specific areas:

1. Maintenance Sustainability: Any new feature must have a long-term plan for maintenance that does not rely on a single developer or a small team of enthusiasts.
2. Measurable Impact: Proposals must be backed by rigorous data showing significant, broad-based performance improvements, rather than improvements that are limited to edge cases.
3. Integration and Compatibility: New features must integrate seamlessly with the existing C-API, debugging tools, and profilers without introducing breaking changes.

The decision to remove the JIT is a reflection of the maturity of the Python language. As Python has grown from a scripting language to the backbone of modern AI and data infrastructure, the cost of introducing complex, experimental features has risen. The community’s decision-making process is now defined by a cautious, evidence-based approach that protects the interests of the millions of developers who rely on the language for mission-critical applications.

While the JIT will not be appearing in the next version of CPython, the lessons learned from this endeavor are far from lost. The infrastructure built, the bugs discovered, and the limitations identified will serve as the foundation for the next generation of performance improvements. The pursuit of a faster Python continues, albeit through a more deliberate and carefully vetted path. For the time being, the Python ecosystem remains focused on the stability and reliability that have made it an enduring success, while continuing to innovate in ways that preserve the integrity of the language for years to come.