From Sea to Solid Ground: V8's Transition from Sea of Nodes to Turboshaft

For years, V8's top-tier optimizing compiler, Turbofan, was one of the few production compilers relying on a Sea of Nodes (SoN) intermediate representation. This distinctive approach allowed powerful optimizations but came with its own complexities. Now, after nearly three years of development, V8 is steadily replacing SoN with a more traditional Control-Flow Graph (CFG) based IR dubbed Turboshaft. This article explores the journey from SoN to Turboshaft and the reasons behind this significant architectural shift.

The Origins of Turbofan and Sea of Nodes

Twelve years ago, in 2013, V8's optimizing compiler was Crankshaft, which used a CFG-based IR. Crankshaft delivered notable performance gains despite its early limitations. Over time, the team enhanced it to handle more scenarios, but technical debt accumulated, leading to several critical issues:

• Excessive hand-written assembly: Each new IR operator required manual translation to assembly for all four supported architectures (x64, ia32, arm, arm64).
• asm.js optimization difficulties: Crankshaft struggled with asm.js, then seen as a stepping stone to high-performance JavaScript.
• No dynamic control flow: Control flow was fixed at graph construction time, preventing lower-level operations from introducing new branches. For instance, lowering a high-level JSAdd(x, y) into a conditional if (x is String && y is String) { StringAdd(x, y) } else { ... } was impossible.
• Missing try-catch support: Implementing it proved extremely challenging—multiple engineers spent months without success.
• Performance cliffs and bailouts: Using certain features or hitting edge cases could cause a 100x performance drop, making it hard for developers to write reliably fast code.
• Deoptimization loops: Crankshaft would re-optimize a function with the same faulty assumptions after deoptimization, leading to endless cycles.

These shortcomings prompted the V8 team to design a new compiler from scratch. The result was Turbofan, which adopted the Sea of Nodes representation. SoN aimed to eliminate many of Crankshaft's limitations by allowing flexible reordering of operations and easier integration of control flow during lowering. However, as the compiler matured, the complexity of SoN began to weigh on maintenance and performance.

The Challenges with Sea of Nodes

Despite its theoretical elegance, Sea of Nodes introduced its own set of practical difficulties. The non-linear representation made debugging and verification harder. The IR's flexibility sometimes led to unexpected optimization patterns, and the learning curve for new developers was steep. Additionally, maintaining the SoN infrastructure across multiple compiler pipelines (JavaScript, WebAssembly, builtins) proved increasingly costly. These factors motivated the team to explore a return to a more conventional CFG-based approach—one that could provide similar optimization power with less complexity.

Introducing Turboshaft: A Return to Control-Flow Graphs

Turboshaft is V8's new CFG-based IR designed to replace Sea of Nodes in Turbofan. Already, the entire JavaScript backend of Turbofan has been migrated to Turboshaft, and the WebAssembly pipeline uses it throughout. Two components still rely on the original SoN: the builtin pipeline (which is slowly being transitioned) and the frontend of the JavaScript pipeline (being replaced by Maglev, another CFG-based IR). Turboshaft aims to preserve the optimization capabilities of SoN while offering a more maintainable and predictable IR. Its CFG structure simplifies tasks such as register allocation, scheduling, and debugging, making the compiler easier to evolve.

What's Next?

V8's migration from SoN to Turboshaft is part of a broader effort to streamline the compiler infrastructure. As the builtin pipeline and JavaScript frontend are gradually modernized, the remaining SoN dependencies will vanish. This transition not only improves compiler maintainability but also sets the stage for future performance enhancements. By adopting a robust CFG foundation, V8 is building a compiler that can more readily adapt to evolving web standards and hardware capabilities.

For developers, this change is largely transparent—code runs as fast as before, if not faster—but it represents a significant engineering milestone. To learn more about V8's compiler architecture, check out our articles on TurboFan’s origins and Turboshaft’s design.