6 Game-Changing Optimizations That Made JSON.stringify Twice as Fast

JSON.stringify is one of the most frequently called functions in JavaScript, powering everything from API requests to local storage saves. Its speed directly impacts how snappy your web app feels. Recently, V8 engineers achieved a remarkable feat: they made JSON.stringify more than twice as fast. This wasn't a single tweak—it was a series of clever optimizations that reworked the serializer from the ground up. In this article, we'll break down the six key improvements that drove this performance leap. Each optimization is a lesson in low-level JavaScript engine design, and understanding them can help you write code that runs faster today.

1. The Side-Effect-Free Fast Path

The cornerstone of the speedup is a dedicated fast path that kicks in when serialization is guaranteed to have no side effects. A side effect here means anything that might alter program state or trigger garbage collection—like calling user-defined toJSON methods, encountering getters that mutate data, or dealing with Proxy objects. By detecting that an object is a plain data container (no custom serialization logic, no tricky properties), V8 can skip all the defensive checks the general serializer needs. This fast path is iterative rather than recursive, which eliminates stack overflow checks and allows resumption after encoding changes. For the vast majority of objects—simple POJOs, arrays of primitives—this path delivers a dramatic speed boost without compromising correctness.

2. Iterative Instead of Recursive Traversal

The original JSON.stringify used a recursive algorithm, which meant every nested object or array required a new stack frame. That brought overhead: stack overflow checks, function call costs, and a hard limit on nesting depth. The new implementation is iterative, using an explicit stack managed by the engine. This change alone reduces overhead significantly. It also means you can serialize deeply nested object graphs—think hundreds of levels—that previously would have thrown a stack overflow error. The iterative approach pairs naturally with the fast path: once inside it, the serializer can process the entire object tree in a tight loop, pausing only when it hits a construct that requires the slow path. For developers, this translates to better reliability and faster serialization of complex data.

3. Templatized String Handling (One-Byte vs Two-Byte)

V8 stores strings in two internal representations: one-byte (for ASCII-only strings) and two-byte (for strings with characters outside ASCII). Previously, the serializer had to check the string type on every character and branch accordingly. Now, the entire stringify function is templatized on the character width. That means V8 compiles two separate, highly optimized versions: one that assumes all strings are one-byte, and another for two-byte. This eliminates branching and type-checking during the hot loop. The cost is a modest increase in binary size (two copies of the code), but the performance gain—especially for ASCII-heavy payloads like JSON from most web APIs—is well worth it.

4. Efficient Handling of Mixed Encodings

In real-world data, strings often mix ASCII and Unicode characters. The templatized approach still needs to handle these cases gracefully. During serialization, V8 inspects each string's instance type to detect representations that aren't handled on the fast path—like ConsString (a concatenated string that might trigger GC during flattening). If a string contains only one-byte characters, the one-byte specialized serializer runs. If it hits a two-byte character, it falls back to the two-byte version. This check-and-branch is still faster than the old generic code because the inner loops are now branch-free. The check is also combined with the existing type-inspection V8 already does, so there's minimal extra cost.

5. Avoiding Garbage Collection from ConsString

V8 uses a variety of string representations for efficiency. ConsString is a tree of string fragments that avoids copying when concatenating. However, flattening a ConsString (needed for JSON output) can trigger garbage collection, which is a side effect. The old serializer had to handle this generically, often causing GC pauses. The new design detects ConsString early and immediately routes it to a slow path that flattens the string in a controlled way—or, better yet, avoids flattening altogether by serializing the fragments directly. By treating ConsString as a side effect that forces a path change, V8 keeps the fast path pure and GC-free. This reduces jank and makes serialization more predictable.

6. Real-World Impact and How to Benefit

These optimizations aren't just theoretical—they make a real difference. Benchmarks show that for typical JavaScript objects (nested JSON with ASCII strings), the new JSON.stringify is 2x to 3x faster than before. Complex nested structures that previously hit recursion limits now serialize without error. But there's a catch: the fast path only works for objects that don't trigger side effects. To get the full benefit, avoid custom toJSON methods, getters that mutate state, Proxy wrappers, and properties with Symbol.toPrimitive. Stick to plain objects, arrays, numbers, strings, booleans, and null. Also minimize deeply nested ConsString trees by concatenating strings with template literals rather than the + operator in tight loops. By writing side-effect-free data structures, you let V8 stay on the fast path and enjoy the full speed boost.

These six optimizations show how deep engine-level work can dramatically improve a fundamental JavaScript function. The next time you call JSON.stringify, know that under the hood, V8 is running a highly tuned, branch-free, iterative machine that's twice as fast as it used to be. To stay ahead, keep your serialization data simple and side-effect-free—and let V8 do the heavy lifting.