From Sea of Nodes to Turboshaft: How V8 Reengineered Its Compiler IR

Introduction

V8's optimizing compiler Turbofan was one of the few production compilers using the Sea of Nodes (SoN) intermediate representation (IR). For nearly three years, the V8 team has been systematically replacing Sea of Nodes with a more traditional control-flow graph (CFG) based IR called Turboshaft. Today, the entire JavaScript backend of Turbofan and the complete WebAssembly pipeline use Turboshaft. Only the builtin pipeline (slowly being replaced) and the JavaScript frontend (being replaced by Maglev) still retain some Sea of Nodes components. This guide walks through the step-by-step journey of that transition, explaining why V8 moved away from Sea of Nodes and how you can understand the process.

From Sea of Nodes to Turboshaft: How V8 Reengineered Its Compiler IR — Source: v8.dev

What You Need

Basic understanding of compiler intermediate representations (IRs)
Familiarity with V8's architecture (Crankshaft, Turbofan, Maglev)
Curiosity about real-world compiler design trade-offs

Step 1: Recognize the Limitations of the Sea of Nodes

Before the transition could begin, the V8 team had to acknowledge that the Sea of Nodes IR, despite its theoretical elegance, caused practical problems. Key issues included:

Hand-written assembly: Every IR operator required manual assembly code for all four supported architectures (x64, ia32, arm, arm64).
asm.js struggles: Sea of Nodes made it difficult to optimize asm.js efficiently.
No control flow during lowering: High-level operations could not introduce new control flow during lowerings, which is a common compiler technique.
No try-catch support: Months of effort by multiple engineers failed to add try-catch support.
Performance cliffs and bailouts: Minor edge cases could cause 100× performance drops, bewildering developers.
Deoptimization loops: Compiler would repeatedly reoptimize with the same speculative assumptions, leading to endless cycles.

Step 2: Evaluate the Need for a New IR

With the problems identified, the team determined that patching Sea of Nodes was insufficient. They needed an IR that:

Allowed control flow to be introduced during low-level lowering.
Simplified architecture-specific code generation.
Made try-catch and other advanced control flow constructs feasible.
Eliminated performance cliffs and deoptimization loops.

This led to the conceptual design of Turboshaft, a CFG-based IR that retained the best parts of Sea of Nodes while addressing its weaknesses.

Step 3: Design Turboshaft – A Hybrid CFG IR

Turboshaft was built as a control-flow graph but with a sophisticated node-based representation for data dependencies, similar to Sea of Nodes. The design goals were:

Explicit control flow: Phis, loops, branches are first-class citizens.
Fine-grained lowering: High-level operations can be lowered to multiple low-level steps with control flow.
Reduced code repetition: A single lowering step per operation can generate architecture‑specific sequences using shared patterns.

Step 4: Pilot the Transition in the JavaScript Backend

The team started by replacing the Sea of Nodes backend of the JavaScript pipeline with Turboshaft. This meant rewriting:

Register allocation: New algorithms that work on CFG.
Instruction selection: Patterns for all architectures.
Code generation: Final assembly emission using the new IR.

This phase took several months and produced significant performance wins without regression.

Step 5: Extend Turboshaft to WebAssembly

After the JavaScript backend was stable, the team tackled WebAssembly (wasm). Wasm had its own pipeline built on Sea of Nodes. The transition for wasm was simpler because wasm’s language semantics aligned well with CFG. The entire wasm pipeline now uses Turboshaft, yielding faster compilation and better code quality.

Step 6: Gradually Migrate Remaining Components

Two parts still rely on Sea of Nodes: the builtin pipeline (for internal V8 functions) and the JavaScript frontend (graph building from JavaScript bytecode). The team is methodically replacing these:

Builtins: Slowly rewriting builtins to use Turboshaft or moving them to the Maglev tier.
Frontend: The new Maglev compiler, a CFG-based mid-tier, is taking over the frontend work. Maglev is designed to interoperate with Turboshaft.

Step 7: Monitor and Iterate

With the major components migrated, V8 continues to:

Track performance benchmarks (Octane, JetStream, Speedometer).
Fix edge cases where Turboshaft might produce suboptimal code.
Add new optimizations that were impossible in Sea of Nodes, such as better inlining and range analysis.

Tips for Understanding This Transition

Think in terms of trade-offs: Sea of Nodes was great for certain optimizations but terrible for adding new features. Every IR has strengths and weaknesses.
Follow V8’s blog and design docs: The team publishes detailed rationale for each change. Look for posts about Turboshaft and Maglev.
Experiment with the compiler: If you are a compiler enthusiast, try building V8 from source and adding a simple optimization to see how the new IR works.
Compare with other projects: Many modern compilers (e.g., Cranelift, RISC‑V) use CFG IRs; contrast their choices with V8’s.
Understand the big picture: V8’s goal is high performance for real-world JavaScript. The move away from Sea of Nodes is a case study in pragmatism over purity.