Latest

Technology

Python drops its JIT and open source loses a shortcut

The steering council rejects PEP 836 and the experimental JIT leaves CPython: small gains, insufficient support and a clear message about performance.

Python drops its JIT and open source loses a shortcut
Python drops its JIT and open source loses a shortcut

The experimental JIT (Just-in-Time) engine in CPython will not remain in the main branch. The proposal that was to turn it into a supported part of the interpreter, PEP 836, was withdrawn on 19 October, closing an attempt that had spent three years looking for room among the language's priorities. The authors, Brandt Bucher and Savannah Ostrowski, have not disappeared from the map: they have acknowledged that they lacked the resources to sustain the current version of the document. That detail says more about the state of the project than any statement.

For anyone who programs in Python every day, the news has two readings. The first is that the language will not be sped up via the compiler in the short term. The second is that the mechanism meant to decide it worked: the steering council asked for a maintenance plan, assessed the performance evidence and said no when the plan did not arrive. In an ecosystem where almost everything is approved out of enthusiasm, seeing a documented technical rejection is almost a rarity, but that is how Python works.

The matter matters because Python carries an old contradiction: it serves as the entry point to half the sector and, at the same time, is the language that complains most about its own speed. Every year a solution appears that promises to close that gap and every year the solution hits the same wall, which is not technical but one of maintenance engineering.

After all, touching a language like Python is not easy; a good part of enterprise solutions depend on this language, and in AI and Machine Learning it is the undisputed king, so laying a hand on its specification requires much more than good ideas, it requires commitments and clear plans.

What was the JIT and what did it promise in Python?

A just-in-time or JIT compiler translates code into machine instructions while the program runs, instead of interpreting it line by line. The promise is simple to state and hard to keep: less repeated work, more speed, without the programmer changing a single comma of their code.

The CPython project started with that goal and with a limited scope, designed for long-running loops and compute-heavy workloads. The improvements existed, but they were modest and uneven, according to the council's own analysis used to decide.

A JIT that speeds up some programs by 15% and leaves the rest unchanged is not an epoch-making change, it is an optimization that has to be justified every quarter against other patches that do benefit everyone.

The other front was maintenance. A JIT inside an interpreter touches the compiler, the bytecode interpreter, the debugger and the profiler at the same time, and each of those systems has its own pace of change. That is where the project ran out of air.

The council's "No"

The sequence is documented and instructive. Work was paused in June 2026 until a document existed explaining how to integrate and sustain the JIT in Python's base. The team responded with two proposals: PEP 744 explained what the compiler did and PEP 836 attempted to answer what was missing, from maintenance to performance evaluation.

The council found concrete gaps: how the code would be sustained long term, how the gain would be measured with comparable criteria and how it would coexist with debugging and profiling tools. To that it added a less kind and more useful objection, that the document was too optimistic about the figures to be expected. InfoWorld's report covers the closure of the matter and Ostrowski's remark about the team's bandwidth.

No one has forbidden others from continuing the work on their own or packaging it in an alternative CPython build. What has changed is the price of returning: anyone who wants to bring that code back into the main branch will have to clear the same bar of support, measurement and integration, and that bar is now written down and public.

The adaptive interpreter keeps doing the dirty work

The withdrawal of the JIT does not leave Python where it was in 2022. The adaptive interpreter that arrived with version 3.11 swaps bytecode for specialized versions based on the types it sees at runtime, and does so without the programmer rewriting anything. It does not reach JIT speed, but it spreads the improvement across all code and not just closed loops. In the end, the overall improvement matches or exceeds the JIT that was being pursued, so its withdrawal is not painful.

That is why the decision makes sense. The CPython team has spent years pushing gradual improvements that add up little by little, and the JIT competed for the same review time with less measurable return. When the scarce resource is five people's attention, the comparison resolves itself.

Via What it contributes Status
Adaptive interpreter (3.11+) Type-specialized bytecode, without touching the code In production
Experimental CPython JIT Speeds up long loops, uneven gain Withdrawn from the main branch
PyPy Mature JIT, up to ten times faster on favourable workloads Separate project, lagging behind CPython
CinderX (Meta) JIT as an installable add-on Experimental

What remains for those who need speed

If your code spends the day inside a numerical loop, the answer is still the same as five years ago: move that core to a compiled library, to C, to Rust or to an engine like NumPy. The other option is to change interpreter and accept the price of PyPy, which lags behind the reference version and has problems with C extension modules.

For those who write tools and prefer a language with performance guarantees from the outset, the debate goes by another name. We covered it when analyzing SolidCraft and parametric CAD written in Rust, where the choice of language is not an aesthetic preference, but a decision about what can be promised to the user. Python wins on speed of writing and loses on speed of execution, and the JIT was the attempt to narrow that disadvantage without giving up the former.

There is a third door that almost no one uses and that the council itself pointed to: keeping the JIT outside CPython, as a satellite project. An alternative build with the compiler inside would allow interested parties to measure it without burdening the main project with its maintenance. It is the elegant exit, and also the one with the fewest incentives, because no one funds a fork used by only four teams.

The uncomfortable message for the rest of the ecosystem

What has happened with CPython's JIT is a case study in technical governance. A group of volunteers proposed a major improvement, documented it, argued for it and received a reasoned no with three specific reasons. There were no leaks or public ego wars, and the code remains available to anyone who wants to pick it up.

Compared with what happens in other projects, the scene is almost exemplary. In open source, performance decisions taken on a demo and announced at a conference abound, with the real measurement arriving two years later and nobody taking on the cost of maintaining it. Here the cost was put up front, and that was the reason for the rejection.

It is not the end of fast Python

The language has not become slower because a PEP was withdrawn. The stable version remains the same and the adaptive interpreter continues to improve with each release, albeit without headlines. What has been closed is a specific path, not the problem.

In two years, the relevant question will not be whether CPython has a JIT, but whether the governance model can withstand the pressure of an ecosystem that demands both stability and speed.

If the next attempt arrives with comparable measurements and a signed maintenance plan, the council will find it hard to say no. And if it does not arrive, the gap will be filled by alternative interpreters, which already know how it is done and have been waiting their turn for a decade.

José Maldonado

Author

José Maldonado

Activist and blogger on technology, free software and blockchain.

The latest
From Huang to Botín, from Zara to Byron: corporate responsibility in global capitalism

Keep reading