Inside V8's JSON.stringify Speedup: How We Doubled Performance

Introduction

JSON.stringify is a fundamental JavaScript function that serializes objects into JSON strings. Its performance directly impacts activities like sending data over the network, saving to localStorage, or caching responses. A faster JSON.stringify leads to snappier user interactions and more responsive web apps. We're excited to share how a recent engineering effort in V8 made JSON.stringify more than twice as fast. This article breaks down the technical optimizations behind this improvement.

Inside V8's JSON.stringify Speedup: How We Doubled Performance — Source: v8.dev

The Foundation: A Side-Effect-Free Fast Path

The core of this optimization is a new fast path built on a simple premise: if we can guarantee that serializing an object won't trigger any side effects, we can use a much faster, specialized implementation. A side effect includes any action that breaks the simple, streamlined traversal of an object, such as executing user-defined code during serialization or triggering garbage collection cycles. For more details on what constitutes a side effect and how you can design objects to avoid them, see the Limitations section.

As long as V8 can determine that serialization will be free from these effects, it stays on the highly-optimized fast path. This allows the engine to bypass many expensive checks and defensive logic required by the general-purpose serializer, resulting in significant speedups for the most common JavaScript objects—plain data containers like dictionaries and arrays.

Iterative vs Recursive: A Key Architectural Change

Another key improvement is that the new fast path is iterative, unlike the recursive general-purpose serializer. This architectural choice eliminates the need for stack overflow checks and enables quick resumption after encoding changes. More importantly, developers can now serialize significantly deeper nested object graphs than before, since the iterative approach uses heap-allocated structures instead of the call stack.

Optimizing String Serialization: One-byte and Two-byte Specialization

Strings in V8 can be represented with either one-byte or two-byte characters. If a string contains only ASCII characters, it is stored as a one-byte string using 1 byte per character. However, a single non-ASCII character forces the entire string to use a 2-byte representation, doubling memory usage.

To avoid constant branching and type checks in a unified implementation, the entire stringifier is now templatized on the character type. This means we compile two distinct, specialized versions of the serializer: one completely optimized for one-byte strings and another for two-byte strings. While this increases binary size, the performance gains are well worth it.

Handling Mixed Encodings and Fallbacks

During serialization, we must inspect each string's instance type to detect representations that cannot be handled on the fast path (like ConsString, which may trigger a GC during flattening). These cases require a fallback to the slow path. The templatized approach allows efficient checks at runtime, ensuring that the majority of strings (which are one-byte) benefit from the streamlined handler, while falling back gracefully for two-byte or complex strings.

Limitations and Future Work

The fast path is only activated when V8 can prove no side effects will occur. This means objects with custom toJSON methods, getters, or proxies fall back to the slow path. Additionally, objects that trigger GC during serialization (e.g., via internal flattening of certain string types) are also excluded. We continue to explore ways to broaden the fast path while maintaining correctness. For now, developers can maximize performance by structuring data as plain objects and arrays with primitive values.

These optimizations are already available in the latest V8 release and will be included in Chrome and Node.js after the respective release cycles. The result is a measurably faster JSON.stringify that benefits virtually every web application.

Tags: