How to migrate from encoding/json to Sonic?

Use sonic.Marshal and sonic.Unmarshal as drop-in replacements, but note default differences like no HTML escaping. Enable ConfigStd for full compatibility or adjust options like EscapeHTML and SortKeys as needed from the README.

Sonic vs go-json: which is faster?

Sonic consistently outperforms go-json in benchmarks, especially with JIT and SIMD optimizations. For example, decoding benchmarks show Sonic is 2-3x faster in generic scenarios, as detailed in the medium JSON benchmark results.

Does Sonic validate JSON syntax?

Yes, Sonic validates JSON by default and returns decoder.SyntaxError with pretty-printed error positions. However, you can disable validation for speed with options like NoValidateSkipJSON, as mentioned in the tips section.

How to handle large JSON files with Sonic?

Use streaming IO with NewDecoder from io.Reader or NewEncoder to io.Writer to process data in chunks, reducing memory footprint. Also, consider Pretouch for huge schemas to avoid runtime compilation delays.

What are the memory implications of using Sonic's ast.Node?

ast.Node references the original JSON buffer for strings without escapes, saving CPU but increasing memory usage. Use CopyString option or LoadAll() for concurrent safety, but this may reduce performance as noted in the tips.

Can Sonic work with custom JSON marshallers like encoding.TextMarshaler?

Yes, but by default Sonic quotes and escapes their output for security, which hurts performance. Enable encoder.NoQuoteTextMarshaler to skip this, but you must ensure RFC8259 compliance manually.

Open-Awesome

sonic

Apache-2.0Gov1.15.0

A blazingly fast JSON serializing & deserializing library for Go, accelerated by JIT and SIMD.

GitHub

9.6k stars464 forks0 contributors

What is sonic?

Sonic is a JSON serializing and deserializing library for the Go programming language. It is engineered for maximum performance, utilizing JIT compilation and SIMD instructions to significantly outperform standard and other third-party JSON libraries. It solves the problem of JSON processing being a bottleneck in high-throughput Go applications.

Target Audience

Go developers building high-performance services, APIs, or data processing pipelines where JSON serialization/deserialization speed is critical.

Value Proposition

Developers choose Sonic because it consistently delivers the fastest JSON processing speeds for Go, as demonstrated by extensive benchmarks. It provides a powerful AST for flexible JSON manipulation and offers both easy migration from `encoding/json` and advanced APIs for optimization.

Overview

A blazingly fast JSON serializing & deserializing library

Use Cases

Best For

Microservices and APIs requiring ultra-fast JSON request/response handling
Data processing pipelines that parse large volumes of JSON data
Replacing `encoding/json` in existing Go projects for a significant performance boost
Applications needing to manipulate JSON structures without a fixed schema using an AST
Scenarios where JIT and SIMD optimizations can be leveraged on supported CPU architectures (AMD64, ARM64)
Streaming JSON encoding/decoding to reduce memory footprint

Not Ideal For

Projects requiring strict RFC8259 compliance by default, as Sonic disables HTML escaping and sort keys for performance
Environments with unsupported Go versions (below 1.18 or above 1.26) or non-AMD64/ARM64 CPU architectures
Applications where minimal memory overhead is critical, as Sonic's memory pool can increase in-use memory under high load
Teams needing simple drop-in JSON handling without advanced tuning, due to features like pretouch and config options adding complexity

Pros & Cons

Pros

Blazing Fast Performance

Benchmarks show Sonic outperforms stdlib, jsoniter, and go-json across all JSON sizes and scenarios, leveraging JIT and SIMD for speed.

Flexible JSON Manipulation

Provides ast.Node APIs for searching, modifying, and serializing JSON without a fixed schema, enabling runtime binding and partial parsing.

Streaming IO Support

Decodes from io.Reader and encodes to io.Writer, reducing memory consumption for handling large or multiple JSON values efficiently.

Advanced Error Reporting

Offers pretty-printed syntax and mismatch type errors with detailed position information, easing debugging compared to standard libraries.

Cons

Compatibility Deviations

Default settings skip HTML escaping and sort keys to boost speed, breaking RFC8259 compliance and requiring explicit options for alignment with encoding/json.

Environment Limitations

Restricted to Go 1.18-1.26 and AMD64/ARM64 CPUs, with issues like Go1.24.0 unsupported without build flags, limiting portability.

Memory Management Overhead

Uses memory pools that can spike in-use memory under load, necessitating careful configuration with options like CopyString or buffer size controls.

Frequently Asked Questions

Related Projects

viper

Go configuration with fangs

Stars30,373

Forks2,173

Last commit6 months ago

godotenv

A Go port of Ruby's dotenv library (Loads environment variables from .env files)

Stars10,548

Forks456

Last commit8 days ago

env

A simple, zero-dependencies library to parse environment variables into structs

Stars6,271

Forks281

Last commit17 days ago

envconfig

Golang library for managing configuration data from environment variables

Stars5,457

Forks393

Last commit1 year ago

Community-curated · Updated weekly · 100% open source

Found a gem we're missing?

Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.

Submit a project Star on GitHub