JIT in the Wild: CPython’s Next Step vs PyPy and V8 (With Real Benchmarks)

“JIT” is not one thing
— it’s a family of tradeoffs between startup time, peak speed, memory footprint, and deoptimization risk.
In this talk we connect mechanism → measurements.

We start with runtime JITs and their philosophies:

• PyPy: tracing JIT (traces + guards + aggressive specialization around hot loops)
• CPython: modern execution pipeline (adaptive specialization today + an evolving JIT direction)
• V8: tiered execution (fast baseline + optimizing tiers; speculation + deopts)

Then we add a pragmatic angle: Numba and JAX aren’t “Python runtime JITs”,
but they are the most widely used ways to JIT-compile numeric kernels on CPU (and beyond).
We benchmark them separately on kernels where they apply, and show how their speedups relate to compilation cost, shape constraints, and dispatch overhead.

Interactive segment:
I show multiple unlabeled warmup/throughput curves (runtime curves + kernel curves).
The audience guesses which engine produced which curve, then we unpack the reason.

Key message:
performance is a curve, not a number.
If you can read warmup and steady-state behavior, you can choose the right toolchain (runtime vs kernel compiler) with confidence.