Open-source alternatives to Hive

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

FASTER is a high-throughput key-value store that combines an in-memory data store with a hybrid memory-disk storage engine, enabling datasets larger than available RAM. It uses a latch-free, cache-optimized index for concurrent point lookups and heavy updates, and records all mutations to a persistent append-only log on disk with checksum validation and group-commit checkpointing for crash recovery. The system supports multi-key transactional workloads through atomic multi-key locking, ensuring transactional consistency without coarse-grained contention. It exposes the key-value store to remo

Olric is a distributed data grid and in-memory key-value store that partitions and replicates data across a cluster of servers. It serves as a shared memory system for managing distributed maps, performing atomic operations, and acting as an in-memory data cache. The system provides a distributed locking mechanism for concurrency control and a pub-sub messaging system that broadcasts and routes messages over named channels across the cluster. The platform covers wide-ranging capabilities including cluster management and orchestration, data replication with configurable quorums, and automated

This project is an educational codebase and asynchronous network implementation of a Redis-compatible server and client. It serves as a demonstration of the Tokio asynchronous runtime, providing a networked key-value store and a messaging system. The project implements the Redis Serialization Protocol to communicate between clients and servers using byte streams. It features a pub-sub messaging system that allows clients to subscribe to named channels and receive real-time updates. The implementation covers asynchronous network programming, including concurrent TCP connection handling and by

Sled is an embedded key-value store and ACID-compliant database designed for high-performance data persistence. It functions as a log-structured storage engine that organizes data using B+ trees to support efficient range queries and prefix scans. The engine implements a zero-copy data store model, utilizing epoch-based reclamation to provide direct references to cached values without memory allocations. It distinguishes itself through a combination of write-ahead logging, page cache optimizations to reduce write amplification on flash storage, and serializable transactions for atomic multi-k

DiceDB is a distributed cache manager and hierarchical storage engine based on a Valkey key-value store. It functions as a high-availability key-value cluster that balances performance and cost by distributing data across memory and disk tiers. The system supports working sets larger than available RAM by persisting evicted keys to disk and restoring them on demand. It also includes a real-time query subscription system that notifies clients when data matching specific criteria is updated. The project provides distributed cache coordination through master node health monitoring and quorum-ba

Redis is a high-performance in-memory key-value store that functions as a distributed cache, message broker, and NoSQL database. It provides sub-millisecond read and write access to data stored in RAM and can operate as a vector database for indexing high-dimensional embeddings. The system supports a wide range of data storage and synchronization primitives, including the management of strings, hashes, lists, sets, and JSON documents. It enables real-time data operations through atomic transactions, hybrid persistence using snapshots and append-only logs, and high-availability configurations

LedisDB is a distributed NoSQL key-value store built in Go. It functions as a high-performance database server that persists simple values, counters, and complex data structures using pluggable storage engines. The system implements the Redis protocol to maintain compatibility with existing client libraries and drivers, while also providing an HTTP interface that exposes database functions through JSON, BSON, or msgpack formats. It includes an embedded virtual machine to execute custom server-side Lua scripts for complex operations. The platform supports high availability through data replic

RocksDB is a high-performance, embeddable persistent key-value library and storage engine based on Log-Structured Merge-trees. It is designed to provide durable storage for large-scale datasets, integrating directly into applications to manage data on flash and RAM-based hardware. The engine is distinguished by its focus on minimizing read and write amplification through multi-threaded compaction and custom memory allocators. It features specialized optimizations for flash storage, including support for zoned block devices, and provides the ability to extend store behavior via external plugin

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

Dice is a low-latency key-value store based on Valkey that functions as a hierarchical storage engine. It combines a high-speed memory store with a tiered cache system to manage data across multiple storage levels. The system extends memory capacity by implementing a disk-backed cache that automatically persists evicted items to disk and restores them during cache misses. This storage tiering balances retrieval speed and operational cost by distributing data between fast memory and slower disk storage. The engine includes a query subscription service that monitors specific data patterns and

RoseDB is a persistent key-value database and log-structured storage engine. It functions as a lightweight storage system that utilizes a log-structured hash table and a Bitcask engine implementation to provide fast data retrieval and disk-backed persistence. The system operates as an atomic transaction engine, grouping multiple read and write operations into single units to maintain data consistency. It handles data through a key-value model that supports individual insertions, lookups, and deletions. The database provides capabilities for batch data processing and atomic updates. Additiona

react-native-mmkv is a synchronous mobile persistence system that provides an encrypted key-value store for mobile applications. It serves as a high-performance wrapper for the MMKV storage engine, eliminating asynchronous overhead by reading and writing values directly to disk. The project distinguishes itself through shared app group storage, which allows data access across multiple application extensions via a shared filesystem directory. It also provides state-synced storage hooks that automatically trigger component updates when stored key-value pairs change. The system covers a broad r

Badger is an embeddable key-value store written in Go that provides persistent data storage for byte keys and values. It is a persistent database that utilizes a tiered LSM tree storage model to optimize disk storage and retrieval efficiency. The system features an ACID transaction engine that ensures data integrity through serializable snapshot isolation and multi-version concurrency control. It also provides an encrypted key-value store with data-at-rest encryption and a managed encrypted key registry to secure stored information. The engine covers a broad set of capabilities including hig

bbolt is an ACID-compliant embedded key-value store for Go applications. It persists all data in a single memory-mapped file on disk, organizing information using B+ trees to facilitate sorted key iteration and efficient range queries. The project distinguishes itself through a hierarchical data organization model, allowing buckets to be nested within other buckets to create a tree-like structure. It employs a single-writer, multi-reader locking mechanism and copy-on-write transactions to ensure serializable isolation and data integrity. The system includes comprehensive data management capa

React Native AsyncStorage is a persistent key-value storage library designed for React Native applications. It provides a unified local storage interface that works identically on both iOS and Android, ensuring saved data remains available across app restarts and when the device has no network connectivity. The library uses an asynchronous background I/O queue to handle all storage operations without blocking the JavaScript thread, communicating with native storage engines through React Native's bridge protocol. It includes a serialization layer that converts JavaScript values to strings for

node-redis is a Node.js client and database driver for interacting with Redis key-value stores. It functions as a connection manager and data iterator, allowing applications to execute database commands and manage atomic transactions on a remote server using asynchronous JavaScript. The project provides specialized capabilities for handling large datasets through an asynchronous interface and supports connection pooling to isolate blocking operations. It includes support for client-side caching and token-based authentication via Entra ID. The driver covers a broad range of operational areas,

Garnet is a multi-threaded in-memory database and distributed key-value store. It functions as a high-performance remote cache store that implements the RESP wire protocol to maintain compatibility with existing Redis clients and libraries. The project is distinguished by a shared-memory architecture that enables parallel request processing across multiple cores for sub-millisecond latency. It features a tiered storage system that automatically offloads colder data from system memory to SSD or cloud storage layers, and includes a specialized vector search database for high-dimensional similar

RedisInsight is a graphical user interface and management tool for browsing, analyzing, and administering Redis databases. It provides a visual environment for exploring key-value data structures, managing database instances, and performing data analysis across different operating systems and deployments. The tool distinguishes itself by providing dedicated visual managers for complex operations, including a vector database manager for configuring embeddings and similarity searches, a query workbench for executing raw commands and Lua scripts, and a performance monitoring dashboard for tracki

TinyBase is a reactive data store and in-memory relational database designed for client-side state persistence. It serves as a local-first sync engine that merges distributed state using conflict-free replicated data types and logical clocks to ensure deterministic data convergence. The project features a schema validation library that converts external definitions from tools like Zod, Yup, and TypeBox into type-safe store definitions. It provides an infrastructure for real-time collaborative editing, utilizing synchronization with Automerge, Yjs, and PartyKit to maintain consistent state acr

Dexie.js is a wrapper library for IndexedDB that provides a simplified interface for managing and querying structured data within the browser. It functions as a browser database manager used to maintain persistent application state and store binary blobs and records. The project serves as an offline-first data store that synchronizes browser data with remote servers to maintain consistency across sessions. It also acts as a reactive database store by monitoring data changes in real time to trigger automatic user interface updates, and functions as a client-side search engine for indexing and

Simpl is an HTML, CSS, and JavaScript example library that provides a collection of minimal functional demonstrations of core web technologies and native browser APIs. It serves as a reference implementation and pattern gallery for frontend development, offering practical examples of how to implement common web features. The project showcases a wide range of browser capabilities, including real-time web communication via WebSockets and WebRTC, responsive web design techniques for adaptive layouts, and the implementation of offline workflows using service workers. It also provides demonstratio

go-cache is a thread-safe, in-memory key-value store for single-machine applications. It provides a local caching mechanism that stores objects in RAM to reduce redundant data retrieval and avoid the overhead of network protocols or serialization. The system features a persistent cache store that saves the in-memory state to a local file, allowing data recovery across application restarts. The project manages concurrent data access across multiple routines and implements time-to-live expiration for cached entries. A background process periodically scans the store to delete expired items and

LevelDB is an embedded database library and persistent storage engine that provides a sorted key-value store. It uses a log-structured merge-tree architecture to map byte arrays to values, running directly within a process to provide storage without the need for a separate server process. The system is distinguished by its use of custom comparison functions to define key ordering, enabling efficient range scans and sequenced lookups. It ensures data reliability through atomic batch execution, consistent snapshot generation, and log-based recovery after failures. The engine covers broad capab

This project provides a high-performance key-value storage solution for mobile applications, utilizing memory-mapped files to enable rapid read and write operations. It functions as a persistent data layer that integrates directly with the JavaScript runtime to minimize overhead, while supporting reactive state synchronization to ensure interface components update automatically when stored data changes. The storage system distinguishes itself through its ability to manage multiple independent database instances, which organizes data by module and prevents collisions between application compon

This project is a TypeScript mobile application scaffold and framework template for building cross-platform iOS and Android applications. It provides a standardized architectural starting point that emphasizes a separation of concerns by isolating business logic from the user interface. The template functions as an architecture kit with built-in support for environment-aware configurations, allowing different API secrets and settings across development and production builds. It also serves as an internationalized starter project featuring dynamic visual theme injection and multi-language loca

Node-cache is a lightweight in-memory data storage module designed for Node.js applications. It functions as a key-value store that maintains frequently accessed data directly within the application runtime to improve response times and reduce latency. The library manages the lifecycle of stored information through automated expiration policies, which use internal timers to remove stale entries once a defined time-to-live duration has elapsed. It provides granular control over stored resources, allowing for the manual inspection, deletion, or clearing of specific keys to manage memory usage e