awesome-repositories.com
Blog
awesome-repositories.com

Descubre los mejores repositorios open-source con nuestra búsqueda potenciada por IA.

ExplorarBúsquedas curadasAlternativas open-sourceSoftware autohospedableBlogMapa del sitio
ProyectoAcerca deCómo clasificamosPrensaServidor MCP
Aviso legalPrivacidadTérminos
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·

297 repositorios

Awesome GitHub RepositoriesKey-Value Stores

Simple storage systems for persisting small amounts of application state.

Distinguishing note: Focuses on lightweight, non-relational key-value persistence.

Explore 297 awesome GitHub repositories matching data & databases · Key-Value Stores. Refine with filters or upvote what's useful.

Awesome Key-Value Stores GitHub Repositories

Encuentra los mejores repositorios con IA.Buscaremos los repositorios que mejor coincidan usando IA.
  • expo/expoAvatar de expo

    expo/expo

    50,111Ver en GitHub↗

    Expo is a universal mobile framework designed to build native iOS and Android applications from a single codebase using web-standard technologies. It provides a comprehensive development environment that includes a unified runtime for testing, cloud-based infrastructure for compiling and signing native binaries, and automated tools for managing the entire mobile release lifecycle, including app store submission. The framework distinguishes itself through a plugin-based native configuration engine that programmatically modifies project files, allowing developers to integrate native modules wit

    Expo provides a simple and persistent asynchronous key-value storage mechanism for saving non-sensitive data like user preferences or application state.

    TypeScriptandroidapp-frameworkexpo
    Ver en GitHub↗50,111
  • heyputer/puterAvatar de HeyPuter

    HeyPuter/puter

    42,318Ver en GitHub↗

    Puter is a browser-based desktop environment and cloud-native development platform that provides a virtualized graphical workspace. It enables developers to build and deploy full-stack web applications by integrating cloud storage, authentication, and serverless backend logic directly into the browser, eliminating the need for traditional server infrastructure. The platform distinguishes itself through a unified cloud storage layer and a distributed network runtime that facilitates peer-to-peer communication and cross-origin resource fetching. It features a sophisticated cross-window orchestr

    Provides key-value database storage for efficient data management.

    TypeScriptcloudcloud-oscloud-storage
    Ver en GitHub↗42,318
  • google/leveldbAvatar de google

    google/leveldb

    39,152Ver en GitHub↗

    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

    Maintains entries in a specific sequence using custom comparison functions for efficient range scans.

    C++
    Ver en GitHub↗39,152
  • dokploy/dokployAvatar de Dokploy

    Dokploy/dokploy

    34,901Ver en GitHub↗

    Dokploy is a self-hosted platform-as-a-service designed to simplify the deployment and management of containerized applications and databases. It provides a centralized control plane that decouples administrative management from application workloads, allowing users to oversee infrastructure across multiple server nodes through a unified web interface or a command-line tool. The platform distinguishes itself through an extensive library of pre-configured application templates, enabling the rapid deployment of databases, identity providers, and various productivity or development tools. It sup

    Provides a high-performance, open-source key-value data store.

    TypeScriptbackendbackupsdatabases
    Ver en GitHub↗34,901
  • surrealdb/surrealdbAvatar de surrealdb

    surrealdb/surrealdb

    32,397Ver en GitHub↗

    SurrealDB is a multi-model database engine designed to store and query document, graph, relational, and vector data within a single ACID-compliant platform. It functions as an AI-native data store, integrating vector search, graph traversal, and machine learning model execution directly into its query layer. By providing a unified declarative query language, the platform eliminates the need for external middleware to synchronize data across different storage models. The platform distinguishes itself through its ability to manage agent memory and complex workflows natively. It allows developer

    Stores information in an embedded database using a reliable key-value interface.

    Rustbackend-as-a-servicecloud-databasedatabase
    Ver en GitHub↗32,397
  • searxng/searxngAvatar de searxng

    searxng/searxng

    32,180Ver en GitHub↗

    This project is a privacy-focused, self-hosted metasearch engine that aggregates results from a wide array of web, academic, and media sources into a single, unified interface. By acting as a proxy between the user and external search providers, it strips identifying headers and tracking parameters from requests, ensuring that search activity remains anonymous and protected from third-party profiling. The platform distinguishes itself through a modular, plugin-based architecture that allows for extensive customization of search behavior, result filtering, and interface branding. It supports a

    Maintains a persistent key-value store for search results to reduce latency and redundant network requests.

    Pythonbingbravedegoogle
    Ver en GitHub↗32,180
  • facebook/rocksdbAvatar de facebook

    facebook/rocksdb

    31,767Ver en GitHub↗

    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

    Serves as a persistent, embeddable key-value store integrated directly into applications.

    C++databasestorage-engine
    Ver en GitHub↗31,767
  • dragonflydb/dragonflyAvatar de dragonflydb

    dragonflydb/dragonfly

    30,688Ver en GitHub↗

    Dragonfly is a high-performance, multi-model in-memory data store designed to serve as a drop-in replacement for existing database infrastructures. By utilizing a multi-threaded, shared-nothing architecture and a fiber-based concurrency model, it maximizes CPU utilization and minimizes latency for read and write operations. The system supports a wide range of data structures, including strings, hashes, lists, sets, sorted sets, and JSON documents, while maintaining full compatibility with standard industry wire protocols and client libraries. What distinguishes Dragonfly is its focus on effic

    Dragonfly executes standard key-value operations such as setting, getting, deleting, and checking the existence of keys across various supported data types.

    C++cachecppdatabase
    Ver en GitHub↗30,688
  • jashkenas/backboneAvatar de jashkenas

    jashkenas/backbone

    28,108Ver en GitHub↗

    Backbone is a JavaScript MVC framework and client-side data orchestrator used to structure web applications. It functions as an event-driven UI library and RESTful state manager that synchronizes data models with remote JSON interfaces to maintain consistent application state. The framework coordinates communication between application components through a decoupled event system. It binds data updates directly to the document object model, ensuring that the user interface remains synchronized with the underlying state. It provides tools for frontend data organization, allowing developers to

    Stores application state in simple object maps for fast retrieval and attribute tracking.

    JavaScript
    Ver en GitHub↗28,108
  • mozilla/localforageAvatar de mozilla

    mozilla/localForage

    25,780Ver en GitHub↗

    localForage is a browser storage wrapper and key-value store that provides a unified JavaScript API for persisting data. It acts as an abstraction layer over IndexedDB, WebSQL, and localStorage, allowing web applications to save data offline. The library features a priority-based driver fallback system that automatically detects and selects the most capable storage engine available in the browser. It simplifies data management by providing an asynchronous interface for storing complex JavaScript objects and binary buffers without requiring manual serialization. The project covers broad capab

    Implements a lightweight key-value store for persisting application state in the browser.

    JavaScript
    Ver en GitHub↗25,780
  • localforage/localforageAvatar de localForage

    localForage/localForage

    25,755Ver en GitHub↗

    This project is an asynchronous key-value store designed for client-side data persistence. It provides a unified interface that allows applications to save and retrieve complex data types, including binary objects, while maintaining responsiveness through non-blocking operations. By enabling offline-first functionality, it ensures that data remains accessible even when a network connection is unavailable. The library distinguishes itself through a driver-based abstraction layer that automatically detects the most efficient storage mechanism available in the current browser or mobile environme

    Provides a persistent storage layer with a unified interface for saving complex data types.

    JavaScriptindexeddbjavascriptlocalforage
    Ver en GitHub↗25,755
  • asciimoo/collyAvatar de asciimoo

    asciimoo/colly

    25,348Ver en GitHub↗

    Colly is a web scraping framework and concurrent crawler written in Go. It provides a system for traversing web pages, following links, and extracting structured data from HTML and XML documents. The framework includes a distributed scraping engine designed to spread data collection tasks across multiple instances to increase throughput. It ensures compliance with website owner policies by automatically reading and respecting robots.txt files. The system manages request lifecycles through domain-based rate limiting, concurrency controls, and session management via a stateful cookie jar. It s

    Provides pluggable response caching to reduce redundant network requests and increase scraping speed.

    Go
    Ver en GitHub↗25,348
  • langchain-ai/deepagentsAvatar de langchain-ai

    langchain-ai/deepagents

    25,006Ver en GitHub↗

    Deepagents is an LLM agent orchestration platform and stateful application server designed for deploying and managing AI agents built with computational graphs. It provides a containerized runtime environment that handles agent execution, state persistence, and the versioning of AI assistants. The platform distinguishes itself through deep integration with the Model Context Protocol, allowing agents to function as servers that expose tools and capabilities to external clients. It features a sophisticated observability suite for capturing execution traces, performing LLM-based evaluations agai

    Stores serializable values with expiration logic to reduce redundant agent computations.

    Pythonagentsdeepagentslangchain
    Ver en GitHub↗25,006
  • valkey-io/valkeyAvatar de valkey-io

    valkey-io/valkey

    24,875Ver en GitHub↗

    Valkey is an in-memory, NoSQL database server designed for high-performance data storage and real-time state management. It operates as a distributed key-value store, maintaining datasets entirely within system memory to facilitate sub-millisecond response times for read and write operations. The system distinguishes itself through a single-threaded event loop that utilizes asynchronous I/O multiplexing to ensure high throughput. It supports high availability via master-replica replication and provides a decoupled communication model through a built-in publish-subscribe messaging pattern. To

    Organizes data into distributed key-value pairs for high availability.

    Ccachedatabasekey-value
    Ver en GitHub↗24,875
  • mrniko/redissonAvatar de mrniko

    mrniko/redisson

    24,355Ver en GitHub↗

    Redisson is a Java client library for Redis and Valkey that provides a distributed data structure library, a distributed lock manager, and a distributed MapReduce framework. It enables application instances in a cluster to share state through thread-safe collections and objects. The project implements a JCache compliant caching layer for standardized data storage and retrieval. It also functions as a probabilistic data store, providing memory-efficient structures such as Bloom filters and HyperLogLog for high-volume data membership testing. The library covers distributed state management usi

    Maps local Java object methods to remote Redis commands through a specialized serialization layer.

    Java
    Ver en GitHub↗24,355
  • redisson/redissonAvatar de redisson

    redisson/redisson

    24,355Ver en GitHub↗

    Redisson is a Java library and Redis client that functions as a distributed Java object mapper, caching provider, and locking framework. It maps Java collections and concurrency primitives to distributed implementations backed by Redis and Valkey, providing synchronous, asynchronous, and reactive APIs for interacting with these data stores. The project distinguishes itself by providing a comprehensive suite of distributed coordination tools, including a locking framework for managing semaphores and countdown latches across multiple application nodes. It also serves as a distributed messaging

    Maps plain Java objects to remote storage with support for persistence, indexing, and cascade handling.

    Java
    Ver en GitHub↗24,355
  • ramda/ramdaAvatar de ramda

    ramda/ramda

    24,072Ver en GitHub↗

    Ramda is a functional JavaScript standard library and toolset for immutable data transformation and composition. It provides a comprehensive suite of pure utility functions designed to enable declarative data processing pipelines. The library is distinguished by its use of automatic function currying and a data-last argument order. These design patterns allow multi-argument functions to be partially applied, simplifying the construction of processing chains where data is passed through a sequence of operations. The toolkit covers broad data manipulation capabilities, including list processin

    Renames object keys using mapping objects or transformation functions.

    JavaScriptjavascriptramda
    Ver en GitHub↗24,072
  • apify/crawleeAvatar de apify

    apify/crawlee

    24,002Ver en GitHub↗

    Crawlee is a web scraping framework designed for building scalable, reliable, and distributed data extraction pipelines. It provides a unified interface for managing headless browser automation and lightweight HTTP requests, allowing developers to handle complex web navigation, dynamic content rendering, and large-scale data collection within a single, modular architecture. The project distinguishes itself through its resource-aware concurrency controller, which dynamically scales task execution based on real-time CPU and memory usage to prevent host machine exhaustion. It also features a rob

    Manages persistent key-value storage for configuration and state associated with crawling tasks.

    TypeScriptapifyautomationcrawler
    Ver en GitHub↗24,002
  • quii/learn-go-with-testsAvatar de quii

    quii/learn-go-with-tests

    23,510Ver en GitHub↗

    This project is an educational platform and tutorial series designed to teach the Go programming language through the practice of test-driven development. It provides a structured path for developers to master language fundamentals, concurrency, and standard library usage by building functional applications in small, verifiable increments. The core methodology centers on the test-driven development cycle, where failing tests are written before implementation to define requirements and ensure code correctness. This approach is applied across a wide range of practical scenarios, including the c

    Associates values with unique keys to enable efficient data retrieval.

    Gogogolangtdd
    Ver en GitHub↗23,510
  • jhao104/proxy_poolAvatar de jhao104

    jhao104/proxy_pool

    23,426Ver en GitHub↗

    This project is a Python-based proxy pool manager that collects, validates, and serves free proxy IP addresses through an HTTP API. It consists of an automated scraper to gather addresses from multiple online sources, a persistent database-backed store for organization, and a delivery interface for retrieving validated proxies. The system features a pluggable scraper architecture that allows for the integration of custom discovery methods and source expansion via generator functions. It employs decorator-based validation logic, enabling the definition of custom connectivity and HTTPS criteria

    Implements a persistent database-backed store using hashes for high-speed proxy IP retrieval.

    Pythoncrawlerhttpproxy
    Ver en GitHub↗23,426
Ant.123456…15Siguiente
  1. Home
  2. Data & Databases
  3. Key-Value Stores

Explorar subetiquetas

  • Append-Only Log Stores1 sub-etiquetaStorage systems that persist data to an append-only file with an in-memory index. **Distinct from Key-Value Stores:** Specific implementation detail of the key-value store using a log and offsets, rather than a generic store.
  • Atomic Field Updates1 sub-etiquetaDirect numeric increments or decrements on specific database fields to prevent race conditions. **Distinct from Atomic Key Updaters:** Distinct from key-value updates; focuses on numeric field modification within a document store.
  • Atomic Key Updaters6 sub-etiquetasOperations for saving and conditionally updating key-value pairs based on revision checks. **Distinct from Key-Value Stores:** Distinct from Key-Value Stores: focuses on the atomic update operation rather than the storage system itself.
  • Backend Compatibility LayersInterfaces that provide a unified API to make multiple different storage backends compatible with a specific standard. **Distinct from Key-Value Stores:** Focuses on compatibility mapping to a standard (abstract-leveldown) rather than simple state persistence.
  • Cache Key Management4 sub-etiquetasAdministrative operations for enumerating and deleting specific keys within a cache layer. **Distinct from Key Deletion:** Covers general administrative listing and deletion of cache keys, whereas Key Deletion focuses on session invalidation.
  • Change-Streaming StoresKey-value stores that stream changes to consumers for real-time state synchronization. **Distinct from Key-Value Stores:** Distinct from Key-Value Stores: adds real-time change notification streaming on top of basic key-value storage.
  • Cluster InitializationProcesses for bootstrapping a distributed store from a single node and restoring data from snapshots. **Distinct from Key-Value Stores:** Distinct from Key-Value Stores: focuses on the specific lifecycle phase of initial cluster bootstrapping and data restoration.
  • Concurrent1 sub-etiquetaThread-safe key-value storage systems that allow multiple goroutines to store and retrieve values without data races. **Distinct from Key-Value Stores:** Distinct from Key-Value Stores: adds thread-safe concurrent access guarantees, not just simple key-value persistence.
  • Decentralized NoSQL StoresNon-relational storage systems that operate across a peer-to-peer network. **Distinct from Key-Value Stores:** Adds the decentralized/P2P requirement to the general NoSQL/Key-Value store pattern.
  • Default Value Assignments4 sub-etiquetasFallback values assigned to keys when no data is explicitly stored in a key-value system. **Distinct from Key-Value Stores:** Specifically handles default values for key-value storage retrieval, distinct from database schema defaults.
  • Dual-Store SynchronizationProcesses for mirroring data between offline warehouses and online key-value stores for ML serving. **Distinct from Key-Value Stores:** Specifically targets the synchronization between two different storage tiers for features, not general KV persistence.
  • Duplicate Key Handling1 sub-etiquetaStrategies for storing and managing duplicate keys in key-value storage systems. **Distinct from Key-Value Stores:** Distinct from Key-Value Stores: focuses on handling duplicate keys within a store, not the store itself.
  • In-Memory State Maps1 sub-etiquetaLightweight key-value structures used for tracking application state in memory. **Distinct from Key-Value Stores:** Focuses on in-memory application state binding rather than persistent database storage.
  • Key Browsers2 sub-etiquetasTools for visualizing and navigating stored keys using hierarchical namespace delimiters. **Distinct from Key-Value Stores:** Distinct from Key-Value Stores: focuses on the UI/navigation capability for browsing keys rather than the storage engine itself.
  • Key Deletion4 sub-etiquetasOperations for removing stored data entries to invalidate sessions or revoke access. **Distinct from Key-Value Stores:** Distinct from Key-Value Stores: focuses on the specific operation of removing keys rather than the storage system itself.
  • Key Listing2 sub-etiquetasOperations for retrieving and filtering collections of keys within a storage bucket. **Distinct from Key-Value Stores:** Distinct from Key-Value Stores: focuses on the administrative operation of listing keys rather than the storage engine itself.
  • Key Lookup OperationsRetrieving the value associated with a given key from an associative array, returning null if absent. **Distinct from Key-Value Stores:** Distinct from general Key-Value Stores: focuses on the lookup operation specifically, not the storage system itself.
  • Key Retrievals by Raw Key2 sub-etiquetasRetrieves stored data directly from a key-value store using a raw state key via an RPC endpoint. **Distinct from Key-Value Stores:** Distinct from Key-Value Stores: focuses on retrieving values by raw key via RPC, not general key-value storage.
  • Metadata Caching1 sub-etiquetaCaching of computed image properties and analysis results in a key-value store to avoid redundant computations. **Distinct from Key-Value Stores:** Distinct from Key-Value Stores: specifically targets the caching of image metadata for performance optimization.
  • Performance Benchmarking4 sub-etiquetasAssesses storage and retrieval speed for key-value operations. **Distinct from Key-Value Stores:** Distinct from general key-value stores: focuses on performance testing and benchmarking.
  • Preference OverridesMechanisms for overriding default application settings via key-value mapping. **Distinct from Key-Value Stores:** Distinct from general key-value stores: focuses on application configuration overrides rather than data persistence.
  • Response Caching4 sub-etiquetasTemporary storage of API responses from external providers to improve performance and reduce upstream load. **Distinct from Key-Value Stores:** Distinct from general Key-Value Stores by focusing specifically on the caching of external API responses for performance optimization.
  • SQL-Backed Stores2 sub-etiquetasAdds, lists, sets, or deletes entries in a key-value store backed by a SQL database using parameterized queries. **Distinct from Key-Value Stores:** Distinct from Key-Value Stores: uses a SQL database as the storage engine rather than a dedicated KV store like Redis or LevelDB.
  • Service Discovery StoresHigh-availability key-value stores used specifically for service discovery and cluster health monitoring. **Distinct from Key-Value Stores:** Focuses on the architectural use of KV stores for cluster coordination rather than general application state persistence
  • Session Variable StoresIn-memory key-value stores used to maintain state across a sequence of related network requests. **Distinct from Key-Value Stores:** Specific to request-sequence state rather than general-purpose persistent data storage.
  • Shared-Nothing Scalable StoresKey-value stores that scale linearly by adding commodity servers to a shared-nothing architecture. **Distinct from Key-Value Stores:** Focuses on the architectural scalability and shared-nothing nature, unlike general lightweight key-value stores.
  • SignedKey-value storage systems where each record is cryptographically signed to ensure authenticity. **Distinct from Key-Value Stores:** Distinct from generic key-value stores: requires cryptographic signatures for all stored records to guarantee integrity.
  • Signed Metadata StoresKey-value storage systems that use digital signatures to verify the authenticity of stored metadata. **Distinct from Key-Value Stores:** Adds cryptographic signature verification to standard key-value persistence for decentralized trust.
  • Single-File Persistence2 sub-etiquetasStorage strategies that encapsulate the entire database within a single portable file. **Distinct from Key-Value Stores:** Focuses on the single-file physical storage model rather than the general KV data model.
  • SortedKey-value stores that maintain a specific sequence of entries to enable range queries. **Distinct from Key-Value Stores:** Specifically requires the sorted property, unlike general key-value stores.
  • Store Collection DeletionOperations for removing an entire key-value store and all its associated records. **Distinct from Key Deletion:** Deletes the entire store collection rather than individual keys.
  • Structured Object Mappings4 sub-etiquetasMapping of field-value pairs to unique identifiers for complex entity representation. **Distinct from Key-Value Stores:** Distinct from Key-Value Stores: focuses on the mapping of structured objects to identifiers rather than simple key-value storage.
  • TemporalStorage systems that track values over time, allowing retrieval of the state at a specific timestamp. **Distinct from Key-Value Stores:** Specializes in time-versioned retrieval rather than simple static key-value persistence.
  • Translation MappingsAssociative mappings that link unique keys to localized text strings. **Distinct from Key-Value Stores:** Specifically for UI text translation keys, not general application state persistence
  • Value-Log SeparationArchitectural separation of keys and values into different storage structures to reduce write amplification. **Distinct from Key-Value Stores:** Distinct from general Key-Value stores by specifically separating the key index from the value log.