V8 Engine's JSON.stringify Gets 2x Speed Boost in Latest Update

In a major development for web performance, the V8 JavaScript engine has achieved a more than twofold speed increase for the core function JSON.stringify, according to a blog post from the Chrome V8 team. The optimization directly improves data serialization speed for common web operations, from network requests to local storage.

“This is one of the most significant performance improvements we’ve made to a single built-in function in years,” said a V8 engineer involved in the project. “Faster JSON.stringify means faster page loads and snappier interactions for millions of users.”

The Optimization: A Side-Effect-Free Fast Path

The core breakthrough is a new side-effect-free fast path. V8 can now use a highly specialized serializer when it is guaranteed that no side effects—such as user-defined code, garbage collection triggers, or other interruptions—will occur during serialization.

“By avoiding expensive runtime checks and defensive logic, we unlock a streamlined, iterative traversal,” the engineer explained. “This not only speeds up the process but also allows us to handle much deeper nested object graphs without stack overflow worries.”

The fast path is iterative rather than recursive, eliminating the need for stack overflow checks and enabling faster resumption after encoding changes. Developers can now serialize objects with unprecedented depth.

String Handling Gets a Specialized Makeover

V8 also tackles string representation inefficiency. Strings in V8 can be stored as one-byte (ASCII) or two-byte (Unicode) characters. Previously, the serializer used a unified approach that constantly branched between the two, slowing performance.

Now, the stringifier is templatized on the character type, compiling two separate serializers—one for one-byte and one for two-byte strings. “This lets each path be fully optimized for its specific encoding,” said the V8 team. “The binary size increase is a trade-off we’re happy to make for the speed gains.”

The implementation also efficiently handles mixed encodings during serialization by inspecting each string’s instance type and falling back to the slow path only when necessary (e.g., for ConsString objects that might trigger garbage collection).

Background

JSON.stringify is a fundamental JavaScript function that converts JavaScript objects into JSON strings. It is used everywhere on the web: serializing data for API calls, saving user preferences to localStorage, transmitting data between server and client, and more. Because it is called so frequently, even small performance gains can have a broad impact on user experience.

V8 is the JavaScript engine powering Google Chrome and many other browsers, Node.js, and Electron applications. The engine’s performance directly affects the responsiveness of a huge portion of the modern web.

What This Means

For web developers, this optimization means that applications relying on JSON.stringify will see tangible improvements in speed and responsiveness without any code changes. Complex data serialization that was once a bottleneck will now complete in roughly half the time.

“Users will notice faster page interactions, especially on data-heavy apps like dashboards, real-time collaboration tools, and e-commerce sites,” the V8 engineer noted. “This is a win for everyone—no developer effort required.”

The faster serializer also benefits Node.js backends, where JSON serialization is common for REST APIs and WebSocket messages. The improvements will roll out automatically in Chrome and updates to Node.js.

For those curious about deeper technical details, the V8 team has published limitations and side-effect triggers to help developers ensure they stay on the fast path.

This post was updated to reflect the exact performance gains.