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.
SearXNG is a privacy-respecting metasearch engine that aggregates results from over 100 search engines (Google, Bing, DuckDuckGo, Wikipedia, academic sources, etc.) via HTTP requests. It runs as a Flask web application, supports multiple output formats (HTML, JSON, RSS), and includes a plugin system, bot detection, rate limiting, and user preferences stored in cookies. The architecture is a monolithic Python application with a separate TypeScript/Less frontend built with Vite. It uses Valkey/Redis for caching and rate limiting, and SQLite for persistent caches. The codebase is well-structured with a clear separation of concerns: engine modules implement a common request/response interface, result types are typed with msgspec, and plugins are registered via a simple hook system. It is actively maintained with CI/CD, Docker support, and comprehensive documentation.
Redisson is a feature-rich Java client for Valkey and Redis that extends basic key-value storage with distributed Java collections, objects, and services. It provides synchronous, asynchronous, and reactive APIs for Redis operations, along with integrations for popular frameworks like Spring, Micronaut, Quarkus, and Hibernate. The library implements advanced Redis features including streams, geo-spatial indexing, pub/sub, bloom filters, and distributed computing primitives. Its architecture features a clean separation between core Redis protocol handling, codec-based serialization, and framework-specific adapters, making it a versatile tool for building distributed applications with Redis as a backend.
dogpile.cache is a mature Python caching library that provides a generic caching API with a 'dogpile lock' mechanism to prevent thundering herd problems during cache regeneration. The library is structured around a central `CacheRegion` class that configures a pluggable backend (memory, memcached, redis, valkey, dbm, null) and exposes high-level operations like `get_or_create`, `set`, `get`, and `delete`. It also offers function decorators (`cache_on_arguments`, `cache_multi_on_arguments`) that automatically generate cache keys from function arguments and manage expiration and invalidation. The architecture follows a layered design: the `dogpile.lock` module implements the core dogpile lock (a mutex-based coordination pattern), the `dogpile.cache.api` module defines abstract base classes for backends and serialization, and concrete backends in `dogpile.cache.backends` implement the actual storage. The `CacheRegion` orchestrates key mangling, serialization, expiration, and invalidation strategies. External dependencies are minimal (decorator, stevedore, typing_extensions), with optional backends pulling in redis, valkey, pymemcache, etc. Key entry points include `make_region()` to create a region, `CacheRegion.configure()` to set up a backend, and `CacheRegion.get_or_create()` for atomic cache-and-generate operations. The library is well-tested with extensive unit and integration tests, uses modern Python features (type hints, ABCs, context managers), and follows a clean, maintainable code style. It is actively maintained as part of the SQLAlchemy project.