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.
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.