Projects sharing features with Sonic

SwiftyJSON is a Swift JSON parsing library and data wrapper designed to simplify the reading and manipulation of JSON structures. It provides a toolkit for converting raw JSON strings into structured formats without requiring manual type casting or optional chaining for every value. The library focuses on simplifying nested data extraction through subscript-based value access and recursive data resolution. It ensures optional-safe value retrieval by returning default empty values instead of crashing when encountering missing keys or out-of-bounds array indices. The project includes capabilit

Fastjson is a Java data binding framework and serialization library designed to convert objects to JSON strings and parse JSON data into typed objects. It functions as a JSON parser and stream processor capable of transforming JSON strings into data structures. The project emphasizes high performance JSON processing and memory management, specifically through the use of a pipeline to stream oversized JSON objects and texts to prevent memory exhaustion. It provides capabilities for JSON data serialization and deserialization workflows, including custom JSON data mapping and the ability to def

RapidJSON is a high-performance C++ library used for parsing and generating JSON data. It provides both document object model and stream-based interfaces to transform JSON strings into structured data and vice versa. The library includes a JSON schema validator to verify that documents conform to predefined rules and a Unicode transcoder for converting strings between UTF-8, UTF-16, and UTF-32 encodings. It also supports relaxed parsing for non-standard JSON containing comments or trailing commas. Additional capabilities cover JSON pointer navigation for locating specific values and string s

JsonPath is a Java library designed for querying and manipulating JSON documents using the JsonPath expression language. It functions as a query engine for extracting and filtering specific data from JSON structures through path-based expressions. The library provides capabilities for transforming JSON documents by modifying values or mapping extracted data into Java objects. It also includes an aggregation library for calculating statistical metrics, such as sums and averages, on numeric arrays. The project handles data extraction through array filtering and numerical aggregation. Performan

ObjectMapper is a JSON serialization framework for Swift that maps JSON strings and dictionaries into strongly typed classes and structs. It functions as a data mapper and converter, facilitating the bidirectional transformation of data between raw JSON and Swift model objects. The library uses protocol-based mapping to associate specific JSON keys with object properties. It supports nested key extraction via dot-notation pathing and employs custom transformation classes to bridge the gap between JSON and Swift types. The framework provides capabilities for model validation during initializa

Newtonsoft.Json is a data processing utility for the .NET ecosystem designed to facilitate the transformation and exchange of information. It functions as a serialization library and object mapping framework, enabling the conversion of complex application objects into formatted JSON strings and the reconstruction of structured objects from raw JSON data. The library distinguishes itself through a flexible architecture that supports both strongly-typed class mapping and a dynamic object model for schema-less data manipulation. It employs reflection-based metadata mapping to automate property a

simdjson is a high-performance JSON parser that utilizes SIMD instructions to process gigabytes of data per second. It functions as a SIMD JSON parser, a multithreaded NDJSON processing library, a UTF-8 validation engine, and a tool for JSON minification and string building. The project focuses on high-throughput data processing, enabling the ingestion of massive JSON volumes and the verification of UTF-8 encoding standards. It includes dedicated capabilities for constructing JSON strings with optimized memory usage and removing unnecessary whitespace from documents to reduce file size. The

JsonCpp is a C++ library for parsing, manipulating, and generating JSON data. It functions as a data interchange tool that provides a JSON parser to convert formatted text into structured data and a JSON serializer to transform internal data structures back into valid JSON strings. The library features the ability to preserve non-standard JSON comments during the deserialization and serialization process, which supports the management of human-readable configuration files. The project implements a tree-based internal representation for programmatic data access and uses a builder-based config

cJSON is a lightweight library for parsing, creating, and modifying JSON data structures within C applications. It provides a comprehensive set of utilities for transforming raw text into navigable objects, manipulating data fields within collections, and serializing complex structures into formatted or unformatted strings. The library is designed for memory-sensitive and resource-constrained environments, utilizing manual memory management and type-tagged union structures to maintain a minimal footprint. It employs recursive descent parsing and in-place string manipulation to process data ef

yyjson is a high-performance C library for parsing, serializing, and manipulating JSON data structures. It functions as a memory-efficient data tool that utilizes custom memory pools and contiguous block allocation to minimize fragmentation and overhead. The project distinguishes itself as a SIMD JSON processor, using hardware-accelerated vector instructions for rapid string validation and parsing. It provides a toolkit for querying, modifying, and patching nested JSON objects and arrays through pointer-based access and path expressions. The library covers a broad range of data manipulation

Moshi is a JSON serialization library and parser for Kotlin and Java. It functions as a reflectionless JSON encoder that converts typed objects to JSON strings and parses JSON data back into language objects. The library distinguishes itself through compile-time adapter generation, which removes the performance overhead associated with runtime reflection. It also provides a polymorphic JSON mapper that uses type identifiers to resolve and instantiate specific subclasses of a common base type. The framework supports custom adapter definitions for specialized type conversion, including nullabi

Hazelcast is a distributed data platform that combines an in-memory data grid with a stream processing engine to support real-time analytics and event-driven applications. It functions as a partitioned, distributed key-value store that replicates data across cluster nodes to provide low-latency access and high availability. The platform also serves as a distributed SQL query engine, allowing users to execute standard SQL statements against both in-memory datasets and external data sources. What distinguishes Hazelcast is its use of a distributed consensus subsystem to maintain strongly consis

jsmn is a lightweight JSON parser library written in C. It provides zero-copy tokenization and incremental parsing designed for use in embedded systems and memory-constrained environments. The library identifies structural JSON elements by providing offsets into the original string rather than allocating new memory for data. It uses a single-pass scanning method and requires static-buffer allocation, meaning the caller provides the memory for tokens to avoid dynamic allocation during the parsing process. The parser supports incremental streaming, allowing it to process JSON data in chunks fr

This project is a comprehensive sample library and implementation guide for ASP.NET Core. It provides a collection of practical examples and projects that demonstrate how to build web applications, RESTful APIs, and high-performance services. The repository focuses on a variety of architectural patterns, including the development of Minimal APIs, contract-first gRPC services, and real-time communication using WebSockets and Server-Sent Events. It includes detailed implementations for user identity and security, such as token-based authentication and CSRF protection. The codebase covers a bro

simdjson is a high-performance, header-only C++ library designed for parsing, querying, and serializing JSON data with minimal memory overhead. It functions as a hardware-aware data processing engine that leverages vector instructions to achieve gigabyte-per-second parsing speeds. By detecting host processor capabilities at runtime, the library automatically selects the most efficient instruction sets to accelerate structural analysis and validation. The library distinguishes itself through a focus on extreme efficiency and resource management. It utilizes memory mapping and padded buffer ali

This is a Rust serialization library for converting data structures to and from JSON strings and byte streams. It is built as a framework within the Serde ecosystem, providing both a strongly typed parser for compile-time safety and a recursive value tree for manipulating JSON data without a predefined schema. The project supports both typed and untyped processing. It can map JSON data into specific Rust types for schema conformity or parse input into a flexible, schemaless representation. It also includes macro-based utilities for the dynamic construction of JSON objects.

JSONModel is a data modeling framework and serialization library for Apple platforms, including iOS, macOS, watchOS, and tvOS. It transforms JSON strings and dictionaries into typed Swift objects to eliminate manual dictionary parsing. The framework provides a mapping system that utilizes custom key rules and dot-notation to resolve nested data hierarchies. It supports the conversion of complex JSON structures into organized model relationships and manages the transformation of JSON arrays into collections of typed model instances. The toolset includes data type transformation via custom tra

orjson is a high-performance Python library for serializing and deserializing JSON data. It functions as both a JSON parsing library and a serialization engine, converting data between native Python objects and UTF-8 encoded bytes. The project provides specialized support for converting complex Python data structures, including dataclasses, datetime objects, and NumPy arrays and scalars, into JSON format. It also allows for the insertion of pre-serialized JSON blobs into documents to maintain processing speed. The library includes capabilities for memory-efficient deserialization through key

This library is a high-performance JSON processing tool for Java designed to handle data serialization and deserialization with minimal resource consumption. It provides a framework for transforming complex object graphs into JSON strings and mapping raw input directly to typed class properties. The library distinguishes itself by utilizing compile-time code generation and reflection-free mapping to eliminate expensive runtime overhead. By employing iterator-based stream parsing and zero-allocation buffer management, it processes large or deeply nested data structures while reducing garbage c

Gson is a Java library designed for the serialization and deserialization of objects into structured text formats. It functions as a reflection-based data mapper, inspecting class structures at runtime to automatically convert memory-resident objects into data representations and reconstruct them back into typed language objects. The library distinguishes itself through a modular type-adapter pattern that allows for custom conversion rules for complex or nested structures. It also provides robust support for production environments by generating build-time metadata and configuration rules, wh

Fury is a multi-language binary serialization framework designed for encoding domain objects and complex graphs to facilitate cross-language data exchange. It includes an interface definition language compiler that translates schema definitions into idiomatic native types and serialization boilerplate across multiple languages. The project distinguishes itself through a zero-copy binary reader that allows specific fields to be accessed without deserializing the entire object, as well as an object graph serializer that preserves circular references and referential integrity. It also features a

This project is a set theory library for Go that provides a data structure for storing unique elements of any comparable type using generics. It serves as a tool for managing unique collections and performing mathematical operations such as intersections and differences. The library provides synchronized collections to prevent data races during concurrent read and write operations. It also supports converting unique collections to and from JSON arrays for data persistence and network transmission. The implementation covers membership testing, collection cloning, and size calculation. It incl

This project is a high-performance JSON library for Go, serving as a replacement for the standard encoding/json package. It provides a serialization engine for encoding and decoding data structures, alongside a schemaless parser for extracting specific values from JSON blobs using paths. The library distinguishes itself through a focus on reducing CPU and memory overhead. It implements a high-performance encoder that utilizes buffer reuse and reduced float precision to increase data throughput. Broad capability areas include data serialization, high-performance JSON processing, and schema-le

This project is a framework for the efficient serialization and deserialization of data structures. It provides a unified, macro-based interface that automates the conversion of complex internal objects into standardized formats and reconstructs them from raw input streams or buffers. By leveraging compile-time code generation, the library minimizes manual implementation overhead while ensuring consistent logic across diverse data types. The framework distinguishes itself through a format-agnostic data model and a visitor-based parsing architecture that decouples data structures from specific

This is an educational tutorial that walks through implementing a complete JSON library from scratch in C. The project covers the full data lifecycle of JSON, including parsing text into structured in-memory representations, validating input against the specification, serializing data back into standard JSON output, and providing structured access to elements within parsed arrays and objects. The implementation is built around a hand-written recursive descent parser that processes JSON text by matching grammar rules to build a structured data tree. Parsed values are stored in a tagged union r

Fory is a cross-language serialization framework and binary data serializer designed to convert complex object graphs into a compact binary format for high-performance data exchange. It includes an IDL-based schema compiler to transform interface definition language files into type-safe native data models and a schema evolution manager to maintain forward and backward compatibility. The project features a zero-copy data access layer that allows reading specific fields from binary rows without deserializing the entire object. It supports dual-mode serialization, enabling a toggle between a por

Mantle is a framework for mapping raw data structures and JSON into typed model objects for Cocoa and Cocoa Touch applications. It serves as a data serialization engine and JSON data mapper that transforms dictionaries and arrays into structured model objects. The framework distinguishes itself through an Objective-C persistence layer that manages model disk archiving via keyed archivers. It includes specialized logic for model version management, allowing outdated archived data structures to be upgraded to match current schemas during deserialization. The project covers a broad range of dat