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

The development of the Python programming language has reached a critical juncture following the official decision by the Python Steering Council to strip out the experimental just-in-time (JIT) compiler from the mainline CPython codebase. This monumental reversal follows months of administrative delays, unmet proposals, and rigorous debates regarding long-term maintenance burdens, compatibility with existing profiling and debugging tools, and the actual performance benefits delivered by the technology.

For a language that currently dominates artificial intelligence, data science, web development, and systems automation, the quest for native speed enhancements remains a holy grail. However, the Python community’s governing bodies have consistently demonstrated that performance cannot come at the expense of stability, ecosystem fragmentation, or an unmanageable maintenance debt for core contributors.

The Backstory of CPython Performance and the JIT Experiment

CPython, the reference implementation of Python written in C, has historically prioritized simplicity, portability, and correctness over raw execution speed. Unlike compiled languages such as C++ or Rust, or managed environments like Java, standard Python interprets code line-by-line, which traditionally results in slower execution speeds. To address this persistent criticism without sacrificing backward compatibility, core developers have explored various acceleration techniques over the past decade.

The native JIT compiler initiative represented one of the most ambitious attempts to modernize CPython’s execution model natively. Championed by prominent core developers Brandt Bucher and Savannah Ostrowski, the JIT framework aimed to translate Python bytecode into native machine code at runtime, thereby eliminating repetitive interpretation overhead for heavily executed code segments.

The initial excitement surrounding the JIT was palpable. Proponents argued that a native JIT built directly into CPython could close the speed gap between Python and other compiled languages, democratizing high-performance computing for millions of developers worldwide. However, as the experimental code made its way into development branches, the Python Steering Council—the ultimate authority on language evolution—began raising pressing structural concerns.

Chronology of the JIT Experiment: From Introduction to Withdrawal

The trajectory of the CPython JIT compiler has been defined by a series of escalating requirements and missed deadlines that ultimately led to its demise within the mainline repository:

• Early Development and Prototyping: Throughout 2023 and 2024, core developers experimented with template-based JIT compilation techniques, laying the groundwork for native machine code generation inside CPython.
• The Formalization Phase (PEP 744): Brandt Bucher and Savannah Ostrowski drafted Python Enhancement Proposal (PEP) 744 to outline the JIT’s core functionality, detailing how the foundational architecture would operate. While accepted as an exploration, the proposal lacked operational details concerning day-to-day maintenance.
• The Steering Council Pause (June 2026): Recognizing that the experimental JIT lacked a clear roadmap for long-term survival, the Python Steering Council formally paused work on the JIT. The council mandated that proponents submit a comprehensive follow-up PEP detailing maintenance, debugging integration, and performance evaluation metrics before the feature could graduate beyond experimental status.
• The Submission of PEP 836: To address the council’s demands, Bucher and Ostrowski drafted PEP 836, titled "JIT Go Brrr: The Path to a Supported JIT Compiler for CPython."
• Council Critiques and Pushback: Upon review, the Steering Council found PEP 836 deeply lacking. The council criticized the document for overstating performance expectations while under-delivering on concrete strategies for integration with established CPython debugging tools, memory profilers, and third-party extension modules.
• Official Withdrawal (October 19): Facing insurmountable hurdles, personal bandwidth constraints, and an exceptionally high governance bar, the authors officially withdrew PEP 836. Consequently, the Steering Council ruled that the experimental code must be purged from the mainline CPython repository.

Data and Performance Realities: Measuring the Speedups

At the heart of the Steering Council’s skepticism were empirical metrics regarding performance. While advocates promoted the JIT as a transformative upgrade, benchmark evaluations revealed a more nuanced reality.

Performance improvements provided by the experimental JIT were measurable but strictly limited in scope. The compiler excelled primarily in narrow use cases—most notably in programs characterized by long-running, tight computational loops containing minimal dynamic polymorphism. For standard, asynchronous, input/output-bound, or heavily object-oriented web applications, the speed enhancements were negligible or entirely absent.

Furthermore, introducing a JIT compiler introduced complex trade-offs. Memory consumption increased due to the caching of native machine code, and startup times experienced minor regressions. Most concerningly, the JIT complicated the already intricate mechanics of CPython’s garbage collection and reference counting systems, posing severe risks to third-party C-extensions that rely on stable, predictable internal CPython Application Programming Interfaces (APIs).

Official Statements and Community Reactions

The decision to withdraw PEP 836 and remove the JIT code has sparked widespread discussions across developer forums, mailing lists, and open-source communities.

In her statement accompanying the withdrawal of PEP 836 on October 19, Savannah Ostrowski maintained a balanced perspective on the technology’s long-term promise. "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," Ostrowski noted. Despite the setback, she reaffirmed her faith in the underlying architecture, adding, "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."

Members of the Python Steering Council defended their stringent requirements, emphasizing that CPython serves as the foundational infrastructure for millions of enterprise systems, scientific instruments, and mission-critical cloud pipelines. Introducing a half-baked or poorly maintained subsystem into the core interpreter risks destabilizing the entire ecosystem.

Independent Python developers and maintainers of major libraries expressed relief that stability was prioritized over premature feature adoption. However, a vocal subset of performance-focused engineers voiced disappointment, warning that Python risks falling further behind modern execution environments if it cannot successfully implement native JIT compilation.

Alternative Paths and Competitors in the Python Acceleration Space

The removal of CPython’s native JIT does not signify a total defeat for runtime optimization, nor does it mean Python developers are entirely devoid of high-speed alternatives. The broader ecosystem has long experimented with alternative interpreters and add-on compilers:

• PyPy: As the most prominent alternative Python implementation, PyPy utilizes a highly sophisticated, tracing JIT compiler capable of speeding up pure Python applications by an order of magnitude or more. However, PyPy historically struggles with full compatibility for complex C-extensions (such as NumPy, Pandas, or PyTorch) and frequently lags behind the mainline CPython release cycle.
• Third-Party Add-Ons and Forks: Meta’s CinderX and similar enterprise forks have implemented aggressive JIT compilers and optimization layers to accelerate internal workloads. While powerful, these projects remain fragmented and require specialized build environments that are impractical for mainstream adoption.
• The Adaptive Interpreter: Demonstrating that speed gains are possible without a full JIT, the core CPython team successfully introduced the adaptive interpreter in Python 3.11. Utilizing type-specialized bytecode, this initiative delivered measurable double-digit performance improvements across a wide variety of workloads without requiring users to alter a single line of source code or manage complex compilation flags.

Broader Impact and Future Implications for CPython Development

The purging of the experimental JIT establishes a clear precedent for the future governance of CPython. It underscores the reality that enthusiasm and proof-of-concept code are insufficient for inclusion in the world’s most popular programming language. Any future attempts to introduce a native JIT or major architectural overhaul will be subjected to rigorous scrutiny, requiring exhaustive documentation on maintenance pipelines, debugging compatibility, security implications, and comprehensive performance metrics across diverse test suites.

As Python continues to evolve—particularly with ongoing efforts toward free-threaded execution (PEP 703) to remove the Global Interpreter Lock (GIL)—core developers must carefully allocate their limited human resources. Maintaining a complex JIT compiler requires specialized engineering talent and continuous monitoring to prevent bit rot and security vulnerabilities. By cutting away experimental code that failed to meet these standards, the Python Steering Council has chosen a path of deliberate, sustainable progress.

Ultimately, the quest for a faster Python remains far from over. Whether through incremental bytecode specializations, refined memory management, or future community-led JIT initiatives built on solid, verifiable foundations, the language will continue to adapt to the demands of modern computing. For now, however, CPython’s mainline architecture remains JIT-free, prioritizing absolute reliability, developer trust, and ecosystem stability above all else.