Why V8 Abandoned the Sea of Nodes: The Rise of Turboshaft

Introduction

For over a decade, V8’s optimizing compiler Turbofan relied on an innovative but complex intermediate representation known as the Sea of Nodes (SoN). However, since 2021, the V8 team has been systematically moving away from SoN, returning to a more traditional Control-Flow Graph (CFG) approach called Turboshaft. This article explains the reasons behind this significant shift and how it is reshaping V8’s performance landscape.

The Legacy of Crankshaft and Its Limitations

Before Turbofan, V8’s optimizing compiler was Crankshaft, a CFG-based IR that debuted in 2013. Crankshaft brought substantial speed improvements but quickly accumulated technical debt. Key issues included:

• Excessive hand-written assembly: Each new IR operator required manual assembly translation for all four supported architectures (x64, ia32, arm, arm64), slowing development.
• Poor support for asm.js: At a time when asm.js was seen as a pathway to high-performance JavaScript, Crankshaft struggled to optimize it effectively.
• Inflexible control flow: Control flow was fixed at graph-building time, preventing later lowerings from introducing new branches. For example, a high-level JSAdd(x, y) operation could not be lowered to a conditional string addition without rewriting the graph.
• No try-catch support: Despite months of effort by multiple engineers, Crankshaft never gained the ability to optimize code with try-catch blocks.
• Performance cliffs and bailouts: Using certain features or hitting edge cases could cause 100× slowdowns, making JavaScript performance unpredictable.
• Deoptimization loops: Crankshaft would reoptimize functions with the same speculative assumptions repeatedly, leading to endless cycles of deoptimization.

These problems motivated the creation of Turbofan, which aimed to overcome Crankshaft’s rigidness by adopting the Sea of Nodes representation.

Turbofan and the Sea of Nodes Approach

The Sea of Nodes is a graph-based IR where instructions (nodes) are connected by data and control dependencies in a single, flattened sea, rather than being organized into explicit basic blocks. This design offered several theoretical advantages:

• Flexible instruction scheduling: Optimizations could reorder operations freely without block boundaries.
• Better code motion: The unified graph allowed global optimizations like common subexpression elimination and loop-invariant code motion.
• Easier lowerings: High-level operations could be expanded into multiple low-level nodes without needing to restructure control flow explicitly.

Turbofan successfully addressed many of Crankshaft’s shortcomings. It introduced robust try-catch handling, improved asm.js performance, and reduced the number of bailouts. However, the Sea of Nodes came with its own set of trade-offs, which over time prompted the team to reconsider.

The Shift to Turboshaft: A Return to CFG

Three years ago, V8 began developing Turboshaft, a new IR that reverts to a traditional CFG structure. Several practical reasons drove this decision:

• Simpler maintenance: The Sea of Nodes’ global graph is conceptually elegant but hard to debug and extend. CFG-based IRs are more intuitive for compiler engineers and easier to optimize incrementally.
• Better performance for modern workloads: Turboshaft’s CFG design enables faster compilation times and more predictable code generation, which matters for large JavaScript applications.
• Enhanced parallelism: CFG-based pipelines can more easily leverage multi-threading during compilation, a key requirement for today’s multicore processors.
• Reduced memory overhead: The Sea of Nodes consumed significant memory for graph metadata; Turboshaft’s representation is leaner.

Today, the entire JavaScript backend of Turbofan runs on Turboshaft, and WebAssembly uses Turboshaft throughout its entire pipeline. Only two parts of the old system still use SoN: the builtin pipeline (being gradually replaced) and the frontend of the JavaScript pipeline (being replaced by Maglev, another CFG-based IR developed for mid-tier optimization).

Current Status and Future Outlook

The migration to Turboshaft is nearly complete. The V8 team has achieved:

• All JavaScript optimization passes now run on Turboshaft.
• WebAssembly compilation is entirely CFG-based, simplifying the codebase.
• Maglev, a new CFG-based mid-tier compiler, supersedes Turbofan’s frontend, further reducing reliance on SoN.

The remaining Sea of Nodes components are being actively phased out, with no plans to retain them long-term. This transition reflects a broader trend in compiler design: while innovative IRs like SoN can unlock new optimizations, production compilers often benefit from the simplicity and engineering efficiency of well-trodden paths like CFG.

Conclusion

V8’s journey from Crankshaft to Turbofan (Sea of Nodes) and now to Turboshaft (CFG) illustrates the constant balancing act between innovation and practical engineering. The Sea of Nodes served its purpose in pushing the boundaries of JIT compilation, but Turboshaft’s pragmatism delivers faster iterations, easier maintenance, and reliable performance gains. As V8 continues to evolve, its compiler stack becomes increasingly robust, ensuring that JavaScript and WebAssembly remain fast and efficient for the years to come.