Navigating Away from the Sea of Nodes: V8's Shift to Turboshaft

Introduction

For years, V8's top-tier optimizing compiler, Turbofan, stood out as one of the few production compilers built on the Sea of Nodes (SoN) intermediate representation (IR). This innovative approach combined control flow and data dependencies into a unified graph, offering flexibility but also introducing significant complexity. However, since 2021, the V8 team has been systematically replacing SoN with a more traditional Control-Flow Graph (CFG) IR, named Turboshaft. Today, Turboshaft powers the entire JavaScript backend of Turbofan and the complete WebAssembly compilation pipeline. Only two areas of Turbofan still rely on Sea of Nodes: the builtin pipeline (being gradually replaced) and the JavaScript pipeline frontend (being replaced by Maglev, another CFG-based compiler). This article explores the motivations behind this departure from the Sea of Nodes.

Navigating Away from the Sea of Nodes: V8's Shift to Turboshaft — Source: v8.dev

The Roots: Challenges with Crankshaft

To understand why V8 moved away from Sea of Nodes, it helps to look back at its predecessor, Crankshaft. Twelve years ago, in 2013, V8 had a single optimizing compiler—Crankshaft—which already used a CFG-based IR. While Crankshaft delivered impressive speedups for its time, it accumulated technical debt that made further improvements increasingly difficult.

Hand-Written Assembly Bloat

Every new IR operator in Crankshaft required manual hand-written assembly code for all four supported architectures (x64, ia32, arm, arm64). This was error-prone, time-consuming, and hindered the addition of new optimizations.

No Control Flow in Lowerings

Crankshaft built control flow only at graph construction time and considered it final. However, lowering high-level operations to low-level ones often requires introducing new control flow. For example, a high-level JSAdd(x, y) might need to be lowered to: if (x is String and y is String) then use StringAdd else …. Crankshaft could not do this, severely limiting optimization opportunities.

Try-Catch Support Impossible

Supporting try-catch constructs in Crankshaft proved nearly impossible. Multiple engineers spent months trying to add it, without success. This left a critical gap in error handling optimization.

Performance Cliffs and Deoptimization Loops

Crankshaft suffered from abrupt performance cliffs: using a specific feature or hitting an edge case could cause a 100x slowdown. Moreover, it often entered deoptimization loops—re-optimizing with the same speculative assumptions, only to deoptimize again, leading to wasted cycles and unpredictable performance.

The Sea of Nodes Approach in Turbofan

To overcome Crankshaft's limitations, V8 designed Turbofan with a Sea of Nodes IR. SoN represented both data flow and control flow in a single graph, allowing more flexible lowerings and supporting complex features like try-catch. For a time, it was a powerful tool.

What Sea of Nodes Offered

SoN eliminated the finality of control flow, enabling reordering and merging of operations in ways a CFG could not. This allowed Turbofan to handle JavaScript's dynamic nature more effectively, reducing the number of bailouts seen in Crankshaft.

Why It Became Problematic

Despite its advantages, SoN introduced new challenges. The graph structure was difficult to debug and maintain. Visualizing dependencies required specialized tooling, and reasoning about graph transformations became increasingly complex as the codebase grew. Performance cliffs didn't disappear entirely—they just changed form. Additionally, the separation between phases (building, lowering, scheduling) sometimes led to inefficiencies that were hard to trace. As the V8 team added more optimizations, the cost of SoN's flexibility began to outweigh its benefits.

The Transition to Turboshaft

Starting around 2021, V8 began developing Turboshaft, a new CFG-based IR that returns to a more traditional structure while learning from the lessons of both Crankshaft and Turbofan. Turboshaft aims to combine the simplicity of a CFG with the sophistication needed for modern JavaScript and WebAssembly optimization.

A Return to CFG IR

Turboshaft uses a control-flow graph similar to Crankshaft but with modern design principles: it separates control flow and data dependencies into distinct but cooperating representations. This makes the IR easier to reason about, debug, and optimize. Lowerings can still introduce new control flow, but in a more structured manner than in SoN. The result is a compiler that is simpler to maintain yet capable of high performance.

Current Status of Migration

As of now, Turboshaft has fully replaced Sea of Nodes in Turbofan's JavaScript backend. The entire WebAssembly pipeline also runs on Turboshaft. The two remaining holdouts are the builtin pipeline (used for quickly compiled built-in functions) and the JavaScript frontend of Turbofan. The builtin pipeline is being incrementally migrated to Turboshaft, while the frontend is being replaced by Maglev, a new CFG-based compiler designed specifically for generating tier-2 code. Maglev already handles many functions that would previously have gone through Turbofan's SoN frontend.

Conclusion

V8's journey from Crankshaft through Sea of Nodes to Turboshaft reflects a pragmatic evolution in compiler design. While SoN was a bold experiment that pushed the boundaries of what was possible, its complexity ultimately made it less sustainable for a large-scale production compiler like V8. Turboshaft offers a more maintainable foundation that still delivers the high performance JavaScript developers expect. The transition is nearly complete, and with Maglev handling the front-end, V8 is now better positioned to optimize future web workloads. The shift away from the Sea of Nodes marks not a retreat from innovation, but a strategic return to stability and clarity.

Tags: