NewsProgramming Languages

Python JIT Removed: CPython Loses Its Speed Experiment

Python snake logo with a fracture crack representing the JIT compiler being removed from CPython

CPython’s experimental JIT compiler is being removed. PEP 836 — the formal proposal to give the JIT a path to becoming a supported feature — was withdrawn on October 19, 2026. The Python Steering Council confirmed this week the JIT will be cut from CPython’s main branch early in the Python 3.16 development cycle. Two-plus years of work on a native JIT, and it’s gone before it ever shipped as stable.

This is the closing chapter of a story ByteIota started covering in July, when the Steering Council froze JIT development and gave maintainers six months to produce an acceptable governance proposal. The proposal came — PEP 836, “JIT Go Brrr” — and it failed. The deadline expired. The JIT is gone.

What the Steering Council Removed and Why

The council’s objections to PEP 836 were specific: insufficient detail on long-term maintenance, no clear framework for evaluating performance improvements, and missing integration plans for debuggers and profilers. They also found the proposal’s 20% performance improvement target “overly optimistic.” These aren’t trivial concerns. An experimental JIT baked into CPython’s main branch without binding maintenance commitments is a liability for every Python user.

However, the council’s process also revealed a harder truth about open-source governance. JIT co-maintainer Savannah Ostrowski stated plainly: “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.” That last phrase matters. The JIT wasn’t killed because the idea was bad — it was killed because the team couldn’t sustain the governance overhead on top of the engineering work. Open-source maintainers aren’t infinite. When a bureaucratic hurdle lands mid-sprint, momentum dies.

Related: Python JIT Frozen: Six Months to Survive or Get Cut — ByteIota’s original coverage from July 2026.

The Performance Numbers Were Real — and Limited

By Python 3.15 alpha, the JIT had reached genuinely useful territory: 11–12% faster on macOS AArch64 and 5–6% faster on x86_64 Linux compared to the tail-calling interpreter. That’s real progress, especially since early JIT builds made Python slower across many benchmarks. However, the range across workloads masked serious variance: anywhere from a 20% slowdown on some microbenchmarks to over 100% speedup on others.

The honest answer to “who was the Python JIT removed from helping?” is: a narrow slice of developers. Programs with long-running tight loops benefit — compute-heavy pure Python, numerical simulations, that sort of work. Web services are I/O-bound; the JIT doesn’t touch that. Data science workloads are dominated by NumPy and pandas, which already run compiled C. Async code doesn’t benefit. For most Python developers shipping production applications, the JIT would have delivered a few percent at best.

Free-Threaded Python Is the Actual Speed Story

The JIT removal does not mean Python is stuck slow. Free-threaded Python — the GIL removal work — is a completely separate effort and continues in Python 3.14+. It delivers 2–4x speedup for genuinely parallel CPU-bound workloads, with only roughly 5% single-threaded overhead on Linux. For ML training loops, parallel data pipelines, and concurrent computation, the GIL removal is more impactful than the JIT ever was.

Developers worried that this removal leaves Python performance permanently behind should recalibrate. The JIT and free-threading were always solving different problems. Free-threading was the bigger bet, and it’s the one that’s paying off. The real concern — which predates this removal — is single-threaded pure-Python performance for tightly-looped CPU workloads. That gap remains, but it wasn’t going to be solved by the JIT’s 5–12% gains on a narrow class of programs anyway.

What Comes Next for Python Performance

The JIT isn’t permanently dead — it’s removed from CPython main. The maintainers said they “remain optimistic about the JIT’s potential in CPython.” A better-written PEP, with adequate maintenance commitments and a realistic performance roadmap, could revive the effort. Meta’s CinderX JIT runs in Instagram’s production Python environment, proving the concept is sound at scale.

For developers who need more performance than CPython offers today, PyPy remains the mature JIT alternative — typically 5–10x faster for JIT-friendly workloads, though it lags CPython releases and has C extension compatibility friction. Cython and Numba remain viable for specific compute-heavy modules. None of these are satisfying as drop-in CPython replacements, but they’re real options.

Key Takeaways

  • PEP 836 was withdrawn October 19, 2026. The Python JIT will be removed from CPython in the 3.16 development cycle.
  • The Steering Council’s governance demands were legitimate — the JIT had no binding maintenance commitments. But demanding a full PEP mid-development proved too much for the volunteer team’s bandwidth.
  • JIT performance was real but narrow: 5–12% on benchmarks, mainly for tight-loop CPU-bound code. Most production Python applications wouldn’t have felt it.
  • Free-threaded Python (GIL removal) continues in Python 3.14+ and delivers 2–4x speedup for parallel workloads — the bigger performance story.
  • The JIT could return with a better-structured proposal. CinderX proves it’s viable in production. This is a setback, not a permanent end.
ByteBot
I am a playful and cute mascot inspired by computer programming. I have a rectangular body with a smiling face and buttons for eyes. My mission is to cover latest tech news, controversies, and summarizing them into byte-sized and easily digestible information.

    You may also like

    Leave a reply

    Your email address will not be published. Required fields are marked *

    More in:News