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

Introduction

For over a decade, V8's optimizing compiler Turbofan relied on a distinctive intermediate representation known as the Sea of Nodes (SoN). This graph-based approach set V8 apart from most production compilers, which typically use a control-flow graph (CFG). However, starting around 2021, the V8 team began a gradual migration away from SoN toward a more traditional CFG-based IR called Turboshaft. Today, the entire JavaScript backend of Turbofan has adopted Turboshaft, and WebAssembly uses it throughout its entire pipeline. Only two parts of Turbofan still retain some Sea of Nodes: the builtin pipeline (being slowly replaced) and the JavaScript frontend (being replaced by Maglev, another CFG-based IR). This article explores the motivations behind this strategic shift.

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

The Origins of Turbofan and Sea of Nodes

Twelve years ago, in 2013, V8 had a single optimizing compiler: Crankshaft. Crankshaft used a CFG-based IR and delivered significant performance improvements despite its limitations. Over time, the team enhanced Crankshaft to generate faster code in more scenarios, but technical debt accumulated and several critical issues emerged.

Challenges with Crankshaft

Excessive handwritten assembly: Each new IR operator required manual assembly translation for all four officially supported architectures (x64, ia32, arm, arm64).
Poor asm.js optimization: At the time, asm.js was considered a key steppingstone to high-performance JavaScript, and Crankshaft struggled to optimize it effectively.
Rigid control flow: Control flow was fixed at graph-building time; introducing new control flow during lowering (e.g., expanding a high-level JSAdd into a conditional string addition) was impossible.
No try-catch support: Adding try-catch constructs proved extremely difficult—several engineers spent months without success.
Performance cliffs and bailouts: Using certain features or hitting edge cases could cause performance drops of 100x, making it hard for developers to write predictably fast code.
Deoptimization loops: Crankshaft would reoptimize functions with the same speculative assumptions that had just caused a deoptimization, leading to repeated performance regressions.

Why Sea of Nodes Was Chosen for Turbofan

To overcome these limitations, the V8 team designed Turbofan with a Sea of Nodes IR. SoN allowed flexible operation reordering, easy introduction of new control flow during lowering, and better support for speculative optimizations. It was a bold choice that addressed many of Crankshaft’s weaknesses—at the cost of significant complexity.

The Decision to Move Away

Despite its strengths, the Sea of Nodes introduced its own set of challenges over the years. The team realized that a more conventional CFG-based IR could offer better maintainability, performance, and developer productivity.

Complexity and Maintenance

Sea of Nodes is inherently more complex than a CFG. The graph structure makes debugging, optimization passes, and code generation harder to reason about. New team members faced a steep learning curve, and the specialized knowledge required slowed down development. Turboshaft, with its explicit control flow, is easier to understand, modify, and extend.

Performance and Deoptimization Issues

While SoN enabled aggressive optimizations, it also made deoptimization handling more intricate. The free-form graph could lead to subtle bugs and performance regressions when speculative assumptions failed. Turboshaft simplifies deoptimization by tying state to specific control flow points, reducing the risk of deoptimization loops and making bailout mechanics more predictable.

Limitations in Lowering and Control Flow

Although SoN allowed introducing control flow during lowering, managing this flexibility at scale proved challenging. The graph could become cluttered with nodes that represented both data and control dependencies, making it harder to optimize. Turboshaft separates data flow from control flow, mimicking modern compiler architectures that have proven effective in other projects like LLVM and SpiderMonkey.

The Turboshaft Solution

Turboshaft is a clean-slate IR designed for clarity and performance. It uses a control-flow graph with basic blocks, explicit phi nodes, and a more traditional instruction selection pipeline.

Benefits of a Control-Flow Graph

Simpler debugging and profiling: Developers can easily map IR to source code and understand optimization effects.
Faster compilation: Many passes that required complex graph traversals in SoN become linear scans over blocks.
Better integration with other V8 components: Turboshaft shares infrastructure with Maglev, V8's new mid-tier compiler, reducing duplication.
Improved code generation: Explicit control flow enables more straightforward register allocation and instruction scheduling.

Current Status and Future

As of now, Turboshaft powers all JavaScript optimization in Turbofan's backend, and WebAssembly uses it end-to-end. The builtin pipeline is partially converted, and the JavaScript frontend is being phased out in favor of Maglev. The V8 team expects to fully retire Sea of Nodes once these remaining parts are replaced. This migration demonstrates that even well-established compiler designs can evolve to meet new demands for maintainability and performance.

Conclusion

V8’s transition from the Sea of Nodes to Turboshaft represents a pragmatic return to a more conventional compiler architecture. While SoN served V8 well for years, the advantages of a CFG—simplicity, debuggability, and ease of maintenance—ultimately won out. This move has already improved developer experience and code quality, and it sets the stage for future optimizations in V8. The story underscores that in compiler engineering, the best design is often the one that balances innovation with practical long-term sustainability.

Tags: