JSON.stringify is a core JavaScript function that powers data serialization across the web. Whether you're sending data to a server or storing it locally, its speed directly impacts application responsiveness. The V8 team recently achieved a stunning performance improvement—making JSON.stringify more than twice as fast. This article breaks down the key optimizations in a Q&A format, explaining how a side-effect-free fast path, iterative architecture, and templatized string handling combine to deliver this leap in speed.
1. Why did JSON.stringify get more than twice as fast?
The main driver was a new fast path that avoids costly side-effect checks. V8's original serializer always assumed the worst case—it had to guard against user-defined code during serialization, garbage collection triggers, and other overheads. The fast path, by contrast, is only used when V8 can prove that no side effects will occur. This lets it skip many expensive branching checks, resulting in a dramatic speedup for the most common use cases—plain objects without custom toJSON methods or getters.
2. What exactly are “side effects” in this context?
Side effects are any actions during serialization that break the simple traversal of an object. The obvious ones include executing user-defined code (like custom toJSON or getters) that could modify external state. But more subtle triggers also count: for example, operations that force a garbage collection cycle, such as flattening certain string representations (like ConsString). The fast path requires a guarantee that none of these will happen, allowing V8 to use an extremely streamlined code path. If any such side effect is detected, the engine falls back to the general-purpose serializer.
3. Why did switching from recursive to iterative help?
The original general-purpose serializer was recursive, which meant it needed stack overflow checks for deeply nested objects. The new fast path is iterative, eliminating those checks entirely. This architectural change not only makes serialization faster by reducing per-call overhead, but also raises the depth limit for object graphs. Developers can now serialize significantly deeper nested structures without hitting recursion limits. Additionally, an iterative approach makes it easier to resume after encoding changes, further boosting performance.
4. How are different string representations handled for speed?
V8 stores strings in two internal formats: one-byte for ASCII-only content (1 byte per character) and two-byte for Unicode characters outside ASCII (2 bytes per character). A single non-ASCII character forces the whole string to use two-byte representation, doubling memory usage. To avoid constant branching during serialization, the team templatized the stringifier on the character type. This means two separate, fully optimized versions of the serialization logic are compiled: one for one-byte strings and one for two-byte. While this increases binary size slightly, the performance gain is well worth it.
5. What about mixed encodings—how are they handled efficiently?
During serialization, V8 must inspect each string's instance type anyway to detect representations that might trigger side effects (like ConsString). That necessary check is reused to determine the character width. By already examining the type, the engine can seamlessly switch between the one-byte and two-byte optimized code paths without extra work. This design ensures that even objects containing strings of different encodings are processed efficiently, with no redundant branching or memory overhead.
6. Are there limitations to the new fast path?
Yes—the fast path is only active when V8 can be certain of no side effects. This means objects with custom toJSON, getters that trigger code execution, or certain internal string types (like ConsString requiring flattening) will fall back to the slower general serializer. Developers who want to stay on the fast path should avoid these patterns when performance is critical. The team's documentation provides detailed guidance on what exactly breaks the optimization and how to design data objects accordingly.