v2.0.2 update go.mod

> Gemini 2.5 generated this response due to high traffic on Gemini 3

refactor: update module path to v2

v1.8.0

Here is a concise commit message summarizing the changes in the diffs:

refactor: simplify `fastParseFloat` using `strconv.ParseFloat`

- Replace the custom loop-based float parsing logic with `strconv.ParseFloat`.
- Utilize `unsafe.String` for zero-allocation byte slice to string conversion before parsing.
- Add `strconv` to the package imports.

Release v2.0.0: Go Modules v2 & Extreme Performance 🚀

This major release upgrades the library to module path v2 and introduces significant performance optimizations and new features for high-performance systems.

⚡ What's New

• Go Modules v2: Updated the module path to github.com/GenshIv/silentjson/v2 to comply with Go semantic versioning standards.
• Shared Memory (SHM) Integration: Added support for parsing JSON directly from Shared Memory (via mmap) with zero heap allocations. Perfect for ultra-low latency Inter-Process Communication (IPC).
• Zero-Allocation Marshaling: Introduced MarshalSlice and Marshal functions with buffer reuse support. Now JSON generation is as efficient as parsing.
• Scalar Parser Optimization: Deep refactoring of the Pure Go (scalar) parser. Performance increased to 829 MB/s, outperforming JIT-based parsers like Sonic even on hardware without AVX2 support.
• Improved ARM64 Support: Stabilized performance and fallbacks for Apple Silicon and ARM-based servers.

📊 Benchmarks (Ryzen 9 7950X3D)

Library	Mode	Throughput	Memory Allocs
SilentJSON v2	AVX2 (Parallel)	24,670 MB/s 👑	27
SilentJSON v2	Scalar (Pure Go)	810 MB/s	29
Sonic	AVX2 (JIT)	644 MB/s	10,002
Standard (encoding/json)	Pure Go	110 MB/s	509,997

⚠️ Migration Guide

To upgrade to v2.0.0, update your import paths:

import "github.com/GenshIv/silentjson/v2"

And run:

go get github.com/GenshIv/silentjson/v2

---

Full list of changes is available in CHANGELOG.md.

Release v1.6.0: ARM64 NEON Acceleration & Cleanups 🚀

This release brings hardware-accelerated SIMD parsing to ARM architectures! SilentJSON is no longer just blazing fast on Intel/AMD — it now natively leverages 128-bit NEON vector instructions on Apple Silicon (M-series) and ARM-based servers (like AWS Graviton).

✨ New Features & Performance
Experimental ARM64 NEON Support: We've rewritten the core parsers (skipSpaceASM and findArrayElementsEarlyExitASM) in native Go ARM64 assembly using NEON vector extensions.
SIMD Fast-Path Chunking: The parser now loads 16-byte chunks into NEON registers (VLD1) and simultaneously compares them against all structural JSON characters using parallel VCMEQ and VORR masks.
O(1) Space Skipping: Implemented an innovative "shift-and-add" technique (VADDP) to extract scalar masks from 128-bit vectors, reducing massive whitespace blocks at 16 bytes per CPU cycle.
Zero-Allocation Parity: The ARM64 implementation perfectly mirrors the AMD64 AVX2 behavior, maintaining the strict zero-allocation architecture and nested state correctness.
🛠 Fixes & Chores
Cleaned up repository history: Removed obsolete v1.5.1 and v1.5.2 tags to streamline the release history.
Test Suite Cleanup: Removed temporary stream_debug files and isolated test environments.
💡 Why this matters
If you are deploying high-throughput Go services to AWS Graviton instances or developing locally on Apple Silicon, SilentJSON will now bypass the slow scalar loops entirely and jump straight into hardware-accelerated vector processing.

Note: ARM64 support is currently marked as experimental while we gather edge-case feedback from real-world production environments. AMD64 AVX2 remains stable and production-ready.

Release v1.2.2: The Streaming Update & Extreme Chunking 🚀

This major release introduces the StreamDecoder — a highly optimized suite of tools for parsing infinite JSON arrays and massive network streams without loading the entire payload into memory. It also brings unprecedented raw extraction speeds using a brand-new dedicated AVX2 assembly routine.

🌟 Key New Features

• StreamDecoder (Standard Next)
  A low-allocation stream parser that extracts and unmarshals objects sequentially from any io.Reader. Perfect for parsing multi-gigabyte files with minimal RAM footprint (~41MB) at speeds exceeding 470 MB/s.

• Zero-Allocation Async Streaming (NextChan)
  Need to process objects on the main thread while the parser runs in the background? NextChan provides asynchronous Producer-Consumer streaming. Unlike other libraries that cause massive GC pressure or data races, SilentJSON uses an internal Ring Buffer, achieving 0 GC allocations during streaming at ~378 MB/s.

• Extreme Stream Chunking (NextRawBlock)
  When you just need to slice a massive JSON array into smaller raw byte chunks (e.g., to proxy to a database or save to disk) without unmarshaling to Go structs. Powered by the new dedicated findObjectBoundariesEarlyExitASM routine, it scans and slices streams at an incredible ~4.1 GB/s with zero allocations!

🛠 Improvements & Optimizations

• Dedicated Early-Exit Assembly: Isolated the streaming assembly logic into findObjectBoundariesEarlyExitASM to ensure the core parser (UnmarshalArrayParallel) maintains its peak throughput (~3.3 GB/s) without any branching overhead.
• silent-chunker Example: Added a fully runnable, real-world utility in samples/silent-chunker/ demonstrating how to use NextRawBlock to rapidly slice massive JSON files into 10MB chunks and save them to disk.
• Documentation & Benchmarks: Completely updated README.md with new Mermaid.js charts, streaming benchmarks, and comprehensive NextRawBlock usage examples.

📊 Performance Summary (Streaming)

Feature	Throughput	Allocations
NextRawBlock (Raw chunk extraction)	~4150 MB/s	0
Next (Full Go Struct Binding)	~470 MB/s	Zero-alloc iteration
NextChan (Async Channel Ring Buffer)	~378 MB/s	Zero-alloc iteration

(Note: Standard streaming disables zero-copy strings for memory safety when reading from io.Reader buffers).

---

Upgrade today to start processing infinite JSON arrays faster than ever!

Release v1.2.1: Zero-Alloc Async Streaming & Nested Struct Slices

This release introduces major architectural improvements to stream parsing, making it incredibly powerful for high-throughput backend applications, along with enhanced structural support.

✨ New Features
Async Producer-Consumer Streaming (NextChan) We've introduced dec.NextChan(bufferSize int), a new asynchronous channel-based iterator! You can now parse infinite JSON streams on a background goroutine while your main thread processes the data concurrently.
Zero Extra Allocations: Unlike traditional libraries that suffer from massive allocations or data races when passing structs to channels, SilentJSON utilizes a highly optimized internal Ring Buffer. It reuses memory safely, keeping memory allocation locked at the exact same minimal footprint as synchronous iteration (only ~41MB under extreme load).
Throughput: Achieves ~378 MB/s with practically zero GC pressure.
Support for Nested Struct Slices Added full parsing support for []Struct types. The decoder now seamlessly handles nested arrays of complex objects using dynamic registry traversal, allowing for much deeper and richer Go struct bindings out-of-the-box.
📈 Benchmarks Update
We have updated our internal benchmarks and the README.md to include visually stunning Mermaid charts comparing streaming performance. SilentJSON now officially dominates the stream-parsing landscape in both speed and memory efficiency compared to jsoniter and the standard library.

🛠 Fixes & Improvements
Fixed an issue where nested array structures were not properly mapped during BuildRegistry.
Prevented critical data-races in channel streaming by properly sizing the ring buffer relative to the channel capacity (bufferSize + 4).

v1.2.0: Assembly Optimizations & StreamDecoder Improvements 🚀

We are excited to announce a new release of SilentJSON! This update brings significant performance improvements at the lowest level and introduces major enhancements to our streaming capabilities.

🚀 What's New
Fast Assembly Routines (fast_asm): We've introduced highly optimized assembly implementations for key parsing bottlenecks. This further reduces CPU latency and pushes our reflection-free processing speeds even higher.
Enhanced StreamDecoder Performance: The stream boundary scanner has been significantly optimized, specifically improving string skipping operations when processing infinite JSON arrays from an io.Reader.
New Benchmarks & Documentation: The README has been updated to include extensive benchmarks for the StreamDecoder. Our streaming parser now reliably hits ~477 MB/s while maintaining a strict, bounded memory footprint (e.g., 256KB buffer), easily outperforming other streaming alternatives.
🛠️ Commits Highlights
perf: Optimize stream boundary scanner string skipping.
feat: Integrate fast_asm for low-level performance boosts.
docs: Add StreamDecoder section to README with detailed benchmarks.
Full Changelog: https://github.com/GenshIv/silentjson/commits/main

update go.mod

This release introduces massive performance breakthroughs, completely rewriting the foundational scanning architecture and cementing silentjson as the fastest JSON parser in the Go ecosystem.
🔥 Key Highlights:

• AVX2 Bitmask Iterator (Tape-Scanner): Replaced scalar byte-by-byte loops with simdjson-style vectorization (VPMOVMSKB + BSFL). Structural characters are now processed in 32-byte chunks, allowing the parser to leap directly to relevant bytes.
• Unsafe Key Parsing: Eliminated bounds-checking overhead in key parsing by utilizing direct unsafe.Pointer memory casting via optimized switch statements.
• Extreme Throughput: Single-core parsing (UnmarshalSlice) now reaches ~747 MB/s. Multi-core parallel parsing (UnmarshalArrayParallel) shatters previous records, scaling perfectly to ~3347 MB/s!
• Expanded Test Coverage: Added deep error-handling tests and extensive nested structure validations.
  🚀 Benchmarks (100k complex objects):
• SilentJSON (Parallel): 3347 MB/s
• Sonic: 467 MB/s
• simdjson-go: 371 MB/s
• Standard encoding/json: 107 MB/s