V8’s JSON.stringify Speed Doubled: Inside the Optimization

Introduction

JSON.parse’s counterpart, JSON.stringify, is a workhorse of modern JavaScript. Every time you send data to a server, save state in localStorage, or transfer objects between threads, V8’s serializer is hard at work. Even a small improvement in its speed can make web applications feel significantly snappier. That’s why the V8 team recently undertook a deep optimization effort, and the result is a serializer that runs more than twice as fast as before. This article dives into the two key technical changes that made this leap possible: a side-effect-free fast path and templatized string handling.

The Side‑Effect‑Free Fast Path

Eliminating Costly Guarantees

The cornerstone of the speedup is a new fast path that V8 activates only when it can safely assume that serializing an object will not trigger any side effects. A side effect, in this context, is anything that forces the serializer to abandon its streamlined traversal: executing user‑defined code (e.g., custom toJSON methods), or even internal operations that could trigger garbage collection. As long as V8 can prove the serialization is pure, it can skip many of the expensive checks and defensive logic present in the general‑purpose serializer.

For a deeper understanding of what exactly constitutes a side effect and how to avoid them, see the Limitations section later in this article.

Iterative Instead of Recursive

The traditional serializer is recursive, which brings risk of stack overflow on deeply nested objects and forces frequent stack‑limit checks. The new fast path, by contrast, is iterative. This architectural shift eliminates both the overflow checks and allows the serializer to quickly resume after encoding changes. As a bonus, developers can now serialize object graphs that are significantly deeper than before.

Handling Different String Representations

One‑Byte and Two‑Byte Strings

V8 stores strings in two internal forms: one‑byte (for ASCII‑only strings) and two‑byte (for strings containing any non‑ASCII character). A single non‑ASCII character forces the entire string into the two‑byte representation, doubling memory usage and complicating serialization.

Previously, the serializer used a unified code path that branched on the string type at every step, adding overhead. To eliminate this, the entire stringifier was templatized on the character width. Two separate, highly optimized versions of the serializer are now compiled: one exclusively for one‑byte strings and another for two‑byte strings. Although this increases binary size, the performance gain is well worth it.

Efficient Mixed‑Encoding Handling

During serialization, V8 must examine each string’s instance type to detect representations that cannot be processed on the fast path (like ConsString, which may trigger a garbage collection during flattening). When such a string is encountered, the serializer gracefully falls back to the slower, general‑purpose path. This check is necessary and has been integrated without slowing down the common cases.

Conclusion

The combination of a side‑effect‑free iterative fast path and templatized string handling yields a dramatic speedup for V8’s JSON.stringify. For the vast majority of plain JavaScript objects—those without custom serialization logic or exotic string types—the serializer now runs more than twice as fast. This means faster page loads, snappier UI updates, and a better experience for end users. The V8 team continues to explore further optimizations, but this round represents a significant milestone for JavaScript performance.