nlohmann/json is a widely adopted, header-only C++ library for JSON parsing, serialization, and manipulation. It provides a single-header `json.hpp` (or multi-header variant) that implements a full-featured `basic_json` class template with support for JSON Pointer, JSON Patch, JSON Merge Patch, and binary formats (CBOR, MessagePack, BSON, UBJSON, BJData). The library is designed for modern C++ (C++11 through C++20/23) and emphasizes intuitive syntax, trivial integration, and rigorous testing. It includes a SAX interface for streaming/event-driven parsing, ADL-based customization for user-defined types, and macros for declarative serialization of enums and structs. The architecture is a classic template-based library with a deep hierarchy of internal detail headers under `include/nlohmann/detail/`. The core `basic_json` class is parameterized on object type, array type, string type, boolean type, number types, allocator, and serializer, allowing extensive customization. The library is distributed as both a multi-header tree and an amalgamated single header (generated by a Python script). It has no runtime dependencies beyond the C++ standard library and is compatible with all major compilers and platforms. Key entry points are the `json::parse()` and `json::sax_parse()` functions for deserialization, `json::dump()` for serialization, and the various `to_*`/`from_*` functions for binary formats. The library is extensively tested with over 100 unit test files, fuzz testing (AFL and libFuzzer), and compliance suites (JSONTestSuite, nativejson-benchmark). It is maintained with active CI across Linux, macOS, and Windows, and has a large ecosystem of package manager integrations.
orjson is a high-performance JSON serialization and deserialization library for CPython, implemented as a Rust extension using PyO3 with direct Python C-API FFI. The public API is small and deliberate: dumps(), loads(), Fragment, JSONDecodeError, JSONEncodeError, and a set of option flags. Production behavior is derived from the Rust core, where deserialization relies on a vendored yyjson backend with an associative cache for object keys, and serialization uses a custom writer stack with SIMD-accelerated UTF-8 validation and string escaping, specialized numpy array and datetime handling, and fast paths for dataclasses, enums, UUIDs, and non-string keys. Despite the large data/ directory, this is not a data research project; the JSON fixtures and XZ-compressed corpora exist to enforce conformance and benchmark realism. The architecture is a classic C-extension pattern: src/lib.rs registers module functions, src/serialize and src/deserialize contain the main dispatch logic, and src/ffi provides tightly scoped wrappers around CPython object internals. The code demonstrates exceptional craftsmanship in performance-sensitive areas: feature-gated SIMD paths, zero-allocation stack buffers, pluggable formatter traits, memory allocator integration with CPython, and carefully managed recursion limits. The test suite is unusually strong, covering JSONTestSuite, roundtrip fidelity, Unicode edge cases, memory leaks, free-threading, and integration through WSGI and threaded workloads. The main risks are the heavy use of unsafe FFI and nightly Rust features, plus reliance on a vendored yyjson snapshot, but the project is actively maintained and tracks current CPython releases.
Gson is a mature Java library for JSON serialization/deserialization, offering both streaming (JsonReader/JsonWriter) and tree-based (JsonElement hierarchy) APIs. It is centered around a flexible type adapter system (TypeAdapter/TypeAdapterFactory) that enables custom serialization for arbitrary Java objects, including support for Java generics, annotations (@SerializedName, @Expose, @JsonAdapter), and versioning. The core module provides reflection-based adapters for most common types, while extras and proto modules extend support for runtime polymorphism and Protocol Buffers. The library is in maintenance mode (bug fixes only, no major new features), but remains actively maintained with CI builds on multiple JDKs (11 through 25), integration tests for JPMS, GraalVM native image, and code shrinking (ProGuard/R8). Its design emphasizes extensibility and backward compatibility, though it relies heavily on Java reflection and sun.misc.Unsafe, which may pose risks on future JDK versions.
easyjson is a Go library and code generator that produces specialized, reflection-free JSON marshal/unmarshal code for Go structs. It achieves 4–5× faster serialization than the standard `encoding/json` by generating type-specific encoder/decoder functions at compile time. The architecture consists of a CLI tool (`easyjson/main.go`) that parses Go source files, extracts struct annotations (`//easyjson:json`), and generates `_easyjson.go` files implementing `easyjson.Marshaler`/`Unmarshaler` interfaces. The runtime library provides a fast JSON lexer (`jlexer`), writer (`jwriter`), buffer pool (`buffer`), optional types (`opt`), and helpers for unknown fields, string interning, and zero-copy parsing. The project includes extensive benchmarks comparing against ffjson, jsoniter, and go/codec, and a comprehensive test suite covering edge cases like omitempty, snake_case, embedded types, and custom key types.
SocketIOClient-Unreal is a Socket.IO client plugin for Unreal Engine that enables real-time bidirectional communication between Unreal applications and Socket.IO servers. The plugin features a modular architecture with separate modules for core client functionality (SocketIOClient), low-level Socket.IO implementation (SocketIOLib), JSON handling (SIOJson), and utility functions (CoreUtility). It provides both Blueprint-accessible components (USocketIOClientComponent) and native C++ interfaces (FSocketIONative) for flexible integration. The plugin handles connection management, event emission/reception, namespaces, rooms, and includes sophisticated JSON-UStruct conversion utilities with Blueprint compatibility.
This repository serves as a historical archive and clearinghouse for software controlling the ThingM blink(1) USB RGB LED device. It contains a wide variety of tools, libraries, and firmware across multiple platforms (Windows, macOS, Linux, Qt, etc.), including language-specific bindings (Python, Node.js, Java, Go, Ruby, .NET) and integration scripts for services like email, GitHub, and IFTTT. The README explicitly states that most code is deprecated and points to official repositories for current development. Despite its deprecated status, the repository contains several high-quality, reusable components. Notably, the embedded Newtonsoft.Json library (in windows/Blink1Control/JSON/Newtonsoft.Json/) provides a robust JSON serialization framework with support for multiple .NET platforms via conditional compilation. Additionally, the Windows HidLibrary (in windows/ManagedBlink1/HidLibrary/) offers a well-structured abstraction for USB HID device communication, suitable for reuse in other HID-based projects. The overall architecture is fragmented, reflecting the repository's role as a collection of independent tools rather than a unified application. While this makes it a valuable reference for blink(1) integration patterns, the codebase exhibits signs of technical drift due to outdated dependencies and platform-specific implementations that may not align with current best practices. Maintenance is minimal, as active development has moved to satellite repositories.