# Distributed consensus algorithm

> AI-ranked search results for `distributed consensus` on awesome-repositories.com — ordered by an LLM for relevance, best match first. 111 total matches; showing the top 16.

Explore on the web: https://awesome-repositories.com/q/distributed-consensus

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [this search on awesome-repositories.com](https://awesome-repositories.com/q/distributed-consensus).**

## Results

- [apache/zookeeper](https://awesome-repositories.com/repository/apache-zookeeper.md) (12,763 ⭐) — ZooKeeper is a distributed coordination service that provides a centralized system for managing configuration, naming, and synchronization across a cluster of distributed processes. It functions as a cluster consensus service, a distributed configuration store, and a distributed lock manager to maintain a consistent state across multiple network nodes.

The service implements a consensus protocol to ensure data consistency and uses a replicated state machine to maintain identical copies of the system state across all servers. It provides a distributed lock management system to coordinate exclu
- [baidu/braft](https://awesome-repositories.com/repository/baidu-braft.md) (4,216 ⭐) — braft is an embeddable C++ library that implements the Raft consensus algorithm, providing a distributed consensus engine for building fault-tolerant, replicated state machines. At its core, it manages leader election, log replication, cluster membership changes, and state machine synchronization across a cluster of nodes, ensuring strong consistency and data durability even in the face of node failures.

The library distinguishes itself through a comprehensive set of mechanisms for reliable distributed coordination. It uses a randomized timeout-based leader election process with term manageme
- [coreos/etcd](https://awesome-repositories.com/repository/coreos-etcd.md) (51,846 ⭐) — 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
- [sofastack/sofa-jraft](https://awesome-repositories.com/repository/sofastack-sofa-jraft.md) (3,806 ⭐) — 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,
- [lni/dragonboat](https://awesome-repositories.com/repository/lni-dragonboat.md) (5,308 ⭐) — Dragonboat is a Go implementation of the Raft consensus protocol designed to maintain consistent state across a distributed cluster of nodes. It provides a library for building distributed state machines that ensure data integrity and fault tolerance during system failures.

The project distinguishes itself through a multi-group Raft implementation, which partitions data across independent consensus groups to distribute workloads and increase overall system processing capacity. It also incorporates mutual TLS to encrypt inter-node communication and verify the identity of cluster members.

The
- [etcd-io/etcd](https://awesome-repositories.com/repository/etcd-io-etcd.md) (51,838 ⭐) — etcd is a distributed, strongly consistent key-value store designed to provide reliable storage for critical system metadata and coordination primitives. It functions as a distributed consensus engine, utilizing a replicated log and leader-based state machine to ensure that all nodes in a cluster maintain a synchronized view of data. By providing atomic operations and linearizable reads and writes, it serves as a foundational component for distributed systems requiring high availability and fault tolerance.

The system distinguishes itself through its multi-version concurrency control, which e
- [hashicorp/raft](https://awesome-repositories.com/repository/hashicorp-raft.md) (9,037 ⭐) — 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
- [talent-plan/tinykv](https://awesome-repositories.com/repository/talent-plan-tinykv.md) (3,938 ⭐) — TinyKV is a distributed key-value store designed for storing and retrieving data across multiple nodes with high availability. It functions as a distributed database system that incorporates a dedicated key-value storage engine for raw data persistence and retrieval on individual nodes.

The project includes a Raft consensus engine to ensure data consistency and fault tolerance across a cluster of servers. It also features a distributed transaction manager that coordinates atomic commits and concurrency control to maintain data integrity across shards.

The system covers cluster membership man
- [tendermint/tendermint](https://awesome-repositories.com/repository/tendermint-tendermint.md) (5,861 ⭐) — Tendermint is a Byzantine fault tolerant consensus engine that replicates a deterministic state machine across a cluster of machines while tolerating up to one-third malicious validators. It functions as a blockchain application platform, connecting application logic to the consensus engine through a socket-based protocol that enables development in any programming language.

The system commits blocks when more than two-thirds of weighted validators sign and broadcast their votes, with proof included in the next block. It provides cryptographic state verification, allowing efficient authentica
- [apache/brpc](https://awesome-repositories.com/repository/apache-brpc.md) (17,545 ⭐) — brpc is a high-performance C++ RPC framework and network programming library designed for building distributed systems. It functions as a multi-protocol RPC server capable of hosting and detecting multiple communication protocols, including gRPC, Thrift, HTTP, Redis, and Memcached, on a single TCP port.

The project distinguishes itself through high-throughput data transport and memory efficiency, utilizing RDMA-based transport to bypass the kernel TCP stack and zero-copy memory management to eliminate data duplication. It also implements the Raft algorithm for consensus-based state replicatio
- [logcabin/logcabin](https://awesome-repositories.com/repository/logcabin-logcabin.md) (1,961 ⭐) — LogCabin is a distributed storage system built on Raft that provides a small amount of highly replicated, consistent storage. It is a reliable place for other distributed systems to store their core metadata and is helpful in solving cluster management issues.
- [etcd-io/raft](https://awesome-repositories.com/repository/etcd-io-raft.md) (1,051 ⭐) — Raft library for maintaining a replicated state machine
- [tikv/raft-rs](https://awesome-repositories.com/repository/tikv-raft-rs.md) (3,351 ⭐) — Raft-rs is a Raft consensus library and distributed consensus engine implemented in Rust. It functions as a systems-level protocol implementation that provides foundational message formats and data structures for state serialization across nodes.

The library executes the underlying consensus protocol to ensure multiple distributed state machines agree on a shared sequence of log entries. It coordinates state changes across a cluster of nodes to keep replicated logs synchronized and consistent.

Additional capabilities include defining protocol buffer messages for consensus communication, enco
- [async-raft/async-raft](https://awesome-repositories.com/repository/async-raft-async-raft.md) (1,093 ⭐) — 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
- [willemt/raft](https://awesome-repositories.com/repository/willemt-raft.md) (1,168 ⭐) — 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
- [wenweihu86/raft-java](https://awesome-repositories.com/repository/wenweihu86-raft-java.md) (1,228 ⭐) — Raft-java is a lightweight Java consensus library and replicated state machine engine designed to synchronize transaction logs and maintain fault-tolerant state across distributed server nodes. The framework relies on a leader-based replication model that routes write operations through a designated coordinator node, executing RPC-driven consensus protocols and automatic leader elections to maintain cluster agreement. 

The library supports dynamic cluster membership changes, allowing nodes to be added or removed during runtime without downtime through joint consensus configuration entries app