awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
sofastack avatar

sofastack/sofa-jraft

0
View on GitHub↗
3,806 stars·1,201 forks·Java·Apache-2.0·21 viewswww.sofastack.tech/projects/sofa-jraft↗

Sofa Jraft

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, including quorum-based consensus, joint consensus membership changes, and lease-based linearizable reads. It includes tools for distributed locking, metadata storage, and log compaction via state snapshots. Traffic management is handled through leader request routing, leader distribution balancing, and the deployment of non-voting learner nodes for read-scaling.

Observability is provided through performance metric monitoring, real-time node inspection via a telnet interface, and distributed consistency verification using fault-injection and network partitioning tests.

Features

  • Consensus Engines - Provides a core consensus engine that ensures high availability and data consistency via leader election and log replication.
  • Distributed Consensus Stores - Provides a distributed consensus store that ensures consistent state across multiple nodes using the Raft algorithm.
  • Replicated State Machines - Implements a replicated state machine that ensures consistency by applying an ordered sequence of log entries across nodes.
  • Consistent Read Optimizations - Provides optimized read indices to guarantee linearizable reads without the overhead of full log writes.
  • Distributed Key-Value Stores - Ships a replicated key-value store designed to maintain a reliable source of truth across a distributed cluster.
  • Quorum-Based Commit Protocols - Requires a majority quorum of nodes to agree on log entries before committing them to the state machine.
  • Dynamic Cluster Membership Management - Provides a system for managing dynamic node membership and leader transitions using joint consensus.
  • Atomic Record Updates - Provides atomic operations like compare-and-put and merge to ensure data integrity during concurrent updates.
  • Raft Implementations - Provides a production-grade Java implementation of the Raft consensus algorithm.
  • Sharded Consensus Architectures - Supports multi-group consensus sharding to distribute traffic and increase system throughput through independent consensus groups.
  • Joint Consensus Protocols - Implements a two-phase joint consensus process to safely transition cluster membership and prevent split-brain scenarios.
  • Distributed Leader Election - Coordinates a priority-based leader election process to ensure high availability and single-writer exclusivity.
  • Log Replication Strategies - Replicates logs and state snapshots across the network to ensure continuous service availability and rapid node recovery.
  • Consensus Log Replication - Copies log entries from a leader to followers using quorum-based consensus to ensure cluster-wide data consistency.
  • Replicated Log Management - Manages the synchronization and maintenance of sequential operation logs across distributed nodes to prevent data loss.
  • Consensus Log Storage Integrations - Implements high-performance storage interfaces for the Raft consensus log to ensure durability and system recovery.
  • Raft Consensus Implementations - Provides a production-grade Java implementation of the Raft consensus protocol for managing replicated logs and leader election.
  • Inter-Node Consensus Communication - Manages the network communication of votes and log entries between consensus peers.
  • Linearizable Read Validations - Guarantees linearizable reads by validating leader authority through time-bound leases or heartbeats.
  • Leader Authority Validations - Validates leader authority through timed leases and heartbeats to guarantee the most recent write is returned during reads.
  • Batch Write Buffering - Supports batch write operations across different partitions in parallel to increase data throughput.
  • Leader Distribution Balancers - Enables manual distribution of leaders across nodes to ensure an even workload in multi-group environments.
  • Custom Log Serialization - Enables custom serialization and deserialization formats for log entries via a service provider interface.
  • Distributed Configuration Storage - Provides consistent storage for cluster-wide configuration and critical system metadata.
  • Multi-Raft Sharding - Organizes nodes into multiple independent Raft consensus groups to distribute traffic and increase throughput.
  • Learner Node Synchronization - Implements non-voting learner nodes that replicate data from the cluster to scale read operations without affecting quorum.
  • Snapshot-Based Compactions - Provides snapshot-based log compaction to truncate obsolete logs and accelerate node recovery.
  • Read-Only Data Replication - Supports the deployment of non-voting learner nodes to replicate data for read-scaling and backups.
  • Fault-Tolerant Coordinators - Provides a fault-tolerant coordination layer for managing critical system configuration using quorum-based consensus.
  • Distributed Locks - Implements distributed reentrant locks with lease management to prevent race conditions in multi-node environments.
  • Optimistic Pipelining - Increases replication throughput by asynchronously pipelining multiple log entries to followers.
  • Leader-Routed Request Handlers - Tracks the current cluster leader and redirects client requests to the correct node for atomic operations.
  • Leader Role Transfers - Supports the explicit transfer of leader authority to facilitate node maintenance and load balancing.
  • Consensus Node Roles - Initializes consensus nodes with specific roles and storage paths to manage leadership transitions.
  • RPC Servers - Establishes an RPC server to handle internal consensus protocol interactions such as elections and heartbeats.
  • Component Extensibility Interfaces - Provides standardized interfaces for implementing custom log storage and entry encoding components.
  • Fault Tolerance Implementation - Implements architectural resilience to maintain consistency and availability during network partitions and quorum loss.
  • Metric and Performance Monitors - Collects high-frequency statistics on log replication, state machine application, and RPC latency.
  • Distributed System Verification - Uses fault-injection and network partitioning tests to verify distributed system correctness and consistency.

Star history

Star history chart for sofastack/sofa-jraftStar history chart for sofastack/sofa-jraft

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Projects sharing features with Sofa Jraft

These projects share indexed features with Sofa Jraft. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • hashicorp/rafthashicorp avatar

    hashicorp/raft

    9,037View on GitHub↗

    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

    Go
    View on GitHub↗9,037
  • baidu/braftbaidu avatar

    baidu/braft

    4,216View on GitHub↗

    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

    C++distributed-consensusdistributed-storageraft
    View on GitHub↗4,216
  • willemt/raftwillemt avatar

    willemt/raft

    1,168View on GitHub↗

    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

    Craft-consensus-algorithm
    View on GitHub↗1,168
  • maemual/raft-zh_cnmaemual avatar

    maemual/raft-zh_cn

    6,287View on GitHub↗

    This project is a Chinese language translation of the original research paper detailing the Raft consensus protocol. It serves as a technical research translation and a consensus protocol guide, making the specifications of the Raft algorithm accessible to Chinese speakers. The documentation covers the core mechanisms of distributed systems, including leader election, log replication, and safety protocols. It provides a detailed explanation of how to maintain a single source of truth across multiple servers to achieve fault-tolerant cluster management. The material addresses distributed stat

    chineseraft
    View on GitHub↗6,287
Compare all 30 related projects→

Frequently asked questions

What does sofastack/sofa-jraft do?

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.

What are the main features of sofastack/sofa-jraft?

The main features of sofastack/sofa-jraft are: Consensus Engines, Distributed Consensus Stores, Replicated State Machines, Consistent Read Optimizations, Distributed Key-Value Stores, Quorum-Based Commit Protocols, Dynamic Cluster Membership Management, Atomic Record Updates.

Which projects share features with sofastack/sofa-jraft?

Projects with overlapping indexed features include: hashicorp/raft — This is a Raft consensus library and distributed consensus engine implemented in Go. It provides the primitives… baidu/braft — braft is an embeddable C++ library that implements the Raft consensus algorithm, providing a distributed consensus… willemt/raft — Raft is a portable C programming library that implements the Raft distributed consensus protocol. It serves as a state… maemual/raft-zh_cn — This project is a Chinese language translation of the original research paper detailing the Raft consensus protocol.… async-raft/async-raft — Async-raft is an asynchronous consensus framework built on Rust for coordinating replicated state machines across… goraft/raft — Raft is a Go library implementing the Raft consensus protocol for coordinating reliable state machine replication…