Projects sharing features with Wire

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

Simple Binary Encoding (SBE) - High Performance Message Codec

anytype-ts is a TypeScript client library and offline-first knowledge base client designed for managing structured layouts and modular blocks within a private distributed database. It functions as a zero-knowledge data synchronizer and schema-driven API wrapper that enables the secure replication of encrypted data across devices. The library utilizes peer-to-peer connectivity and zero-knowledge encryption to ensure data remains private and unreadable to hosting infrastructure. It employs a schema-driven approach to compile data definitions into typed language bindings, ensuring consistent com

Kitex is a high-performance remote procedure call framework for building distributed microservices in Go. It provides a communication system compatible with gRPC and Protobuf standards and includes a suite of tools for microservices governance. The framework features proxyless service mesh integration, which allows it to manage network traffic and governance directly without adding sidecar proxy latency. It optimizes data throughput through a high-performance communication library that minimizes memory copies. The system covers a broad surface of distributed capabilities, including service d

This project is a gRPC framework for Node.js used to implement high-performance remote procedure calls. It provides a client-server communication library that utilizes HTTP/2 for streaming, multiplexing, and binary framing, alongside a protocol buffers implementation for defining structured data and generating service stubs. The framework includes a toolchain to compile protocol buffer files into language-specific objects and supports the generation of static TypeScript type definitions to validate objects at runtime. The library covers distributed system networking and microservices communi

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

RoaringBitmap is a compressed integer set library designed for memory-efficient storage and high-speed in-memory analytics. It provides a professional implementation of the Roaring Bitmap format to maintain compact representations of integer collections. The project features a standardized binary serialization format that enables the exchange of compressed bitmap data across different programming languages and hardware architectures. This allows for consistent data portability and cross-language data exchange. The library performs rapid logical set operations, including intersections, unions

Fast & memory efficient hashtable based on robin hood hashing for C++11/14/17/20

Postmodern immutable and persistent data structures for C++ — value semantics at scale

HashMap JavaScript class for Node.js and the browser. The keys can be anything and won't be stringified

A complete, fully tested and documented data structure library written in pure JavaScript.

RxJava is a reactive stream processing framework and JVM reactive extensions library. It serves as an asynchronous dataflow orchestrator used to compose event-based programs by transforming, combining, and consuming real-time data flows on the Java Virtual Machine. The project distinguishes itself through integrated backpressure flow control, which manages the emission rate between producers and consumers to prevent memory exhaustion. It further provides mechanisms for concurrent thread management and parallel data processing to offload blocking operations and maintain application responsiven

a header-only, constexpr alternative to gperf for C++14 users

ConcurrentQueue is a header-only C++ template library that provides a lock-free data structure for multi-producer multi-consumer thread communication. It functions as a synchronization primitive designed to coordinate data flow between concurrent execution units using atomic operations rather than traditional mutex locking. The library distinguishes itself through a design that minimizes contention and synchronization overhead. It utilizes sub-queue token mapping to distribute workloads across partitioned internal queues and supports bulk operations to transfer multiple data elements in singl

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

A Persistent Java Collections Library

A bounded multi-producer multi-consumer concurrent queue written in C++11

🏅State-of-the-art learned data structure that enables fast lookup, predecessor, range searches and updates in arrays of billions of items using orders of magnitude less space than traditional indexes

Go package implementing bitsets

C++ small containers

This is a persistent data structure library for JavaScript that provides collections which prevent the direct mutation of objects and arrays. It serves as an immutable state management tool and functional programming utility, ensuring that data remains unchanged after creation to simplify change detection and state tracking. The library enables the maintenance of application state by producing new versions of data structures during updates. It focuses on efficient data comparison by checking actual content instead of memory references and supports a functional programming workflow to prevent

A family of header-only, very fast and memory-friendly hashmap and btree containers.

Go package implementing Bloom filters, used by many important systems

Tries in C++

Roaring bitmaps in Go (golang), used by InfluxDB, Bleve, DataDog

C++11/20 library that provides staticvector, smallvector, staticmap, smallmap, flatmap, staticflatmap, smallflatmap, staticunorderedmap, smallunordered_map, etc.