Lib.rs

lru

cache implementation

cached

Generic cache implementations and simplified function memoization

moka

A fast and concurrent cache library inspired by Java Caffeine

string_cache

A string interning library for Rust, developed as part of the Servo project

ustr

Fast, FFI-friendly string interning

clru

An LRU cache implementation with constant time operations and weighted semantic

http-cache-semantics

RFC 7234. Parses HTTP headers to correctly compute cacheability of responses, even in complex cases

internment

Easy interning of data

mini-moka

A lighter edition of Moka, a fast and concurrent cache library

stretto

high performance thread-safe memory-bound Rust cache

concread

Concurrently Readable Data-Structures for Rust

foyer

Hybrid cache for Rust

get-size

Determine the size in bytes an object occupies inside RAM

http-cache

An HTTP caching middleware

deja

command line utility to cache output of commands

intaglio

UTF-8 string and byte string interner and symbol table

quick_cache

Lightweight and high performance concurrent cache

memoize

Attribute macro for auto-memoizing functions with somewhat-simple signatures

schnellru

A fast and flexible LRU map

tame-index

access to local and remote cargo registry indices

rustcbuildx

$RUSTC_WRAPPER tool to sandbox cargo builds and execute jobs remotely

jupiter

providing high-throughput ultra low latency services via the RESP protocol as defined by Redis

assets_manager

Conveniently load, cache, and reload external resources

once_map

Single assignment and lazy maps

infinitree

Embedded, encrypted database with tiered cache

bkt

CLI and Rust library for caching subprocess invocations

comemo

Incremental computation through constrained memoization

lru-cache

A cache that holds a limited number of key-value pairs

twilight-cache-inmemory

In-process-memory based cache for the Twilight ecosystem

cachedir

help interacting with cache directories and CACHEDIR.TAG files

dotslash

Command-line tool to facilitate fetching an executable, caching it, and then running it

hashlru

LRU cache

redhac

Embedded Distributed HA Cache

cache-advisor

scan-resistant concurrent cache eviction manager

lru_time_cache

Least Recently Used caching algorithm in a container which may be limited by size or time, ordered by most recently seen

foyer-intrusive

intrusive data structures for foyer - Hybrid cache for Rust

globalcache

Cache utility that allows per-process managent of many cache instances

cargo-green

Cargo plugin and $RUSTC_WRAPPER to sandbox & cache cargo builds and execute jobs remotely

moka2

hitdns fork of A fast and concurrent cache library inspired by Java Caffeine

mtop

top for Memcached

fn-cache

A copy-less and clone-less function caching library

refreshable

wrapper around a value that changes over time

sieve-cache

SIEVE cache replacement policy

kash

Function and method cache and memoization

lease

Object pool that leases values and automatically returns them with async support

associative-cache

A generic N-way associative cache with fixed-size capacity and random or least recently used (LRU) replacement

dragonfly-api

Canonical location of the Dragonfly API definition

momento

Client SDK for Momento services

version-track

used to track changes to complex data, when direct comparison or hashing is too expensive

aws_secretsmanager_caching

The AWS Secrets Manager Rust caching client enables in-process caching of secrets for Rust applications

pokerust

Pokeapi wrapper

dynamic-loader-cache

Reader of the dynamic loader shared libraries cache

fortifynet_proxy

FortifyNet Proxy is a lightweight Rust proxy server designed to provide secure and efficient handling of HTTP requests with basic authentication and resource caching capabilities

br-plugin

Plugin

core-to-core-latency-plus

This program is used to calculate the communication latency between CPU cores

debuginfod

interacting with debuginfod servers

coitrees

A very fast data structure for overlap queries on sets of intervals

freqfs

An in-memory filesystem cache layer over tokio::fs, with LFU eviction

esri_ascii_grid

reading ESRI Ascii Grid .asc files

local_lru

thread-safe and lock-free LRU cache based on thread local storage

strpool

String Pools / Strings Interning

mtime-travel

A small tool to save and restore the mtime attribute for files

sine_cache

SineCache is a high-performance, in-memory caching library for Rust, designed to efficiently store and manage key-value pairs with support for various eviction policies

lfu_cache

constant time LFU cache implementation

static-id

A memory-efficient library for handling interned identifiers

pi_cache

LFU-LRU cache

TinyUFO

In-memory cache implementation with TinyLFU as the admission policy and S3-FIFO as the eviction policy

memcached

async memcached rust client

cache_control

parse the HTTP Cache-Control header

re_query

High-level query APIs

pi_assets

assets manager, async load assets, The capacity of multiple managers is managed uniformly

memo-cache

A small, fixed-size cache with retention management

michie

An attribute macro that adds memoization to a function (sounds like Mickey)

famcache

Official Famcache server client

reinda

Easily embed and manage your assets for your web application to build standalone-executables. Offers filename hashing, templating, compression and more.

lrumap

A safe Least Recently Used (LRU) cache implementation with ordered and unordered support

hashconsing

A hash consing library

generational-cache

Generational Arena based cache impls. in 100% safe, [no_std] compatible Rust.

hashring

A minimal implementation of consistent hashing

get-size2

Determine the size in bytes an object occupies inside RAM

deduplicate

caching, asynchronous, request deduplication

rom_cache

cache ROM in memory like CPU caching RAM

binary-install

Install a binary from a path to a global cache

cacheapp

Cache inspired by Laravel's cache remember forever

opentalk-cache

OpenTalk caching of redis data in local memory

tomt_atom

Basic Atom (string) registry for use with ID strings. For when an application contains and passes around many constant strings (mainly de/serialized strings), this should reduce the…

retainer

Minimal async cache in Rust with support for key expirations

mapage

In-memory type-namespaced key value storage with GraphQL

daab

DAG aware artifact builder

shale

Useful abstraction and light-weight implemenation for a key-value store

threadsafe-lru

Thread-safe LRU

accumulo-access

Rust API for parsing and evaluating Accumulo Access Expressions

interned

generic Interned<T> which can intern practically any type including &str, slices, and primitives, plus memoization via Memoized<I, T>

ttl_cache_with_purging

A time-to-live (TTL) cache implementation with optional background purging for expired entries

fastcache

A performant but not-so-accurate time and capacity based cache for Rust

lazy-lru

A least-recently-used (LRU) cache implementation with lazy eviction

s3-fifo

An efficient S3-FIFO Cache Implementation

foyer-memory

memory cache for foyer - Hybrid cache for Rust

ttl_cache

A cache that will expire values after a TTL

salrucc

Sourced Asynchronous Least Recently Used Cache Control

hash_on_write

A wrapper for storing hash results to avoid running costly hash functions multiple times without modifying the value

inner-mem-cache

appliction inner memory cache

ocsp-server

OCSP server, listening for requests to give responses

scoped_threadpool

scoped and cached threadpools

stateflow

extensible state machine implementation in Rust

clockpro-cache

CLOCK-Pro cache replacement policy

tiny_lfu

cache admission control policy

unowned-buf

Buffered Read+BufRead and Write for Rust that does not own the underlying Read/Write

low_latency_log

Fast and Low Latency Logging Library for Rust

kesh

Cache library

wtinylfu

W-TinyLFU cache

zcache

in-memory Rust cache with time-based expiration

stylo_selectors

Temporary fork of the selectors crate for Stylo

incremental-query

incremental compilation algorithm similar to rustc's

ustr-fxhash

Fast, FFI-friendly string interning

cachedhash

Wrapper for values that caches their hash

fclicache

command-line utility that caches the output of resource-intensive commands, enabling faster retrieval of results when the same commands are executed repeatedly within a specified Time-to-Live (TTL) period

prehash

storing values with precomputed hashes

warmy

Hot-reloading loadable and reloadable resources

aws-parameters-and-secrets-lambda

Cache AWS Secrets Manager secrets in your AWS Lambda function

anycache

cache with expensive generator function

regex-cache

Lazy and cached regular expressions

ti

terminal timer

retained

Retain local variables between function calls

array_pool

tiered caching array pool implementation in Rust

const-lru

no_std, non-hashing, constant-capacity, constant-memory-usage LRU cache

lazier_static

A thin wrapper around std::sync::OnceLock providing cached, static, lazy initialization

txfs

A cached transactional filesystem layer over tokio::fs

clear-cache

A native implementation of __builtin___clear_cache without dependency of GCC/Clang

remote_config

Flexible crate for asynchronously loading configuration from remote source with caching and automatic revalidation

dashmap-cache

dashmap wrapper to cache results from arbitrary functions and methods

pierce

Avoid double indirection in nested smart pointers

bader-db

Key-value cache RESP server with support for key expirations

pingora-lru

LRU cache that focuses on memory efficiency, concurrency and persistence

sparkv

Expirable in-memory key-value store

quickfetch_traits

Traits for quickfetch

cached_fn

Cache a function's result in a map

anor

Anor In-Memory Data Storage

kvarn-search

Search engine extension for Kvarn

yukina

YUKI-based Next-generation Async-cache

tlru_cache

Time-Aware LRU Cache

lightspeed_cache

LightSpeed

uiuifree-crawl-cache

Crawl Cache

cache_2q

A 2Q Cache which maps keys to values

scryers

alternative to Scryfall with caching and mass image downloading capabilities

tote

A lightweight data cache for CLI libraries

minne

Fast and thread-safe cache for Rust

groupcache

distributed caching and cache-filling library, intended as a replacement for a pool of memcached nodes in many cases. It shards by key to select which peer is responsible for that key.

tinylfu-cached

High performance, LFU based in-memory cache

cascara

TinyLFU cache

foyer-storage

storage engine for foyer - Hybrid cache for Rust

arc-cache

An Adaptative Replacement Cache for Rust

csv-partial-cache

Csv index with partially cached columns

memcached-rs

A MemCached Library in Rust

multicache

An LRU cache where each object has a given weight

common_lib_for_router_center_api

A commun lib for the router center api

vmi-utils

VMI

how-install-tealdeer

Fetch and show tldr help pages for many CLI commands. Full featured offline client with caching support.

light-cache

Async focused caching library

idx-rs

A fast and efficient library for working with IDX-formatted RuneScape caches

r-cache

in memory key value store. It is thread safe and values have expiry times

pond

scoped and cached threadpools that keep a state

cache_bust

compile-time "cache busting", including hashes in file names in order to optimize for caching

mouscache

store object either in redis or in memory

aoc-cache

A way of caching your input from the great and popular Advent of Code

segcache

Pelikan segment-structured cache

tmfalloc

Transactional memory-mapped file allocator

core-to-core-latency

Measures CPU core-to-core latency

memoizer

function memoization struct

supernova

platform client

hsa

Heterogeneous System Architecture(HSA) bindings for Rust

cachedb

In memory Key/Value store that stores RwLock<Value> which expire in LRU order when unused

topo

Tools for incrementally computing repeated callgraphs

lru-cache-map

A cache that holds a limited number of key-value pairs

transient-hashmap

HashMap with transient entries

cachers

A caching library

http-cache-quickcache

http-cache manager implementation for quick-cache

cached_proc_macro_types

Generic cache implementations and simplified function memoization

hitbox

Asynchronous caching framework in Rust

fast_pool

The Fast Pool based on channel

cron-exp

A CRON expression parser and explorer designed for space efficiency for caching and storage purposes such as in a CRON Scheduler

ballista-cache

Ballista Cache

re_query_cache

Caching datastructures for re_query

simple-symbol

Convenient, basic String interning

megenginelite-rs

A safe megenginelite wrapper in Rust

hsa-rt

Rust wrapper for HSA. Part of the Geobacter project.

string_cache_shared

Code share between string_cache and string_cache_codegen

xfetch

Optimal probabilistic cache refresh algorithm

compose-rt

A positional memoization runtime similar to Jetpack Compose Runtime

cache_flow

Cache last result

ref-stable-lru

An LRU Cache implementation with compile-time reference stability

aws-secretsmanager-cache

A client for in-process caching of secrets from AWS Secrets manager

memory-lru

A memory-based wrapper around the lru crate

rattler-server

A server to solve conda environments with rattler

cacache

Content-addressable, key-value, high-performance, on-disk cache

mutate_once

Interior mutability, write-once and borrowable as plain &T

wimc

Wizards in Memory Cache

dynamic-lru-cache

LRU Cache that only stores items recently seen more than once

py-spy-for-datakit

py-spy fork for sending data to datakit

hazptr

hazard pointer based concurrent memory reclamation

cornerstore

An in-memory key/value store for read-heavy workloads with expireable items

memory-cache-rust

memory-cache is a fast, concurrent cache library built with a focus on performance and correctness. The motivation to build Ristretto comes from the need for a contention-free cache in

cacache-sync

Synchronous, content-addressable, key-value, high-performance, on-disk cache

yoke-derive

Custom derive for the yoke crate

cache-compute

implements request/async computation coalescing

waitcache

An ever-growing concurrent hash map with key-level locking granularity

rsmc-tokio

An async memcached client for Tokio

unifont-bitmap

Get bitmap data for GNU Unifont. Embedded in compressed form, light on memory.

karsher

dumb cache written in rust

pingora-memory-cache

An async in-memory cache with cache stampede protection

cache_browns

A general-purpose programmable, declarative cache

vcdiff-common

Common structs, functions, and traits for vcdiff format

ggez-assets_manager

assets_manager integration for ggez

steam-webapi-rust-sdk

Set of utility functions to access Steam Web API

cache-agilor

agilor cache

simple-cache

A basic and simple Rust library async/await ready caching implementation for structures

ded

Dead Easy Deduplication

mangadex-home

A MangaDex@Home implementation in Rust

generic-static-cache

Generic static storage in generic functions

cacher_rs

memory cache

memoiter

Memoization of Iterators, so that their past results can be indexed

hwloc2

Rust bindings for the hwloc hardware locality library 2.x

persistentcache

Macros for persistently caching function calls using files or Redis

lfan

Generic Caching Library

crude_cache

good enough concurrent caching needs

bustdir

Read a directory and generate cache-busting hashes for it

aruna-cache

cache resources for AOS

ps-rclru

Rc-based LRU cache

fn-memo

creating the memoization of a function

simple-async-cache-rs

A fast asynchronous caching crate with expiration delay and custom types

ephemeropt

An ephemeral Option that reverts to None after some time

rive-cache-inmemory

In-memory cache for Rive

bb8-memcached

async connection pool for memcached, based on bb8 and memcache-async

kstd

A kernel standard library for the martimos kernel

odilia-cache

A caching layer for the Odilia screen reader

simple-interner

append-only interner

lazy_list

Lazily-populated lists, finite or infinite

cashe

Command line utility for caching and recalling output

rubin

In-memory key-value store with the option for persistence

cached_field

Proc macro to cache associate function result on strut field. An analogy to python's @cached_property class decorator.

anor-storage

Anor In-Memory Data Storage

fbr_cache

A cache with frequency-based replacement strategy

envcache

A build.rs helper crate for caching environment variables

cyfs-bdt

package

fast-lru

A fast, 100% safe, stack based LRU cache

cache_bust_cli

CLI tool for use in conjunction with the cache_bust crate to add hashes to file names

diem-workspace-hack

Diem workspace hack

dns_in_a_weekend

A toy implementation of a DNS server that implements caching

eternity

limit requests and cache results

texture-cache

A LRU texture cache for caching many small textures in a single big GPU texture

ieee-registry

cache the IEEE public registries as csv

yamemcache

memcached client library

mcpat

The package provides an interface to McPAT

smallgraph

A small graph based on smallvec

enstate

cuckoocache

High performance concurrent cache

profilr-db

in memory profiling database

crates-io-proxy

Caching HTTP proxy server for the crates.io registry

icacher

A minimal crate for caching functions

cachewell

LruCache with pinning and detachment support

versioned

pointer-like wrapper for counting mutations

freqache

A thread-safe LFU cache with iterator

rngcache

A cache so your RNG is faster

Caching

A Caching libary

cachr

shared access caching struct

cache_service

Cache service based on Redis and in-memory cache

libcachebust

Compiletime cache-busting web applications written in rust

ascend

Make static strs from any string

reloadable-core

A generic reloadable state management core traits

ritecache

RiteCache. A smart cache that knows your data.

http-cache-mokadeser

http-cache manager implementation for moka stored deserialized

cachingmap

A caching Hashmap accepting new entries through interior-mutability

rust-actions-cache-api

GitHub Actions Cache API client for actions written in Rust

closure_cacher

Allows caching of user specified closure

random_eviction_cache

A random eviction cache implementation

cacheflush-sys

Exposes GCC’s __builtin___clear_cache as a function

easycache

cache system

aba-cache

In-process in-memory cache library

memselect

No-std compatible memoizing selectors

ccache

Composable Caches

generational-lru

A generational arena based LRU Cache implementation in 100% safe rust

mincache

Minimal function return caching crate

gwd-backend-firefox

Firefox backend for Godwit-Daemon

rearch

Re-imagined approach to application design and architecture

mmap-cache

A low-level, read-only, memory-mapped cache

handle-key

Typed and named or unnamed map keys

plru

concurrent (lockless) pseudo-LRU cache replacement policy

quick-hash-cache

Async Concurrent Hashmap. Unlike Redis it supports multi threading and advanced data structures

extra_waiters

Wait for notifications without a Mutex

memcrab-cache

izihawa_lru_time_cache

Least Recently Used caching algorithm in a container which may be limited by size or time, ordered by most recently seen

depacked

Minimalistic Rust Crate for handling memory packed data to aid CPU caching

lru_map

LRU cache map

nsqueue

Rust client for the NSQ realtime message processing system

cacher_hasher

Demo cacher

zenkit

client library in Rust

proxy-map

proxy server that caches responses in memory

flinch

in-memory database

rmw_ttlmap

Minimal async cache in Rust with support for key expirations

sloth

generic wrapper struct for lazy initialization

foyer-common

common components for foyer - Hybrid cache for Rust

red_memo

safe, single-threaded, pure rust library for memoization and dynamic programming

elfmalloc

A fast, concurrent, general-purpose allocator

stream-download

streaming content to a local file-backed cache

razel

a command executor with caching for data processing pipelines

refcount-interner

reference-counted interning library for strings, slices, and other data

emissary

Stateful caching and serialization framework in 100 lines or less!

expiring_map

A map whose entries expire after a configured time to live

rsmc-core

runtime-agnostic async memcached clients

actix-sled-cache

A caching system built on top of Sled and Actix

iterator-cache

Evaluate and cache iterator values now for future use

weak-list2

Doubly linked, heterogeneous, list of Arc-like nodes that can be used to implement a least recently used cache

js-intern

A macro for interning JavaScript primitives

shared_lru

Have multiple caches with heterogenous tracking of recency

core_memo

Zero-cost, no_std-compatible library for lazy evaluation and memoization

lewp-selectors

CSS Selectors matching for Rust - version used by lewp

dataloader

Facebook's DataLoader using async-await

get-size-derive

Derives the GetSize trait

genmesh

A package for generating 3D meshes

bhatho

LRU Caching library with persistent layer using RocksDB

endorphin

Key-Value based in-memory cache library which supports Custom Expiration Policies

kalgan_cache

A wrapper for redis crate used by Kalgan Framework

rep-str

caching a repeat pattern of a str

matecito

Concurrent LRU Cache (experimental)

arc-disk-cache

Concurrently Readable Disk Cache

reiterate

Iterator adaptor with caching that allows reiterating over the same iterator through the cache

cart-cache

CART cache replacement policy

bloom-server

HTTP REST API caching middleware, to be used between load balancers and REST API workers

libblobd

blobd

mem_cache

memory cache

remember-this

mechanism for caching data to both memory and disk. Uses tokio.

osmnodecache

Flat file OSM node cache to store (latitude,longitude) pairs as indexed entries

pybites-search

A command-line search tool for Pybites content

wimcm

Wizards in Memory Cache Models

data_downloader

way to download and cache files

murmurhash

MurmurHash3 implementation in Rust

fnct

caching library that supports cache invalidation via tags

diwata_intel

Contains algorithmns and heuristics to interpret data

init-once

Concurrent, non-blocking lazy initialization of values

expression_engine

An expression engine written in pure rust

renege

Tracking cache validity using fast concurrent invalidation propogation

poolcache

A hybrid object pool and LFU cache that permits cached object reuse. Useful for avoiding allocations

memcrab-server

rs-complete

that handles text/word completion

cursive-cached-text-view

Cursive's TextView that caches the rows

thunky

Delay the evaluation of a paramless async function and cache the result

calc-graph

Efficient calculations on a graph of values

reloadable-state

A generic reloadable shared state

memorize

Versatile and fast closure cacher with support for recursive algorithms

deposit

Distributed in-process caching with pluggable replacement policies