V8''''s four-tier JIT pipeline and profile-guided tiering

A page feels snappy within 200ms of load. A few seconds later it gets faster still. A third speed-up appears after thousands of user interactions. That is not magic — it is V8’s tiered compiler moving hot code up the ladder while leaving cold code cheap.

The four-tier pipeline

V8 has four execution modes layered by compile-time vs run-time tradeoff.

Ignition — the bytecode interpreter. The parser produces an AST; Ignition lowers it to a compact register-based bytecode and executes that on a virtual machine. While interpreting, Ignition records type feedback into a per-function FeedbackVector — slots for each “interesting” location (property load, function call, arithmetic, comparison). Cheap to enter (no compile cost), ~10× slower per instruction than optimised native code.

Sparkplug — the baseline JIT, added in 2021. Sparkplug emits unspecialised machine code in a single linear pass over the bytecode — no SSA, no real optimisation, just a faithful translation of each bytecode to a small block of machine instructions plus a tail call. Compile cost is essentially free (~1 ms/kB bytecode); speedup over Ignition is 1.5–2×.

Maglev — the mid-tier optimising compiler, added in 2023. Maglev uses observed types from the FeedbackVector and SSA-based optimisations to emit specialised machine code, but skips TurboFan’s heavyweight passes. ~10× slower compile than Sparkplug, ~10× faster compile than TurboFan; code roughly halfway between the two in runtime speed.

TurboFan — the heavy optimising compiler. Aggressive inlining, escape analysis, range analysis, hidden-class-driven specialisation, speculative optimisations that may deopt. Compile cost is high (tens to hundreds of ms for complex functions); runtime code is the fastest V8 produces.

Profile-guided tiering

Functions enter Ignition. After execution-count thresholds are crossed (per-function, dynamic), V8 promotes to the next tier. The FeedbackVector tracks not just types but also branch frequencies, so TurboFan can lay out the hot path with optimal branch prediction. Promotion happens off-thread (concurrent compilation) — the JS main thread keeps running on the current tier while a worker thread compiles the next.

Functions can skip tiers: a very hot function seen at startup may jump from Ignition directly to Maglev. Functions whose feedback is unstable (frequent IC transitions) are deferred or skipped — TurboFan on an unstable function would produce code that deoptimizes immediately, wasting 100 ms of compile work.

Operational levers

Eight patterns that keep code on V8’s fast tier:

1. Constructor pattern — declare all object properties in one place so hidden classes are stable.
2. Avoid delete — use null or undefined assignment instead; delete forces dictionary mode.
3. Keep functions monomorphic — do not pass different shapes to the same call site.
4. Avoid arguments in old code; use rest parameters.
5. Pre-allocate arrays with known capacity to avoid resize.
6. Reuse object pools for short-lived workloads (canvas, animation) instead of allocating new objects per frame.
7. Avoid massive object literals in hot paths — they go megamorphic fast.
8. For very hot numeric loops, use TypedArrays — V8 has highly tuned paths for Uint32Array and friends that bypass the IC layer entirely.