How V8 Makes JavaScript Fast: Ignition, Sparkplug, Maglev and TurboFan

Here's one small function, run on Node 26 with the same input every time:

function dist(p) {
  return Math.sqrt(p.x * p.x + p.y * p.y);
}

Then the same function again, but with V8 stopped at a different stage each time:

Ignition only:   50.9 ns per call
+ Sparkplug:     31.9 ns
+ Maglev:         1.65 ns
+ TurboFan:       1.19 ns   ← 43× faster than the first line

The code never changed. The only thing that changed is how hard V8 worked on translating it.

The mental model: a translator who works harder on popular pages#

Picture a translator handed a book in a language your computer doesn't speak.

• For a page read once, they translate it out loud on the spot, line by line.
• For a page read a few times, they write down a quick word-for-word draft.
• For a page read hundreds of times, they write a proper translation.
• For the page everyone reads all day, they polish it, assuming the page always looks the way it has so far.

V8 translates your JavaScript in stages, and only spends extra effort on code that runs a lot.

Each stage is called a tier, and the whole approach is JIT (just-in-time) compilation: the machine code is made while the program runs, not before.

Interpreting on the spot is quick to start but slow per line, like Ignition. Photo: Blossom Ozurumba, CC BY-SA 4.0, via Wikimedia Commons

How it works#

V8 has four tiers. Each one makes faster code, but takes longer to make it:

Every function starts in Ignition. While it runs, V8 counts how often it's called and records what it sees: "p always has x and y, and they're always numbers." That record is called type feedback.

When a function gets hot (runs a lot), V8 moves it up a tier. For dist above, V8's own trace showed:

• Maglev after about 500 calls, taking 0.08 ms to compile.
• TurboFan after about 16,900 calls, taking 0.61 ms to compile. That's about 8× more compile time for code about 1.4× faster.

That trade is why the tiers exist. Most code runs once, at startup. Spending TurboFan's effort on all of it would make every page load slower and save nothing.

The catch: optimized code is a bet#

Maglev and TurboFan are fast because they assume the future looks like the past. "Every p.x has been a number, so skip the type check and do raw number math."

If that assumption breaks, the fast code is wrong. So V8 throws it away and goes back to a lower tier. This is called deoptimization. Here, a single call with a string inside was enough:

dist({ x: "3", y: 4 }); // V8 drops both Maglev and TurboFan code for dist

The function still works, it just runs slower until V8 learns the new types and optimizes again.

In practice#

You can't pick a tier, and you don't need to. V8 decides. But two habits follow from the model:

1. Keep hot code predictable. Pass the same kinds of values to a hot function: same object shapes, numbers staying numbers. That keeps the bet safe. (For why object shape matters, see hidden classes.)

// before: one function, many types: harder to optimize
format(42); format("42"); format(null);

// after: one type per hot function
formatNumber(42);

2. Warm up before you measure. The first few hundred calls of any benchmark measure Ignition, not your code at its best. Run the code many times, then time it. Every number in this post was taken after a warm-up.

Honest stakes: for most app code (click handlers, a React render, a fetch), the tiers just work and none of this is worth thinking about. It matters in hot loops: parsers, data processing, animation, game logic. Even there, profile first. A function that never gets hot never reaches TurboFan anyway.

Say it in an interview#

"V8 is a JIT engine with tiers. Everything starts in Ignition, an interpreter that runs bytecode and records type feedback. Code that runs often gets compiled by Sparkplug, then optimized by Maglev and finally TurboFan, which make fast machine code based on the types seen so far. If those types change, V8 deoptimizes and falls back to a lower tier. So JavaScript is both interpreted and compiled, and keeping hot code type-stable lets it stay in the fast tiers."

Cheat sheet#

TL;DR#

• V8 translates JavaScript in four tiers, spending more effort only on hot code.
• Optimized code is a bet that types stay the same. A surprise type cancels it.
• The same function ran 43× faster in TurboFan than in Ignition alone.
• Keep hot functions type-stable, warm up before benchmarking, and profile before optimizing.

node --trace-opt --trace-deopt --no-concurrent-recompilation trace.js