JSON.stringify is a fundamental JavaScript tool for converting objects into JSON strings. Its performance is critical for everything from API calls to caching data. Recently, the V8 team achieved a remarkable more-than-doubling of its speed. This Q&A dives into the technical changes behind this improvement, explaining how V8 now handles serialization much more efficiently.
How much faster is JSON.stringify now?
V8's optimizations have made JSON.stringify more than twice as fast for common use cases. This means that operations like serializing a large object for a network request or storing complex data in localStorage can complete in less than half the time. The improvement is especially noticeable for plain data objects—those without custom toJSON methods or getters that might trigger side effects. In typical web applications, this speedup translates to snappier page interactions and reduced latency.
What is the “side-effect-free fast path”?
At the core of the improvement is a new fast path that V8 takes when it can guarantee serialization won't cause side effects. A side effect is anything that interferes with straightforward traversal—like executing user-defined code (e.g., toJSON or getters) or triggering garbage collection. When no such risks exist, V8 uses a highly optimized, specialized serializer that skips many safety checks. This fast path is designed for the most common scenario: serializing plain objects and arrays. It eliminates branching and defensive logic, yielding a dramatic speed boost. You can find detailed conditions for when the fast path is active in the Limitations section.
Why did switching from recursive to iterative help?
The original serializer used recursion, which required checking for stack overflow on every nested call and made resumption after encoding changes tricky. The new fast path is iterative, meaning it uses an explicit stack (or queue) instead of the call stack. This architectural shift brings two key benefits: no stack overflow checks are needed for deep nesting, and V8 can quickly resume after switching encoding modes. Additionally, developers can now serialize much deeper object graphs without hitting recursion limits. The iterative approach also simplifies memory management, contributing to the overall speedup.
How are different string representations handled?
V8 stores strings as either one-byte (ASCII characters, 1 byte per char) or two-byte (including non-ASCII characters, 2 bytes per char). Previously, the serializer used a unified code path that constantly branched between these types. Now, the stringifier is templatized on character width—two distinct versions of the serializer are compiled: one optimized for one-byte strings, another for two-byte strings. While this increases binary size, the performance gain is substantial because each version avoids type checks and branches. During serialization, V8 inspects each string's instance type once to decide which template to use, ensuring efficient handling of mixed encodings without overhead.
What about ConsStrings and other complex string types?
V8 internally represents strings using various subtypes, including ConsString (concatenated strings), SlicedString, and others. The fast path must quickly detect these types because flattening a ConsString (to a contiguous buffer) might trigger garbage collection—a side effect that would break the fast path. During serialization, when V8 inspects the string's instance type to decide the encoding template, it also checks for these “dangerous” types. If a ConsString or similar is found, V8 falls back to the slower, general-purpose serializer to handle the side effect safely. This ensures correctness while still letting the vast majority of simple strings stay on the fast path.
Are there any limitations to the new fast path?
Yes, the fast path is only active when serialization is guaranteed free of side effects. Common situations that disable it include: objects with toJSON methods, objects with getters, Proxy objects, arrays with non-standard indexing (e.g., holes that trigger getters), and objects that contain ConsString or ExternalString references (which may require GC). In those cases, V8 reverts to the older, fully safe serializer—still correct, but slower. However, the vast majority of everyday JSON.stringify calls involve plain objects and strings, so most users will see the full speedup.