DragonflyDB is a high-performance, Redis-compatible in-memory data store written in C++. It implements the Redis wire protocol (RESP) and Memcached protocol, providing drop-in replacement capabilities with significantly higher throughput and lower latency, especially on multi-core machines. The architecture is based on a shared-nothing, multi-threaded design using fibers (boost.fibers) and a custom proactor event loop (epoll/io_uring). Data is partitioned across shards, each with its own thread, and transactions use a VLL-based locking scheme to minimize contention. The system supports replication via a write-ahead journal, cluster mode with slot migration, persistence via RDB snapshots, and tiered storage for offloading cold data to SSD. It also includes a full-text search engine with vector similarity (HNSW), JSON document store, Lua scripting, ACL-based security, and probabilistic data structures (Bloom, Cuckoo, Count-Min Sketch, Top-K). The codebase demonstrates advanced engineering in memory management (custom allocators, SIMD probing, compact object encoding) and concurrency (fiber-aware synchronization, RCU patterns). While primarily an application, it contains research-grade data structures and algorithms, giving it a hybrid character between production service and systems research project.
Valkey is a high-performance in-memory data structure server, forked from Redis under a BSD-3-Clause license. It serves as a key-value store with support for strings, hashes, lists, sets, sorted sets, streams, geospatial indexes, and more. The architecture is event-loop-driven (single-threaded main loop with background I/O threads for persistence, replication, and lazy freeing). It supports clustering (up to 16384 slots), replication (leader-follower with partial resync), persistence (RDB snapshots, AOF logs), Lua scripting (EVAL/FUNCTION), a pluggable module API, TLS, RDMA, and advanced features like client-side caching, hot-key detection, and replication throttling. Key entry points include the `valkey-server` daemon, `valkey-cli` client, `valkey-benchmark` load generator, and `valkey-check-rdb`/`valkey-check-aof` integrity tools. External dependencies include jemalloc (default allocator), Lua 5.1, LZ4, Zstd (optional), OpenSSL (TLS), and RDMA libraries (optional). The codebase is actively maintained with extensive unit and integration tests, and demonstrates high craftsmanship in its lock-free queues, streaming compression, and data structure implementations.
LiteDB is an embedded NoSQL document database library for .NET. In production it is not a server but an in-process database engine that persists BSON documents to a single file with ACID transactions, WAL/checkpointing, MVCC snapshot isolation, B-tree and vector indexes, optional AES-256 encryption, and multi-process shared-file coordination. The public API is built around `LiteDatabase`, `LiteCollection<T>`, and `LiteRepository`, with `BsonMapper` for POCO mapping and both LINQ and SQL-like `Execute` query paths. Internally, `LiteEngine` implements page-based storage, crash recovery, compaction/rebuild, system collections, and an aggressive query optimizer that rewrites predicates, selects indexes, and supports vector similarity search. The repository also ships a CLI shell, a repro runner, stress tools, and a substantial fuzzing harness used to prove durability and recovery correctness under injected faults and power loss. The architecture is a layered monolith: a client/API layer (`LiteDatabase`, mapper, SQL parser, LINQ expression translation), a query execution layer with index selection and predicate optimization, and a storage layer with buffered page cache, WAL recovery, transaction registry, and shared-mutex coordination. Write flows go from POCO through `BsonMapper` into `BsonDocument`, into transaction snapshots and the WAL, then onto data/index pages; reads flow from index seeks/scans through BSON expression evaluation into materialized documents. The core library has no third-party runtime dependencies, relying only on the .NET base class library; supplementary tools add BenchmarkDotNet, Spectre.Console, and Gemini embedding APIs. The code is actively maintained, with a very large regression suite keyed to GitHub issues, continuous fuzzing, and compatibility tooling across file format versions.
DynamoDB-Toolbox is a lightweight, type-safe query builder and ORM library for DynamoDB, written in TypeScript. It provides a fluent builder pattern over the AWS SDK DocumentClient, allowing developers to define schemas with rich validation, defaults, links, transformers, and condition expressions. The library is structured around three core primitives: Table, Entity, and Schema, each with tree-shakable Actions (e.g., GetItemCommand, PutItemCommand, QueryCommand, ScanCommand, batch/transaction operations). It supports single-table design, multi-entity tables, and integrates with Zod and JSON Schema for cross-platform validation. Architecturally, the library employs a command-builder pattern where each DynamoDB operation is encapsulated in a class that can be instantiated via `.build()`. Actions generate raw DynamoDB API inputs through `.params()` and execute via `.send()`. The schema system handles attribute types, polymorphic schemas (anyOf), and complex update expressions with symbol-tagged operations. Additional features include a spy system for testing, MCP tool integration for AI agents, and a synchronizer for remote schema management. The library is LLRT-compatible and emphasizes tree-shaking with deep subpath exports. The codebase demonstrates high craftsmanship with extensive TypeScript generics, comprehensive unit and type tests, and a well-defined error hierarchy (DynamoDBToolboxError). While the library is actively maintained, there are some areas of technical debt such as circular imports and complex type-level computations. Overall, it is a production-grade solution for DynamoDB access patterns in TypeScript projects.
Apache Cassandra is a distributed, wide-column NoSQL database designed for high availability, horizontal scalability, and fault tolerance. The codebase implements a peer-to-peer cluster architecture with consistent hashing for data placement and tunable replication. The system provides the Cassandra Query Language (CQL) as its primary interface, with a native binary protocol for client communication. Key subsystems include the storage engine (SSTables, memtables, commit log), distributed consensus protocols (legacy Paxos and the newer Accord transactional protocol), cluster metadata management (TCM replacing gossip), and secondary indexing (SASI and Storage-Attached Index SAI). The codebase also includes operational tooling (nodetool CLI, cqlsh shell, stress testing tool, sstable utilities) and extensive testing infrastructure (unit, distributed in-JVM, deterministic simulator, property-based, and microbenchmarks). The architecture follows a modular design with clear separation of concerns: transport layer (Netty-based NIO), query processing (CQL parser, statement execution, result set building), storage (commit log for durability, memtables for writes, SSTables for reads, compaction strategies), and distributed coordination (gossip for failure detection, streaming for bootstrap/repair, hinted handoff for availability). The newer Accord protocol introduces a transactional layer on top of the existing storage engine, enabling ACID transactions across partitions. The codebase is predominantly Java with a Python-based CQL shell (cqlsh) and extensive shell-based build and CI automation. Key entry points include the Cassandra server daemon (started via bin/cassandra), the nodetool CLI (bin/nodetool) for administration, cqlsh (bin/cqlsh) for interactive CQL, and various sstable utilities (sstableloader, sstablescrub, etc.). External dependencies include Netty for networking, Dropwizard Metrics for instrumentation, Picocli for CLI parsing, and various Java libraries for compression, encryption, and serialization. The build system uses Ant with Maven dependency resolution, and the project includes Dockerfiles for containerized builds and testing. The repository also contains formal verification artifacts (TLA+ models) and a deterministic simulation framework for testing distributed correctness, reflecting a strong emphasis on reliability.
This repository is a Redis-compatible in-memory data structure server with significant custom extensions, including vector similarity search via HNSW (vector-sets module), rate limiting (GCRA), key eviction protection (BLESS), and a comprehensive module system. The architecture is a single-threaded event loop (ae) with optional IO threads, supporting a wide range of data structures: strings, hashes, lists, sets, sorted sets, streams, geospatial indexes, HyperLogLog, and bitfields. Persistence is provided via RDB snapshots and AOF logs, with replication and cluster support. The codebase is a fork/derivative of Redis/Valkey, incorporating additional features not present in upstream, such as hash field expiration (ebuckets/estore), per-key metadata (keymeta), and a Fenwick tree-based key selection (kvstore). Key entry points include the redis-server daemon, redis-cli, redis-benchmark, and module loading via the redismodule.h API. External dependencies include jemalloc, hiredis, Lua 5.1, linenoise, tre, xxhash, OpenSSL, and optional ZSTD compression. The system is designed for high throughput and low latency, with extensive use of custom memory management (zmalloc) and data structure optimizations.
Authorizer is a self-hosted, production-grade authentication and authorization server written in Go. It implements OAuth 2.0 / OIDC, SAML IdP/SP, SCIM 2.0, WebAuthn/passkeys, TOTP, email/SMS OTP, and fine-grained authorization via an embedded OpenFGA engine. The architecture is transport-agnostic: a shared service layer (internal/service) is called by GraphQL resolvers, gRPC handlers, and HTTP handlers (Gin). It supports multiple storage backends (SQL, MongoDB, Cassandra, DynamoDB, Couchbase, ArangoDB) via a unified storage.Provider interface, plus Redis and in-memory stores for sessions and caching. The system includes a React admin dashboard, an end-user login SPA, and an MCP (Model Context Protocol) server for AI tool exposure. Security is a primary focus, with extensive regression tests for CVEs, SSRF protection, constant-time comparisons, and audit logging.
DBeaver is a universal database management tool and SQL client, built as a desktop application on the Eclipse RCP (OSGi plugin) framework. It provides a rich graphical interface for connecting to over 100 database systems via JDBC/ODBC drivers, including relational databases (MySQL, PostgreSQL, Oracle, SQL Server, SQLite, etc.), cloud databases (BigQuery, Athena, Snowflake), and NoSQL systems (MongoDB, Cassandra) in commercial editions. The application offers a full suite of database development features: a multi-tab SQL editor with syntax highlighting, code completion, and execution plan visualization; a data editor with grid, form, and GIS geometry views; ER diagram designer; data export/import wizards supporting CSV, JSON, XML, SQL, Markdown, and Excel; dashboard widgets for query-based monitoring; and an integrated AI assistant (OpenAI, Copilot) for natural language query generation and schema analysis. The architecture follows a strict model/UI separation enforced by OSGi plugin boundaries. The core model plugin (`org.jkiss.dbeaver.model`) defines interfaces for database objects, data values, execution contexts, and security, which are implemented by database-specific extension plugins (`org.jkiss.dbeaver.ext.*`). UI plugins (`org.jkiss.dbeaver.ui.*`) provide editors, navigators, and dialogs, while data transfer, debugging, and AI features are isolated in their own plugins. This design allows the model layer to be reused in the web-based CloudBeaver product. Key entry points include the `DBeaverApplication` class for startup, the `SQLEditor` for query editing, and the `DataTransferWizard` for import/export. External dependencies include the Eclipse RCP framework, JDBC drivers, ANTLR4 for SQL grammar parsing, JSQLParser for SQL analysis, and various third-party libraries for SSH tunneling, AWS SDK, and AI API communication. Data flows center around database connections: users configure data sources via connection wizards, execute SQL queries through the editor, and view results in data grids or export pipelines. The data transfer subsystem implements a producer/consumer pattern with pluggable transformers and serializers, supporting streaming for large datasets. The AI integration uses a provider abstraction to interface with different LLM APIs, generating SQL from natural language and providing schema-aware context. The repository also includes a CLI tool (`dbvr`) for CI/CD automation and a headless test platform. While the community edition is fully open-source, commercial versions add NoSQL support, additional AI providers, and premium features, with some code paths guarded by feature flags.
OrientDB is a multi-model NoSQL database management system supporting document, graph, object, and relational data models within a single engine. It provides ACID transactions, a SQL-like query language, distributed clustering with automatic sharding and replication, full-text and spatial indexing via Lucene, and a Gremlin graph traversal API. The system is implemented in Java and organized into modular components: a core storage engine with pluggable index structures (SB-Tree, hash, Lucene), a binary client-server protocol, an HTTP REST API, and a web-based administration studio (AngularJS). It includes enterprise features such as backup/restore, metrics monitoring, and security auditing. The architecture follows a plugin-based server model, allowing extensions for authentication, indexing, and custom commands. External dependencies include Dropwizard Metrics, Lucene, Gremlin/TinkerPop, and various compression libraries.
ObjectBox Java is an open-source, embedded NoSQL database library for Java and Kotlin, targeting Android, JVM, and desktop platforms. It provides a high-performance, native-backed object persistence engine with type-safe querying, reactive data observation, object relations (ToMany/ToOne), vector search via HNSW indexes, and optional client-server or mesh peer-to-peer synchronization. The code is organized into multiple Gradle modules including a core `objectbox-java` module with JNI bindings, an annotation API (`objectbox-java-api`), Kotlin extensions, RxJava 2/3 adapters, Android-specific integrations (LiveData, Admin web UI, Paging DataSource), and a mesh sync module using Google Nearby Connections. The architecture is library-centric with a clear separation between Java-facing API, internal serialization (vendored FlatBuffers), and native runtime. Extensive unit and integration tests cover core CRUD, transactions, queries, relations, sync, and error handling. The repository is actively maintained with a version 6.0.0-beta, publishes to Maven Central, and uses multi-platform CI (GitLab, Jenkins). While the codebase includes some legacy APIs and generated FlatBuffers code, the core abstractions exhibit solid software engineering practices with reusable patterns for reactive subscriptions, property converters, and cross-platform native library loading.
The ReplicaDB repository is a high-performance, open-source command-line tool for bulk data replication between heterogeneous databases. It supports a wide range of data sources, including relational databases, NoSQL databases, data virtualization platforms, file formats, cloud storage, and streaming platforms. The tool is cross-platform compatible with Windows, Linux, and macOS, and leverages parallel data transfer for optimal performance and system utilization during large-scale data migrations and synchronization tasks.
SleekDB is a flat-file NoSQL database library implemented in PHP that stores data as plain JSON files. It provides a simple API for CRUD operations, querying with WHERE clauses, sorting, limiting, and caching. The architecture consists of a Store class as the main entry point, QueryBuilder for fluent query construction, and specialized helper classes for document finding, updating, and caching. Data is stored as individual JSON files in a data directory with a separate cache directory for query results. The library requires no third-party dependencies beyond PHP 8.4+ with JSON and MBString extensions. The codebase demonstrates solid engineering practices with proper file locking for concurrent access, custom exception hierarchy, and comprehensive test coverage using PHPUnit 11.0. The query builder follows the builder pattern with method chaining. Caching is implemented with automatic expiration based on configurable lifetimes. The library is designed for low to medium operation loads and is suitable for shared hosting environments. Some deprecated methods are marked for removal in version 3.0, indicating active maintenance and refactoring. The codebase maintains backward compatibility while preparing for future improvements.
Dejavu is a single-page web application that provides a modern UI for browsing, searching, and managing data in Elasticsearch and OpenSearch clusters. It is built with React 18, Redux, Redux-Saga, and Ant Design, and leverages the ReactiveSearch library for search UI components. The application runs entirely client-side, communicating directly with the Elasticsearch REST API. It supports CRUD operations, data import/export (JSON/CSV), field mapping management, term-based filtering, global search, and a search preview builder. The codebase is organized as a monorepo with two packages: a reusable browser component library (`@appbaseio/dejavu-browser`) and the main application (`dejavu-main`). The architecture follows a standard Redux pattern with sagas for side effects, and uses react-virtualized for high-performance data grids. While the code is well-structured and feature-rich, it relies on several outdated dependencies (Redux 3.x, redux-saga 0.16, react-router-dom 4.x, emotion 9.x) and uses Flow type annotations, which are now deprecated. The project appears to be in a stale maintenance state with no recent commits.
RethinkDB is an open-source, distributed, NoSQL database designed for real-time applications. It stores JSON documents and supports automatic failover, sharding, and replication. The system exposes a powerful query language (ReQL) with support for joins, aggregations, geospatial queries, and real-time change feeds. The architecture is built on a custom coroutine runtime for efficient concurrency, a log-structured storage engine with B-tree indexes, and a peer-to-peer clustering layer using Raft consensus for metadata management. External dependencies include OpenSSL, Protobuf, jemalloc, zlib, and QuickJS for JavaScript execution. The codebase demonstrates strong engineering in distributed systems, but is now stale with limited active maintenance and significant technical debt from outdated C++ practices and vendored third-party libraries.
Djongo is a Django database backend that enables using MongoDB as the database engine without modifying the Django ORM. It translates SQL queries (generated by Django's ORM) into MongoDB aggregation pipelines and commands, and provides custom model fields for embedded documents, arrays, and ObjectIds. The core is a SQL-to-MongoDB compiler implemented in the `sql2mongo/` package, which parses SQL tokens and maps them to MongoDB operators and stages. The repository also includes a commercial documentation site built with Angular and Jekyll, and references a paid cloud service (DjongoCS). The library is in alpha stage, with many features explicitly unsupported (indexes, transactions, schema validation, etc.) and pinned to very old versions of Django (≤3.1.12), pymongo (≤3.11.4), and sqlparse (0.2.4). The codebase shows signs of neglect: use of `print` for warnings, many `raise NotSupportedError` placeholders, and incomplete implementations. While the SQL-to-MongoDB translation logic is conceptually interesting, the overall package is not production-ready for modern Django/MongoDB stacks.