Projects sharing features with Distsys Class

This project serves as a comprehensive technical reference for the architecture and design of data-intensive applications. It provides a structured analysis of the fundamental principles required to build reliable, scalable, and maintainable software systems, covering the core trade-offs inherent in modern data infrastructure. The repository explores the mechanics of distributed data management, including strategies for replication, partitioning, and achieving consensus across multiple nodes. It details the design of storage engines, indexing techniques, and transaction management models, whi

Algodeck is an open-source collection of flash cards designed for reviewing algorithms, data structures, and system design concepts, specifically curated for technical interview preparation. The project organizes knowledge into atomic question-and-answer pairs and incorporates spaced repetition scheduling to optimize long-term memory retention. The flash card catalog covers a broad range of computer science topics, including classic sorting algorithms like quicksort and mergesort, data structure operations for arrays, trees, heaps, tries, and graphs, as well as bit manipulation techniques for

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

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

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

This project is a feature-rich Go client library designed for interacting with Redis. It serves as a comprehensive interface for managing remote data stores, enabling developers to execute standard database commands, handle complex data structures, and perform asynchronous operations within Go applications. The library distinguishes itself through its support for advanced Redis capabilities, including connection pooling, pipelining, and transactional integrity. It provides specialized primitives for managing distributed clusters, including automated topology updates and request routing to sha

This project is a reactive, offline-first NoSQL database engine designed for JavaScript applications. It provides a robust framework for managing application state by synchronizing data across browsers, mobile devices, and server-side runtimes. By treating local storage as the primary source of truth, it enables applications to remain functional without network connectivity, automatically reconciling changes with remote backends once a connection is restored. The database distinguishes itself through a modular architecture that supports cross-environment synchronization and high-performance d

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

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-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

Raft is a Go library implementing the Raft consensus protocol for coordinating reliable state machine replication across a cluster. It functions as a distributed systems library for building applications that require strongly consistent replicated state, keeping distributed nodes synchronized and fault-tolerant through automated node elections and log distribution. The library conducts periodic node elections using majority votes to designate a single data authority and prevent split-brain conflicts, while distributing deterministic command logs from leaders to follower nodes using a multi-ph

Loro is a conflict-free replicated data type (CRDT) framework and collaborative state engine designed for building real-time collaborative applications. It provides a distributed data synchronizer that enables multiple users to edit shared documents and complex nested structures—such as maps, lists, trees, and counters—with automatic state convergence without requiring a central server. The project distinguishes itself through a versioned document store that supports branching, forking, and merging via a directed acyclic graph of causal operation history. It enables advanced version control c

ToyDB is a distributed SQL database that provides a system for storing and querying data across multiple nodes. It focuses on maintaining strong consistency and fault tolerance through the implementation of a distributed consensus algorithm. The project distinguishes itself by supporting historical data versioning, enabling time-travel queries to retrieve the state of the database from a specific point in the past. It utilizes multi-version concurrency control to manage ACID transactions and ensure data integrity during concurrent operations. The system covers relational data modeling with t

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

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

Automerge is a distributed state synchronization engine and library for conflict-free replicated data types. It enables multiple nodes to perform concurrent updates to a shared dataset while guaranteeing that all replicas eventually converge to the same state. The project provides a high-performance implementation written in Rust to manage state merging and synchronization. It employs a byte-compressed synchronization protocol to transmit minimal delta updates between peers, facilitating data consistency in peer-to-peer and real-time collaborative environments. The system covers broad capabi

dqlite is a distributed SQL database that embeds a relational database engine to provide replicated storage across a cluster of nodes. It functions as a replicated SQL engine designed to ensure data remains available and consistent during node failures. The system utilizes a consensus algorithm to manage leader election and synchronize a replicated log across the cluster. This approach enables automatic cluster failover and leader promotion to maintain continuous service without manual intervention. The project covers state machine replication, network-based cluster membership, and transacti

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

Pinot is a distributed, columnar analytical database designed for high-concurrency, low-latency query processing. It functions as a real-time OLAP datastore, enabling interactive, user-facing analytics by ingesting and querying massive datasets from both streaming and batch sources. The system architecture relies on a centralized controller for cluster coordination and a distributed segment-based storage model to ensure horizontal scalability. The platform distinguishes itself through a hybrid ingestion pipeline that unifies real-time event streams and historical batch data into a single quer

This project is a technical programming guide and educational resource focused on Go internals, runtime mechanisms, and advanced language features. It provides detailed conceptual analysis of the language's execution model, including its scheduler, memory escape analysis, and garbage collection mechanisms. The material distinguishes itself through deep dives into high-concurrency system design, exploring the implementation of worker pools and communication channels. It also covers low-level network programming with a focus on I/O multiplexing and TCP state management, alongside a study of dis

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

Nebula is a distributed graph database designed for storing and querying massive volumes of interconnected vertices and edges across a horizontally scalable cluster. It functions as a Kubernetes-native database and a distributed graph analytics engine, utilizing a Raft-based distributed store to ensure strong consistency and high availability. The system features an OpenCypher query engine for performing complex graph traversals and pattern matching. It distinguishes itself with a decoupled compute-storage architecture and a shared-nothing distributed design, allowing query processing and dat

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

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

Cassandra is a distributed NoSQL database and wide-column store designed for high availability and linear scalability. It functions as a fault-tolerant distributed system that utilizes an LSM-tree storage engine to optimize write throughput and manage massive datasets. The system is a CQL-compliant database, using a structured query language to manage and retrieve tabular data stored across multiple nodes. It organizes information into rows and columns based on a flexible schema and primary keys. The project provides capabilities for horizontal database scaling, distributed data partitioning

Fluvio is a distributed event streaming platform and cloud-native streaming engine designed for collecting, persisting, and replicating real-time data streams across a distributed cluster. It functions as a real-time data pipeline for building stateful workflows that ingest, enrich, and export data between external sources and sinks. The platform is distinguished by its use of WebAssembly to execute compiled modules for in-line data transformations and filtering. This allows for the execution of custom business logic to reshape information in motion without requiring a restart of the cluster.

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