Python's JIT Is Being Removed: PEP 836 Withdrawn, What 3.15 and 3.16 Mean for You

Python's experimental JIT compiler is getting pulled out of CPython's main branch. The move follows the October 19, 2026 withdrawal of PEP 836, the proposal that was supposed to turn the JIT from a four-year science project into an officially supported feature. If you're on Python 3.13, 3.14, or the newly released 3.15, nothing in your installation changes today. But Python 3.16 (now entering its development cycle) is expected to ship without the JIT the Faster CPython team has been building since 2023.

This isn't a security incident or a bug. It's a governance call. The Python Steering Council looked at the plan to keep the JIT alive and decided it didn't clear the bar. Here's what actually happened and what it means if you ship Python in production.

What is PEP 836, exactly?

PEP 836, titled "JIT Go Brrr: The Path to a Supported JIT Compiler for CPython," was written by Brandt Bucher, Savannah Ostrowski, and Ken Jin (the three core developers who've carried the JIT project since it landed experimentally in Python 3.13). It was created on July 2, 2026, as a direct response to a Steering Council ultimatum from the previous month.

The PEP wasn't asking the council to declare the JIT "done." It proposed a multi-year roadmap: rework the JIT's architecture from trace-based to method-based compilation, hit a 5% performance floor by the Python 3.16 beta, reach a 20% uplift on the free-threaded build by the 3.17 beta, and finish compatibility testing against popular PyPI packages by the 3.17 release candidate. That last milestone landed around August 2028.

The council read that timeline and said no.

Why did the Steering Council reject it?

Three things, according to the council's own feedback and the reporting that followed:

• The compatibility timeline was too slow. Pushing real-world PyPI compatibility testing out to 2028 meant years of development with no confirmation the JIT actually works with the packages people use. The council wanted continuous testing starting now, not a milestone at the end.
• The performance claims were vague and optimistic. The JIT's actual gains so far have been real but modest: noticeable on tight numeric loops, barely there for typical web or data-processing code. The council wasn't convinced the PEP's targets were grounded in that reality.
• Debugging, profiling, and security got thin treatment. A JIT changes how exceptions, tracebacks, and debuggers interact with running code. The council wanted a much more detailed plan for how those tools would keep working, and didn't get one.

Ostrowski put the withdrawal 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's a team saying the ask is reasonable, they just can't staff it right now, not a team that thinks the council is wrong.

How did we get here? A quick history

This didn't come out of nowhere. The JIT has been inching toward "real feature" status for a couple of years:

The pause that led to all this started in June 2026, when the Steering Council froze new JIT work in CPython's main branch and gave the team six months to land an accepted PEP covering maintenance, compatibility, and measurable success criteria. Bug fixes and security patches to the existing code were still allowed. New optimization work wasn't. PEP 836 was the team's answer to that deadline, and it didn't survive the review.

Does this break anything in 3.13, 3.14, or 3.15?

No. This is purely a main-branch, future-version decision. If you're running the JIT today via PYTHON_JIT=1 on 3.14 or 3.15, it keeps working exactly the same way it did yesterday. Released versions don't get features retroactively yanked: that's not how CPython's backport policy works, and the council's decision was explicit about removal happening "early in the Python 3.16 development cycle," not against anything already shipped.

If you've never touched the JIT, you're even less affected. It's been opt-in or limited to free-threaded builds this whole time, and adoption outside of specific numeric workloads has been limited. One developer's joke after this news broke was basically "I checked, my Python never had one," which, fair.

What happens in Python 3.16?

Assuming the council's plan holds, the JIT code comes out of CPython's main branch early in the 3.16 cycle. That means the Python 3.16 release, expected around October 2027, is on track to ship without a built-in JIT at all (a step backward from 3.14 and 3.15 in that specific respect), even though almost everything else about performance keeps moving forward.

The door isn't welded shut. Bucher, Ostrowski, and Jin can keep developing the JIT outside the main CPython tree (as a fork, a reference implementation, or a third-party build) and come back with a tighter, better-evidenced PEP later. Brett Cannon's read on the situation is the one that stuck: withdrawal means the code leaves the repository, but it doesn't mean the idea is dead, just that it has to re-earn its spot the same way any other feature would.

Is CPython giving up on speed?

Not even close, and this is where I think some of the reaction online overshoots. The JIT was always one piece of the Faster CPython effort, not the whole thing. The specializing adaptive interpreter, smaller object layouts, and a string of targeted optimizations since 3.11 have already delivered close to a 50% speedup on real workloads without a JIT anywhere in the picture. The JIT was supposed to be the next big jump, but by the team's own numbers the gains were "measurable, but small," and mostly showed up in long-running tight loops rather than the string processing and I/O-bound code most Python actually runs.

I get why the Hacker News crowd is split on this. Plenty of comments made the fair point that if you forced the JVM's JIT through this kind of committee process at this stage of its life, it would never have shipped either: JITs are messy by nature and get good through iteration, not up-front specification. Others pushed back just as fairly: Python already has Numba, Cython, PyPy, and GraalPy for people who need serious numeric speed, so the bar for baking a brand-new JIT into the default interpreter (with all the debugging, security, and C-extension compatibility risk that comes with CPython's enormous surface area) should be high. I land on the second side. CPython isn't a side project; a half-baked JIT shipping to millions of production deployments is a different kind of risk than one shipping in a research VM.

What should you actually do right now?

Honestly, nothing urgent. A short list if you want to be thorough:

• If you're not using PYTHON_JIT=1 today, this changes nothing for you. Don't go looking for a migration guide that doesn't exist yet.
• If you are running JIT builds in production on 3.14 or 3.15, keep doing what you're doing. Just don't plan your 3.16 upgrade assuming the JIT will still be there.
• If your performance story depends on the JIT long-term, look at PyPy or GraalPy for CPU-bound workloads now rather than waiting on CPython's native one to stabilize. That stabilization timeline just got a lot less certain.
• If you maintain a C extension, this is good news, not bad: one less moving target to test against for the next release cycle.

What people are saying

Related reading

If you're tracking how different ecosystems are approaching the compiler and performance question this year, it's worth looking at how Rust and TypeScript's compiler work compares and why some newer languages are skipping garbage collection entirely to chase the same kind of speed Python is still fighting for.

None of this means Python is falling behind. It means the project's governance did what it's supposed to do: it said "show us the plan," and when the plan didn't hold up, it said no rather than merging something half-finished into a language three CPU architectures and millions of production services depend on. That's slower than shipping fast. It's also probably right.