Open-source alternatives to Msgpack

Kryo is a Java binary serialization framework and object cloning library used to convert Java objects into a compact binary format and restore them from bytes. It provides a system for creating deep or shallow copies of complex object graphs without requiring binary conversion. The project utilizes variable-length integer encoding and integer-ID class registration to reduce the size of serialized data. It handles complex object graphs through circular reference tracking to prevent data duplication and infinite loops. To maintain long-term data viability, it includes schema evolution managemen

FlatBuffers is a cross-platform serialization library designed for performance-critical applications that require efficient, zero-copy data access. By organizing data in a structured binary format, it allows applications to read and write complex data structures directly from memory-mapped buffers without the need for intermediate parsing or temporary object allocation. The project distinguishes itself through a schema-driven approach that balances high-performance access with long-term data evolution. It utilizes a unique memory layout featuring relative offsets and inline fixed-size structu

Protocol Buffers is a language-neutral, platform-agnostic mechanism for serializing structured data. It provides a schema-driven toolchain that compiles declarative data definitions into type-safe source code, enabling consistent communication and strongly typed API contracts across services written in different programming languages. The project distinguishes itself through a highly efficient binary wire format that utilizes tag-based encoding and variable-width integer compression to minimize payload size and processing overhead. It supports robust evolutionary schema management, allowing d

This project provides a technical specification and reference manual for the MQTT 3.1.1 standard, serving as a translated Chinese guide for implementing this lightweight IoT messaging protocol in resource-constrained device networks. The documentation covers the fundamental mechanisms of the publish-subscribe model, including topic-based routing with wildcard filtering, retained message storage, and the configuration of last will and testament messages. It details the protocol's approach to reliability through various quality of service levels, ranging from single-level acknowledgments to exa

MessagePack-CSharp is a high-performance binary serialization library for .NET applications that converts object graphs into the MessagePack format. It functions as a C# data serialization toolkit and a polymorphic binary encoder capable of handling abstract classes and interfaces using union keys to identify concrete derived types. The library provides a binary format transcoder to transform binary data into human-readable JSON for debugging. It supports ahead-of-time formatter generation to avoid runtime overhead and implements LZ4 binary compression to reduce the size of serialized data.

CapnProto is a zero-copy serialization framework and remote procedure call system. It serves as a C++ communication library providing a schema-based data interchange format that eliminates the need to encode or decode data before reading it from memory. The system enables high-performance data serialization and low-latency network communication. It supports cross-language data exchange by using a defined schema to ensure consistent binary representation across different platforms. The framework provides tools for implementing remote procedure calls, allowing functions to be invoked on a remo

This project is a memory-safe library implemented in Rust that provides a high-performance engine for managing shared, distributed data states. It functions as a conflict-free replicated data type implementation, enabling real-time collaborative editing and state synchronization across distributed systems without the need for a central server or manual conflict resolution. The library distinguishes itself through a cross-language binding framework that allows native applications in environments like Python, Swift, and WebAssembly to interact with the same shared data protocol. It utilizes a c

MagicOnion is a .NET RPC framework used to build type-safe remote procedure call services using shared interfaces for communication between servers and clients. It functions as a binary serialization framework and a distributed service orchestrator, providing a network layer for low-latency streaming and real-time data exchange. The project distinguishes itself through an AOT-compatible network client that uses source generators to support ahead-of-time compilation in restricted runtime environments. It enables bidirectional communication and real-time data streaming, allowing servers and mul

meta-rules-dat is a collection of binary-encoded network datasets used to identify and categorize traffic for routing on resource-constrained devices. It provides a structured domain categorization list and a geographic IP routing dataset to map network traffic to specific countries or service providers. The project utilizes trie-based lookup data and compact binary serialization to enable high-performance prefix matching and fast domain-to-category resolution. To minimize memory and storage overhead, it employs stripped-down GeoIP mapping that removes non-essential metadata. The datasets co

Forge is a JavaScript cryptography library providing a comprehensive set of tools for symmetric and asymmetric encryption, hashing, and digital signatures. It includes a full Transport Layer Security implementation for establishing secure network connections and managing encrypted traffic. The project implements a wide array of public key infrastructure tools, including X.509 certificate management, the generation of certificate signing requests, and the validation of certificate chains. It provides a PKCS cryptographic toolkit for handling secure archives and signed messages, alongside suppo

This project is an open-source software development kit and framework for implementing the Matter smart home standard. It provides a universal IPv6-based application layer and a cluster-based data model to ensure interoperability between diverse smart home devices and controllers. The system is distinguished by its multi-transport network abstraction, which maps Bluetooth LE, Thread, and Wi-Fi implementations to a common layer. It includes specialized tooling for secure device commissioning via QR codes and NFC, as well as a comprehensive over-the-air firmware update system for distributing s

Yjs is a CRDT framework and real-time state synchronization engine providing shared data types for collaborative software. It functions as a shared data type library of collaborative maps, arrays, and text structures that converge automatically across distributed clients, serving as a local-first data store and a collaborative editor backend. The system distinguishes itself through a synchronization engine that encodes document changes into commutative binary updates. It employs state-vector based differencing to transmit only missing incremental updates between peers and uses relative-positi

fastjson2 is a high-performance Java library used for serializing and deserializing Java objects to and from JSON strings and byte arrays. It functions as a binary JSON serializer for encoding objects into optimized binary formats to reduce payload size and increase processing speed. The project includes a JSONPath query engine for extracting specific data and fields from JSON documents using standardized path expressions and filters. It also serves as a JSON schema validator, providing utilities to generate data contracts and validate JSON input against defined schemas to ensure structural c

Thrift is a cross-language remote procedure call framework and data serialization protocol. It provides an interface definition language to specify data types and service interfaces in a neutral format, enabling the automated generation of client and server code across multiple programming languages. The project functions as a polyglot service communicator using a layered software stack to ensure interoperable communication. It focuses on implementing cross-language remote procedure calls and transforming complex data structures into standardized formats for efficient network transport. The

Aleth is an Ethereum C++ client and full-node implementation. It provides a virtual machine executor for running and debugging bytecode, a blockchain state debugger, and a serialization library for encoding and decoding data using the Recursive Length Prefix format. The project includes a dedicated mining tool for producing blocks and benchmarking hashing hardware performance. It further distinguishes itself with a state debugger that analyzes pre- and post-execution state changes and generates step-by-step execution traces for the virtual machine. The implementation covers node operations i

s2client-proto provides a set of structured data definitions and language-neutral communication protocols used to exchange information between an external client and the StarCraft II engine. It utilizes protocol buffer definitions to establish a binary serialization schema for these data exchanges. The project defines the underlying communication layer necessary for game engine automation, game state analysis, and the development of software agents for competitive gaming. The framework covers interface definition languages to ensure compatibility across programming languages and employs sche

rkyv is a zero-copy deserialization framework for Rust that provides a binary serialization format for memory-mappable data archives. It allows complex data structures to be mapped to bytes and accessed directly from a buffer without allocating new memory or copying data. The project enables the serialization of polymorphic types and trait objects, maintaining their dynamic behavior and structure within the binary form. It utilizes relative-pointer addressing and byte-aligned structure packing to ensure data remains valid regardless of where it is loaded in memory. The framework covers high-

The mongo-go-driver is a Go library for building applications that integrate with a MongoDB document store. It enables the storage and retrieval of flexible document data by providing a bridge between Go backends and the database. The driver implements specialized capabilities for semantic vector search, allowing the handling and execution of high-dimensional vector data for similarity-based retrieval. It also supports full-text search via linguistic analysis and programmatic search index management. The project covers a broad range of database operations, including document-based CRUD, bulk

ET is a C# game server framework and distributed actor model runtime designed for large-scale multiplayer environments. It provides a comprehensive toolkit for building distributed game backends, incorporating a multiplayer network transport layer and a specialized suite for game AI and pathfinding. The framework is distinguished by its use of a distributed actor model to scale processing across multiple threads and servers, utilizing isolated actors for state management and messaging. It features a unified codebase architecture that allows shared logic between the server and client, enabling

The MongoDB Node.js Driver is a programmatic interface and NoSQL database client used to manage document storage and execute operations within a MongoDB database. It serves as an asynchronous database interface and connection manager that enables Node.js applications to integrate with MongoDB servers. The project implements client-side field encryption to secure sensitive data and queries locally before transmission. It also provides a BSON serialization library to convert JavaScript objects into a binary format for efficient storage and network transmission. The driver covers a broad range

rinf is a cross-platform native bridge and integration layer used to connect business logic written in Rust to application frontends. It functions as a cross-language message broker and binary serialization framework that enables the exchange of structured data between a Rust backend and user interfaces across mobile, desktop, and web targets. The project utilizes a schema-driven code generator to produce language-specific message classes from shared definitions. This ensures type-safe message passing and consistency across different programming environments, preventing data mismatches during

The MongoDB Python Driver is a client library and NoSQL database client used to execute CRUD operations and manage data within MongoDB databases using the Python programming language. It serves as a database connectivity library that handles authentication and connection pooling, while also providing a vector search client for managing embedding indexes and retrieving data based on semantic similarity. The driver supports both synchronous and asynchronous database driver models to perform non-blocking I/O operations and stream data from database clusters. It distinguishes itself through speci

Sui is a blockchain platform featuring an object-centric state model and resource-oriented smart contracts. It utilizes parallel transaction execution to increase network throughput and supports programmable transaction blocks that bundle multiple operations into single atomic units. The platform distinguishes itself with a capability-based access control system and zero-knowledge login mechanisms, enabling users to authenticate via identity providers without seed phrases. It also implements deterministic object addressing to allow predictable state lookups and supports the creation of soulbo

Prost is a Protocol Buffers implementation for Rust that functions as a binary serialization framework and code generator. It translates schema definitions into idiomatic Rust structs and enums, providing the logic necessary to encode and decode structured data into the Protocol Buffers binary format. The project distinguishes itself through a no-std implementation, allowing it to operate in embedded or kernel environments that lack a standard library. It also serves as a schema introspector by emitting file descriptor sets, which enables the programmatic analysis of original schema definitio

This project is a Protocol Buffers Swift library and framework providing a runtime for serializing and deserializing structured data. It includes a code generator that transforms schema files into type-safe Swift structures and a binary serialization framework for converting data into compact streams. The library functions as a JSON data mapper, transforming messages into standard JSON representations to facilitate cross-platform data exchange. It utilizes a schema-driven approach to ensure consistent data modeling between Swift applications and services written in other languages. The frame

This library is a header-only C++ framework designed for the serialization, parsing, and manipulation of structured data. It provides a recursive variant data model that represents arbitrary structures as native types, allowing developers to navigate, modify, and patch hierarchical data using standard pointer paths and declarative update patterns. The project distinguishes itself through its template-based architecture, which enables type-safe data structures and custom type mapping at compile time. It offers a unified interface for binary format abstraction, supporting multiple compact repre

OpenUSD is a framework for authoring and exchanging scalable, time-sampled 3D scene data across digital content creation tools. It serves as a 3D scene interchange standard and interoperable data format to ensure consistency and compatibility when transferring environments between diverse graphics applications. The project functions as an incremental 3D data streamer, transmitting scene descriptions in small increments to allow the loading and display of visual content without interrupting the user experience. It provides capabilities for 3D scene authoring, standardized data exchange, and t