Python 3.15's JIT Resurgence: How Community Collaboration Revived a Flagging Project

The recent progress in Python 3.15's Just-In-Time (JIT) compiler represents a significant turning point for Python's performance trajectory. After months of stagnation and uncertainty, the JIT project has not only recovered but exceeded modest performance goals, delivering 11-12% speed improvements on macOS AArch64 and 5-6% on x86_64 Linux compared to the standard interpreter. This achievement comes particularly noteworthy as it was accomplished ahead of schedule and against considerable odds.

The journey of Python's JIT has been fraught with challenges. As recently as eight months ago, the JIT implementation in Python 3.13 and 3.14 was often slower than the interpreter itself, offering no meaningful performance benefits. Compounding these technical difficulties, the Faster CPython team lost its primary sponsor in 2025, casting doubt on the project's future. At a critical juncture, the continuation of the JIT development hinged on uncertain prospects of community stewardship—a model that had historically struggled with the complexity barrier of JIT compiler development.

What emerged from this precarious situation was a remarkable transformation in how the project approached development and collaboration. Rather than relying on a small, specialized team, the JIT project successfully embraced community-driven development by breaking down its complex problems into manageable, approachable tasks. This strategy proved instrumental in expanding the contributor base from just two active recurrent contributors in the middle-end to a more diverse team with four active recurrent contributors, including two non-core developers who became valued contributors.

The technical breakthroughs themselves deserve attention, not merely for their performance impact but for the serendipitous nature of their discovery. One pivotal decision was the shift to a trace recording interpreter frontend, initially driven by a friendly challenge between developers. What began as a prototype to disprove an idea evolved into a significant architectural improvement. The implementation of what the author terms "dual dispatch"—a mechanism that reduced interpreter overhead while maintaining compatibility—proved instrumental. This innovation alone increased JIT code coverage by 50%, dramatically amplifying the potential impact of subsequent optimizations.

Equally important was the elimination of reference count branches in the JITted code. This optimization, though conceptually straightforward, yielded substantial performance gains by removing expensive branching operations that occurred for virtually every Python instruction. The approach proved particularly valuable as both an educational tool for new contributors and as a parallelizable task that could be distributed across the development team.

The human elements of this success story cannot be overstated. The author explicitly credits the "right people" at the right time, acknowledging that the project's trajectory might have been dramatically different without the contributions of key individuals like Savannah Ostrowski, Mark Shannon, Diego Russo, and Brandt Bucher. Beyond the core team, the importance of external knowledge sharing becomes apparent through the author's engagement with PyPy's CF Bolz-Tereick and participation in compiler-focused communities, which broadened their technical perspective and approach to JIT development.

The infrastructure supporting this development, though modest in scale (four machines running in Savannah Ostrowski's closet), provided critical daily performance metrics that enabled rapid iteration and regression detection. This continuous feedback loop proved essential for maintaining the project's momentum and ensuring that optimizations actually delivered tangible benefits.

Looking forward, the JIT's trajectory suggests several implications for Python's evolution. The planned integration of free-threading support in Python 3.15 or 3.16 could further enhance performance, particularly for multi-threaded applications. More broadly, this project demonstrates how even technically complex endeavors can thrive under community stewardship when problems are appropriately decomposed and contributors are effectively onboarded.

However, challenges remain. The wide performance range (from 20% slowdown to over 100% speedup) indicates that the JIT's benefits may not be uniform across all codebases. Additionally, the current success may owe as much to fortunate circumstances and specific technical insights as to any systematic approach, suggesting that replicating this success in other contexts may prove difficult.

Ultimately, the resurgence of Python's JIT compiler represents more than just a performance improvement—it exemplifies how collaborative technical communities can overcome seemingly insurmountable challenges through persistence, decomposed problem-solving, and the willingness to experiment and learn. As Python continues to evolve, this community-driven approach to performance optimization may prove as valuable as the technical innovations themselves.

For those interested in following the JIT's progress, the project maintains performance dashboards at doesjitgobrrr.com, and technical details about the implementation are available through the CPython GitHub repository.