Projects sharing features with Tinykv

dtm is a distributed transaction framework and polyglot transaction coordinator designed to maintain data consistency across microservices. It functions as a Saga orchestration engine and a two-phase message coordinator, ensuring that multi-service operations either succeed completely or roll back to a consistent state. The project distinguishes itself by supporting multiple consistency patterns, including Saga, TCC, XA, and outbox patterns, allowing users to select the appropriate model for their specific application requirements. It provides a polyglot integration layer via HTTP and gRPC, e

This is a Raft consensus library and distributed consensus engine implemented in Go. It provides the primitives necessary to build fault-tolerant distributed services by implementing a replicated state machine that ensures a group of servers agree on a shared system state through leader election and log replication. The project distinguishes itself through a pluggable architecture for storage backends and snapshot storage, decoupling the consensus logic from physical persistence. It includes specialized mechanisms for leadership transfer, protocol version management to support rolling upgrade

sofa-jraft is a Java implementation of the Raft consensus algorithm. It serves as a distributed consensus engine and linearizable state machine designed to ensure high availability and data consistency across a cluster of nodes. The project provides a replicated key-value store and a coordination engine for managing distributed state. It distinguishes itself through support for multi-group consensus sharding to distribute traffic and a service provider interface that allows for custom log storage and entry encoding implementations. The system covers a wide range of distributed capabilities,

Raft is a portable C programming library that implements the Raft distributed consensus protocol. It serves as a state machine replication engine and coordination primitive for building fault-tolerant distributed applications and clustered systems. The library manages leader election timeouts, heartbeat monitoring, and log replication across peer nodes to maintain consistent state across servers. It handles client write operations, redirects requests from non-leader nodes, processes voting and replication messages, and supports dynamic cluster membership changes through specialized log entri

dtm is a distributed transaction framework and workflow orchestrator designed to manage data consistency across microservices. It functions as a centralized coordinator that synchronizes distributed transactions and manages the state and execution flow of complex sequences of distributed tasks. The framework implements several coordination patterns, including Saga, TCC, and XA, to prevent synchronization errors. It specifically provides a multi-language transaction coordinator to synchronize operations across services written in different programming languages and utilizes a reliable messagin

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

TiKV is a distributed transactional key-value store designed for horizontal scalability and high availability. It functions as a storage engine that maintains massive datasets across a cluster of physical nodes, ensuring that information remains accessible and consistent even when individual hardware components fail. The system utilizes a consensus-based replication model to synchronize data across nodes, ensuring that all replicas agree on the order of operations. It manages data distribution through a sharding mechanism that partitions large datasets into smaller groups, each governed by in

Async-raft is an asynchronous consensus framework built on Rust for coordinating replicated state machines across distributed nodes. The library implements a leader-based consensus algorithm to ensure data consistency and fault tolerance, managing inter-node communication, log replication, and automated snapshot creation. The framework supports dynamic cluster topology modifications at runtime, allowing nodes to be added or removed without downtime through intermediate configuration phases. It handles log replication through batched and pipelined streaming with congestion control, alongside

RavenDB is a multi-model NoSQL document database designed for high-performance, ACID-compliant data storage. It persists structured information as schema-flexible JSON documents and utilizes a unit-of-work session pattern to track entity changes and batch modifications into atomic transactions. The platform is built on a distributed architecture that supports horizontal scaling through sharding and ensures high availability via multi-node, master-to-master cluster replication. The database distinguishes itself through a self-optimizing query engine that automatically creates and maintains ind

FoundationDB is an ACID-compliant distributed transactional key-value store. It functions as a scalable database engine that ensures strict serializability and data consistency across a cluster of servers using a shared-nothing architecture. The system is distinguished by its multi-region replication capabilities, allowing data to be synchronized across different datacenters for high availability and disaster recovery. It utilizes optimistic concurrency control to manage distributed transactions and employs a majority-based coordination system to maintain cluster state. The platform provides

This project is a reference library of architectural blueprints, study materials, and design patterns for building scalable, high-availability distributed systems. It serves as a technical guide for scalability engineering, providing structural solutions for common engineering challenges. The repository focuses on distributed systems design, covering essential patterns for data replication, consensus algorithms, and transaction management. It distinguishes itself by offering detailed blueprints for specialized domains, including real-time data streaming, large-scale data storage, and high-ava

etcd is a distributed key-value store and configuration store designed to maintain a consistent set of data across a cluster of nodes. It functions as a reliable registry for storing and synchronizing critical settings and metadata used by distributed applications. The system implements the Raft consensus algorithm to ensure data consistency and leader election across servers. To protect data transfers and verify node identities, it utilizes a network security layer based on mutual TLS and client certificates. Its capabilities cover distributed configuration management, cluster state synchro

tx-lcn is a distributed transaction framework and Java transaction middleware designed to manage atomic operations and data consistency across multiple microservices and relational databases. It functions as a distributed transaction coordinator that synchronizes commit and rollback operations to ensure global data integrity. The system provides a microservice consistency manager that tracks and resolves transaction flows across service boundaries. It features an integration layer compatible with middleware such as Spring Cloud, Dubbo, and Motan, allowing it to operate across different servic

Hmily is a distributed transaction framework and data consistency manager designed to maintain state across multiple services. It operates as a coordinator that tracks transaction states across remote procedure calls to manage nested operations and ensure atomic completions. The project implements the SAGA pattern to orchestrate long-running business processes through a sequence of local transactions and automated compensating actions. It distinguishes itself by automating the generation and execution of rollback scripts for relational databases to recover from business exceptions and restore

This project is a Java implementation of the try-confirm-cancel pattern, providing a distributed transaction framework and management library. It functions as a coordinator that manages the lifecycle of multi-phase transactions to ensure consistency across multiple distributed services. The framework includes a distributed transaction coordinator server that offloads event and task operations from local services. It also provides a dedicated dashboard for visualizing transaction status and manually operating distributed events and tasks. The system manages consistency through a three-phase c

Seata is a distributed transaction coordinator and consistency framework designed to maintain data integrity across multiple microservices. It functions as a manager that synchronizes state across separate databases to ensure atomic commits or rollbacks of global transactions. The project provides a toolkit for implementing distributed transaction patterns, using a two-phase commit protocol and centralized status tracking to prevent data anomalies. It orchestrates eventual consistency through state-machine-based tracking and message-driven coordination to handle timeouts and failures in distr

rqlite is a distributed relational database that replicates SQLite data across a cluster using the Raft consensus algorithm. It functions as a fault-tolerant storage system that provides high availability and a web API for executing SQL queries and managing relational data without requiring native database drivers. The system distinguishes itself by using an HTTP SQL interface to expose database operations and cluster management. It features a real-time change data capture stream that pushes database mutations to external HTTP endpoints via webhooks and supports the scaling of read throughput

Consul is a distributed coordination service and service mesh tool used for service discovery, health monitoring, and cluster state management across dynamic networks. It provides a platform for locating network addresses of services and managing traffic across distributed infrastructure using DNS and HTTP interfaces. The project distinguishes itself through multi-datacenter network orchestration, enabling the federation of services across different regions using mesh gateways. It secures communication via a service mesh architecture that employs identity-based authorization and mutual TLS en

Mycat-Server is a MySQL database middleware system that functions as a sharding proxy, distributed database coordinator, and high availability manager. It acts as a proxy layer that routes SQL traffic between applications and multiple backend MySQL database instances to enable horizontal scaling. The system coordinates distributed transactions, generates global unique sequences to prevent primary key collisions, and executes distributed join queries across multiple database shards. It includes a load balancer that performs read-write splitting by directing traffic between primary and slave no

Dkron is a distributed, fault-tolerant system designed for scheduling and executing recurring tasks across a cluster of nodes. It functions as a cron-based orchestrator that manages job lifecycles, including automatic retries, timeouts, and complex dependencies, while ensuring state consistency through a consensus protocol. By coordinating remote task execution across infrastructure, it enables the automation of background operations and the management of distributed workflows. The system distinguishes itself through a modular architecture that supports pluggable storage backends and a plugin

ShardingSphere is a distributed SQL database middleware that provides sharding, read-write splitting, and distributed transaction management for relational databases. It functions as a layer that intercepts SQL queries to distribute data across multiple physical database instances for horizontal scaling. The project is distinguished by its ability to operate as either a standalone transparent database proxy or via direct integration as a JDBC driver. It features a SQL dialect translator that parses queries into abstract syntax trees to convert syntax between different database engines, enabli

SpringBoot-Labs is a collection of educational resources and reference implementations for Java backend architecture and distributed systems. It provides practical lab guides and code samples focused on building applications with the Spring Boot framework and designing scalable microservices architectures. The project specifically covers service governance and distributed cloud deployment patterns using Spring Cloud and Spring Cloud Alibaba. It includes a dedicated kit for microservices and a guide for executing remote procedure calls and managing service discovery via the Dubbo protocol. Th

This project is a reference implementation of a distributed system built using Spring Cloud Alibaba, Spring Boot, and JDK 17. It serves as a comprehensive model for implementing a microservices architecture. The system integrates a wide range of distributed patterns, including global transaction coordination for data consistency, OAuth2 and JWT for identity management, and Kubernetes-based container orchestration. It features a dedicated observability stack for distributed request tracing, log aggregation, and service health monitoring. The implementation covers several functional domains, i

YugabyteDB is a distributed SQL database and relational data store designed for horizontal scalability and high availability across multiple nodes or regions. It functions as a cloud-native system that ensures continuous availability and supports PostgreSQL compatible query languages and drivers. The system includes specialized capabilities as a vector database for AI, utilizing high-dimensional indexing to perform similarity searches. It is engineered as a multi-region cloud database that synchronizes data across different geographic locations to maintain global availability. The project co

RocketMQ is a cloud-native distributed messaging platform and streaming engine. It functions as a distributed transactional queue that ensures atomicity between local transactions and message delivery, and serves as an MQTT IoT message broker to bridge lightweight device traffic into high-performance data streams. The system is distinguished by a Kubernetes-native architecture that decouples compute from storage to allow independent scaling of traffic and data retention. It utilizes a tiered storage model to offload older data to remote storage and employs quorum-based replication and automat

This project is a comprehensive Java backend engineering guide and technical reference focused on high-concurrency design, distributed systems, and microservices architecture. It provides detailed strategies for decomposing monolithic applications, managing service discovery, and implementing the architectural patterns required for scalable backend environments. The repository distinguishes itself through an extensive collection of big data algorithmic references and database scaling strategies. It covers memory-efficient techniques for analyzing massive datasets, such as Top-K element extrac

Eventuate Tram Sagas is a framework for managing distributed transactions across microservices. It functions as an event-driven workflow engine that coordinates complex business processes by executing sequences of local operations and maintaining state transitions across independent service boundaries. The framework implements the transactional outbox pattern to ensure atomicity between database updates and message publishing. It coordinates distributed workflows through asynchronous messaging, utilizing a message broker to decouple services and guarantee reliable delivery of commands and rep