easyjson

Analyzes Go struct definitions at build time and generates specialized MarshalEasyJSON methods that serialize structs to JSON without runtime reflection. The generator parses Go source files, identifies target structs (via tags or -all flag), and emits optimized marshaling code to *_easyjson.go files. This eliminates the reflection overhead of encoding/json by pre-computing type layouts and field orderings during compilation.

Generates specialized UnmarshalEasyJSON methods that deserialize JSON into Go structs using a custom lexer instead of reflection. The unmarshaler generator creates type-aware parsing code that directly populates struct fields, leveraging the jlexer component for efficient token extraction. This approach performs 5-6x faster than encoding/json while reducing allocations by ~40% through minimal validation and direct field assignment.

Enables transparent code generation integration into Go's standard build process through go:generate directives embedded in source files. Developers add //go:generate easyjson -all comments to Go files, and the go generate command automatically runs the easyjson tool before compilation. This integrates code generation seamlessly into existing build pipelines without requiring custom build scripts or Makefiles.

Includes extensive unit tests covering struct marshaling/unmarshaling, edge cases (unknown fields, null values, custom types), and performance benchmarks comparing easyjson against encoding/json and ffjson. The test suite validates correctness across different struct types, field configurations, and JSON inputs, while benchmarks quantify performance gains (3-6x faster marshaling, 5-6x faster unmarshaling) and allocation reductions (~40-55%).

Implements jlexer, a high-performance JSON tokenizer that extracts typed values from JSON input with minimal memory allocations and validation overhead. Unlike the standard library's fully-validating parser, jlexer performs just-enough validation to correctly parse input while skipping unnecessary checks. It directly extracts integers, floats, strings, and booleans into Go types, with optimizations for string handling and buffer reuse through sync.Pool.

Implements jwriter, a high-performance JSON serialization component that writes Go data structures to JSON with optimized buffer management and direct output streaming. The writer uses a buffer pool allocating memory in increasing chunks (128 to 32768 bytes) with sync.Pool reuse for chunks ≥512 bytes, reducing garbage collection pressure. It supports direct output to HTTP response writers and other io.Writer targets, with specialized string handling optimizations.

Provides declarative struct field-to-JSON mapping through Go struct tags (json, easyjson) with support for custom field names, omitempty, and unknown field handling strategies. The code generator analyzes struct definitions and produces field mapping code that handles renaming, optional fields, and configurable behavior for unexpected JSON fields (ignore, error, or store). This enables flexible JSON serialization/deserialization without manual field mapping code.

Provides built-in support for optional/nullable types in JSON through special handling of pointer types, custom optional wrappers, and null value semantics. The code generator produces marshaling code that omits null pointers from JSON and unmarshaling code that correctly handles null values by setting pointers to nil. This enables clean representation of optional fields without manual null checking or wrapper types.

Implements string interning optimization that deduplicates repeated string values during JSON unmarshaling, reducing memory allocations when parsing JSON with many identical strings (e.g., repeated field names or enum values). The unmarshaler caches previously-seen strings and reuses pointers to identical values, leveraging Go's string interning semantics to reduce heap pressure and improve cache locality.

Enables JSON marshaling and unmarshaling of maps with non-string key types (int, float, custom types) by generating type-specific key conversion code. The code generator produces marshaling code that converts map keys to JSON-compatible strings and unmarshaling code that parses string keys back to the original type. This allows maps with typed keys to be serialized to JSON while maintaining type safety.

Provides an easyjson command-line tool that analyzes Go source files and generates marshaling/unmarshaling code for selected structs. The tool supports multiple selection modes: explicit //easyjson:json tags on structs, -all flag to generate for all structs, or -type flag to specify individual struct names. Generated code is written to *_easyjson.go files in the same package, integrating seamlessly into Go build pipelines.

Optimizes concurrent JSON serialization through buffer pooling and allocation strategies that scale efficiently across multiple goroutines. The sync.Pool-based buffer reuse and tiered allocation chunks (128-32768 bytes) minimize contention and per-operation allocations even under high concurrency. Benchmarks show 6-7x faster concurrent marshaling than encoding/json due to these optimizations.