Boosting JSON.stringify Performance in V8: A Technical Deep Dive

JSON.stringify is a fundamental JavaScript function used to serialize objects into JSON strings. Its performance directly impacts common web operations such as sending data in network requests, storing in localStorage, or transferring data between Web Workers. A faster JSON.stringify means snappier page interactions and more responsive applications. The V8 team recently achieved a major milestone: making JSON.stringify more than twice as fast. This article explores the key engineering decisions behind this improvement.

The Role of Side-Effect-Free Serialization

The cornerstone of this optimization is a new fast path that relies on a simple insight: if the serialization process can be guaranteed to produce no side effects, V8 can use a highly specialized, streamlined implementation. A "side effect" here means any operation that interrupts the straightforward traversal of an object, such as:

• Executing user-defined toJSON methods or getters
• Triggering a garbage collection cycle during property access
• Handling proxy objects that intercept property retrieval

As long as V8 can determine that a given object won’t trigger any of these operations, it can stay on the optimized fast path. This bypasses many expensive checks and defensive logic needed by the general-purpose serializer. The result is a significant speed boost for typical plain JavaScript objects, especially those used for data transfer.

Beyond the fast path itself, the new serializer adopts an iterative approach instead of the traditional recursive one. This architectural shift offers several advantages:

• It eliminates stack overflow checks, which can become a bottleneck in deep recursion.
• It allows the serializer to quickly resume after encoding changes.
• It enables developers to serialize much deeper nested object graphs without hitting stack limits.

For more details on what exactly constitutes a side effect and how developers can design objects to benefit from the fast path, see the Limitations section (note: in this article we don't have that section, but the original did).

Optimizing String Handling with Templatized Serializers

Strings in V8 can be represented in two ways: one-byte and two-byte. If a string contains only ASCII characters, it is stored as a one-byte string, using 1 byte per character. However, even a single non-ASCII character forces the entire string to be stored as a two-byte representation, doubling memory usage. Such mixed encodings are common, and the serializer must handle both efficiently.

Previously, the stringification code used conditionals and type checks to cope with both types, introducing branching overhead. To eliminate this, the entire serializer is now templatized on the character type. V8 compiles two distinct versions of the serializer:

• One version fully optimized for one-byte strings
• Another version fully optimized for two-byte strings

This approach has a known trade-off: it increases binary size because two nearly identical serializers are shipped. However, the V8 team judged that the substantial performance gains—especially for the most common plain data objects—outweigh the added code footprint.

During serialization, V8 must already inspect each string’s instance type to detect representations that cannot be handled on the fast path (for example, ConsString representations that might trigger garbage collection during flattening). That necessary check now also selects the correct templatized serializer, so no extra work is added. The result is a seamless, branch-predictor-friendly flow that speeds up string serialization considerably.

Combined Impact of Both Optimizations

Together, these two changes—the side-effect-free fast path and the templatized string handling—cut the time for JSON.stringify in half for typical workloads. The improvement is especially visible in frameworks and applications that heavily use plain objects for data transfer, such as React, Angular, or REST API calls.

Developers can further benefit by ensuring their data objects are free of getters, custom toJSON methods, and proxies. This keeps V8 on the fast path and maximizes performance.