Open-source alternatives to Cache

LMCache is a distributed key-value cache manager and tiering system designed to accelerate large language model inference. It functions as a tiered storage layer that offloads tensors from GPU memory to CPU RAM, local disks, or remote object stores, enabling the reuse of cached prefixes across different inference sessions and serving engines. The system differentiates itself through a disaggregated prefill-decode model, which separates prompt processing from token generation by transferring caches between distributed compute nodes. It utilizes peer-to-peer orchestration to share and retrieve

Flysystem is a PHP storage library that provides a filesystem abstraction layer. It enables the management of files across local disks, cloud buckets, and remote servers using a unified interface, decoupling application logic from provider-specific APIs. The project facilitates storage provider migration by allowing developers to swap underlying adapters without changing application code. It includes a multi-backend manager capable of mounting volumes and coordinating file movements between diverse storage systems. The library covers a broad range of file operations, including directory list

FusionCache is a .NET caching framework that manages local and distributed data storage. It functions as a hybrid cache implementation, combining fast in-memory storage with a distributed second-level cache to reduce latency and remote data fetches. The framework includes a cache stampede protector that ensures only one request fetches missing data while concurrent calls wait. It synchronizes data across multiple application nodes using a backplane and provides an observability-driven approach with built-in metrics, structured logging, and telemetry. The system covers a broad range of cachin

Groupcache is a distributed caching library designed to coordinate data retrieval and storage across a cluster of nodes. It functions as a peer-to-peer data store that uses consistent hashing to assign specific keys to canonical owners, ensuring that cached items remain predictable and accessible throughout the network. The system distinguishes itself through a request coalescing engine that merges concurrent requests for the same missing key into a single upstream fetch. This mechanism prevents redundant backend load by ensuring that only one process retrieves the required data while sharing

This library is a PHP-based serialization framework designed to convert complex object graphs into structured formats such as JSON, XML, YAML, and CSV, and to reconstruct those objects from serialized data. It functions as a data transformation tool that maps object properties to array structures, facilitating both application state persistence and the exchange of data between systems. The framework distinguishes itself through a two-stage pipeline that normalizes objects into intermediate structures before encoding them into specific formats. It supports advanced mapping requirements, includ

This project is a cache abstraction layer and interface standard for PHP, specifically defining the PSR-6 caching specification. It establishes a consistent set of type definitions and contracts for cache items and pools to ensure interoperability between different PHP libraries. The specification prevents vendor lock-in by separating high-level caching logic from low-level storage implementations. This allows different caching backends to be swapped without requiring changes to the application code. The project focuses on PHP cache standardization and library interoperability through the us

Codis is a distributed proxy system designed for scaling Redis clusters. It provides a sharding proxy that distributes data across multiple instances and a cluster manager to oversee the environment. The system enables horizontal scaling through dynamic resharding, which allows data slots to be migrated between servers without interrupting operations. It supports multi-key atomic operations using hash tags to ensure related keys are routed to the same server. The platform includes a graphical cluster management dashboard for monitoring and administration. It implements high availability prox

This PHP caching library provides a key-value storage abstraction designed to reduce application computation time by storing and retrieving frequently accessed data. It implements the PSR-6 standard for caching interfaces to ensure interoperability between different libraries. The project includes a legacy cache adapter that wraps modern standardized cache pools. This allows systems in transition to maintain compatibility by converting between legacy caching implementations and unified interfaces. The library covers a range of storage capabilities, including a filesystem cache store for pers

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 an educational framework designed to teach the fundamentals of building core distributed systems and web services from scratch in Go. It provides a collection of modular implementations that demonstrate how to construct essential infrastructure components, including web servers, remote procedure call systems, distributed caches, and database abstraction layers. The framework distinguishes itself by focusing on the internal mechanics of these systems rather than providing a high-level abstraction for production use. It covers the implementation of complex architectural patterns

phpredis is a C-based native extension that bridges PHP applications with Redis servers for high-performance data storage and retrieval. It serves as an interface for manipulating strings, hashes, lists, sets, and sorted sets while providing a direct path for executing Redis commands and server-side scripts. The extension provides comprehensive support for distributed environments and high availability. It interfaces with Redis Cluster to distribute data across multiple nodes using hash slots and manages Redis Sentinel for service discovery and automatic failover. It also enables shared state

Parse Server is a backend-as-a-service solution and Node.js framework that provides a ready-to-use REST and GraphQL API for mobile and web applications. It functions as a core backend infrastructure for managing database schemas, user authentication, and API routing. The system distinguishes itself with a real-time data engine that pushes database updates to clients via WebSockets and a GraphQL server that automatically generates schemas based on application data models. It also features an adapter-based storage layer that abstracts interactions with various cloud and local backends. The pla

Afero is a Go library that provides a unified filesystem abstraction, allowing applications to interact with local disk, in-memory storage, cloud services, archives, and remote systems through a single, consistent interface. At its core, it defines a standard interface that all filesystem backends implement, enabling developers to swap storage implementations without changing application code. The library distinguishes itself through its composable architecture, which includes layered filesystem composition for creating cached, sandboxed, or restricted storage views. It offers a copy-on-write

Incus is a unified orchestration platform for managing system containers, OCI application containers, and virtual machines through a single control plane. It brings together cluster infrastructure management, secure multi-tenancy, software-defined networking, and pluggable storage backend orchestration into one cohesive system exposed via a full REST API and command-line interface. What distinguishes Incus is its ability to run multiple instance types side by side—full Linux system containers, OCI application containers, and QEMU virtual machines—all managed with consistent tooling. Networkin

elFinder is a JavaScript-based web file manager that provides a browser interface for organizing and manipulating files and folders on remote servers. It functions as a backend-agnostic storage interface, utilizing a common API and a JSON-based protocol to translate browser requests into various server-side language commands. The system decouples the front end from physical storage through a multi-backend interface and volume-driver abstraction. This allows the file explorer to connect to different server-side languages and storage volume drivers to manage data across diverse environments. T

Flipper is a runtime feature toggle system and library for Ruby applications. It enables the management of application features by toggling functionality on or off without the need to deploy new code. The system provides a mechanism for controlling code execution through boolean states, actor-based access, and percentage-based traffic rollouts. It includes a management interface for modifying flag states in real-time and a central registry for tracking available capabilities. The project covers a broad range of operational capabilities, including environment-specific flag isolation, configur

Mooncake is a disaggregated large language model serving platform and distributed key-value store designed for high-performance inference infrastructure. It functions as a GPU memory orchestrator and KV cache management system that pools and transfers key-value caches across clusters to accelerate inference. The system distinguishes itself by separating the prefill and decode phases of inference into distinct hardware clusters to optimize resource utilization. It utilizes a high-performance RDMA distributed cache with zero-copy transfers to move data between compute nodes, bypassing the CPU t

This project is a collection of reference implementations and practical guides for building enterprise Java applications using the Spring Boot framework. It serves as a backend project gallery and implementation guide, providing a set of architectures for common server patterns. The repository distinguishes itself through a focus on distributed system design, offering examples for global unique identifier generation, distributed caching, and full-text search. It also includes templates and examples for creating custom Spring Boot starters to encapsulate shared dependencies and configurations

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

KeyDB is a multithreaded in-memory key-value store and distributed cache. It functions as a NoSQL database utilizing multi-version concurrency control to execute non-blocking queries and scans. The project is a multithreaded fork of Redis that maintains protocol compatibility while utilizing a multithreaded architecture to scale across multi-core hardware. It distinguishes itself with flash-tiered storage, allowing the system to offload data from primary RAM to SSD or flash storage to increase total capacity. The system supports high availability through active-active mesh replication and mu

ZeroByte is a backup management platform built around the Restic backup engine, providing encrypted, deduplicated, and compressed snapshots across multiple storage backends. It offers a web interface for scheduling, monitoring, and managing backup operations, with support for cron-based job scheduling and configurable retention policies that automatically prune older snapshots. The platform distinguishes itself through comprehensive multi-protocol volume mounting, allowing backup ingestion from NFS, SMB, WebDAV, SFTP, and rclone-backed sources alongside local directories. It includes a snapsh

AndroidProject is an application framework and development suite for Android that provides a collection of base classes and utilities designed to accelerate the creation and refactoring of mobile projects. It functions as a foundational system for managing application architecture and common shared features. The framework includes a specialized activity result manager that replaces manual callback overrides with listener objects and automated request code generation. It also provides a performance optimization library focused on reducing memory usage and code size to improve application stabi

Cinder is a high-performance Python runtime implementation based on CPython. It is designed as an execution environment optimized for large-scale distributed systems and cloud environments. The project integrates a distributed memory cache and an asynchronous memory layer to manage data across multiple network nodes. It also provides a native C extension framework for developing high-performance compiled modules that link directly into the interpreter memory space. The system covers capabilities for asynchronous data retrieval, large-scale execution, and the integration of embedded scripting

Ignite is a distributed in-memory data grid and compute platform. It functions as a distributed SQL database and storage engine designed to store and process large datasets in RAM to minimize latency and increase calculation speed. The system is distinguished by a multi-tier storage engine that manages data placement across memory and disk to balance high-speed access with large capacity. It features a distributed compute grid that executes custom logic directly on the nodes where data resides to reduce network traffic. The platform provides a broad set of capabilities including ACID transac

HowToBeAProgrammer is a comprehensive software engineering career guide and professional development framework. It serves as a curated-knowledge repository and handbook designed to help programmers acquire technical habits and social competencies necessary for professional advancement. The project distinguishes itself by integrating technical craftsmanship with a detailed manual for technical leadership and organizational navigation. It provides specific strategies for career progression, such as compensation negotiation, promotion readiness, and the management of professional boundaries to p

Athens is a Go module proxy server and dependency cache that provides a persistent storage system for Go dependencies. It acts as a mirror and datastore to ensure reproducible build environments by storing immutable copies of external packages, protecting against upstream deletions or outages. The project distinguishes itself by serving as a secure gateway for private Go module hosting, utilizing authentication tokens, SSH keys, and GitHub Apps to retrieve dependencies from private version control systems. It further enables software dependency compliance through request filtering and checksu