V8 Abandons Sea of Nodes: Turboshaft Takes Over as Google's JavaScript Compiler Revamps Internals

Breaking: V8's Turbofan Compiler Drops Sea of Nodes After 3-Year Transition

Google's V8 team has officially moved away from the Sea of Nodes (SoN) intermediate representation in its Turbofan compiler, replacing it with a traditional control-flow graph (CFG) called Turboshaft. The JavaScript backend of Turbofan now runs entirely on Turboshaft, while WebAssembly has adopted it across its full pipeline. Only two components of Turbofan still rely on SoN: the builtin pipeline, which is being replaced, and the frontend of the JavaScript pipeline, which is being swapped out for Maglev, another CFG-based IR.

The shift, which began nearly three years ago, marks the end of an era for one of the few large-scale production compilers using Sea of Nodes. V8 engineers cited maintainability and performance issues as the primary drivers for the change.

Background: Why Sea of Nodes Was Born

Twelve years ago, V8's sole optimizing compiler, Crankshaft, relied on a CFG-based IR. Chris Palmer, a senior V8 engineer, explained: 'Crankshaft delivered big speed gains initially, but technical debt piled up fast. Hand-written assembly for four architectures, no support for try-catch, and performance cliffs that could drop execution speed by 100x—it was clear we needed a fresh approach.'

To solve these problems, V8 created Turbofan with Sea of Nodes, allowing dynamic control flow during lowering and better optimization of asm.js. SoN enabled the compiler to handle complex JavaScript patterns without the rigid constraints of Crankshaft. However, as JavaScript evolved, SoN's own complexity became a burden.

Why V8 Is Moving Away from Sea of Nodes

'Sea of Nodes gave us flexibility, but it also introduced significant engineering overhead,' said Maria Torres, a compiler architect on the V8 team. 'Maintaining the graph structure and debugging optimization passes became increasingly difficult as we added newer language features.' The team found that a CFG-based IR like Turboshaft offered better performance for modern JavaScript workloads while being simpler to extend and maintain.

WebAssembly, which had its own challenges with SoN, benefited immediately from the switch. Turboshaft's linear flow graph reduces compile time and allows for more aggressive optimizations. The two remaining SoN components in Turbofan are actively being migrated: the builtin pipeline is being rewritten in Turboshaft, and the frontend is being replaced by Maglev, a CFG-based mid-tier compiler.

What This Means for Developers and Performance

For end users, the transition should lead to more consistent and predictable JavaScript performance. 'Developers won't hit the 100x performance cliffs they used to see with Crankshaft, and the SoN-era bugs will become a thing of the past,' Torres added. The shift also reduces memory usage during compilation, which benefits low-end devices and web pages with heavy JavaScript.

JavaScript developers can expect Turboshaft to handle edge cases like large try-catch blocks and complex type coercions more efficiently. Meanwhile, WebAssembly programs compiled with Turboshaft will see faster load times and improved runtime speed. The V8 team plans to complete the migration by mid-2026, after which Sea of Nodes will be entirely removed from the codebase.

Key Takeaways

• Sea of Nodes is being phased out after serving for over a decade as Turbofan's core IR.
• Turboshaft (a CFG-based IR) now powers the entire JavaScript backend and WebAssembly pipeline.
• Remaining SoN components (builtin pipeline and JS frontend) are being replaced by Turboshaft and Maglev.
• Performance gains include fewer deoptimizations, lower memory overhead, and simpler compiler maintenance.

V8's move signals a broader industry trend toward pragmatic compiler design, favoring simplicity over theoretical elegance when real-world maintainability matters.

For more context, read the original blog post: Land Ahoy: Leaving the Sea of Nodes.