Introduction
JSON.stringify is a core JavaScript function that serializes data into a JSON string. Its performance directly impacts common tasks like sending data over the network or storing data in localStorage. A faster JSON.stringify leads to quicker page interactions and more responsive applications. That's why we're excited to share that a recent engineering effort has made JSON.stringify in V8 more than twice as fast. This article breaks down the technical optimizations behind this improvement.
The Core Optimization: A Side-Effect-Free Fast Path
The foundation of this speedup is a new fast path built on a simple premise: if we can guarantee that serialization will not trigger any side effects, we can use a much faster, specialized implementation. A side effect is anything that breaks the simple, streamlined traversal of an object — including executing user-defined code during serialization or even subtle internal operations that could trigger garbage collection. For more details on what exactly can cause side effects and how to avoid them, see Limitations.
As long as V8 can determine that serialization will be free from these effects, it stays on this highly optimized path. This allows it to bypass many expensive checks and defensive logic required by the general-purpose serializer, resulting in a significant speedup for the most common types of JavaScript objects that represent plain data.
Iterative Over Recursive
Furthermore, the new fast path uses an iterative approach instead of the recursive general-purpose serializer. This architectural choice eliminates the need for stack overflow checks and makes it easier to resume after encoding changes. As a result, developers can now serialize much deeper nested object graphs than before — without hitting recursion limits.
Optimizing String Handling
Strings in V8 can be represented as 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, if a string contains a single non-ASCII character, all characters switch to a 2-byte representation, effectively doubling memory usage.
To avoid constant branching and type checks, the entire stringifier is now templatized on the character type. This means V8 compiles 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 slightly, the performance gain is well worth it.
The implementation also handles mixed encodings efficiently. During serialization, each string's instance type is inspected to detect representations that cannot be handled on the fast path (like ConsString, which might trigger garbage collection during flattening). Those cases fall back to the slow path, but the overhead is minimal since most real-world strings are one-byte.
Limitations and Best Practices
The new fast path works best for plain objects and arrays without custom toJSON methods, getters, or other side-effect-inducing features. If your objects include such elements, V8 will fall back to the slower path. To maximize performance, keep your data structures simple and avoid triggering side effects during serialization.
Conclusion
These optimizations — the side-effect-free fast path, iterative traversal, and templatized string handling — combine to make JSON.stringify in V8 more than twice as fast. This translates into real-world performance gains for web applications, from faster API calls to smoother local storage operations. By understanding and leveraging these improvements, developers can build even more responsive applications.