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

http-cache

An HTTP caching middleware

foyer

Hybrid cache for Rust

stretto

high performance thread-safe memory-bound Rust cache

concread

Concurrently Readable Data-Structures for Rust

get-size

Determine the size in bytes an object occupies inside RAM

mini-moka

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

quick_cache

Lightweight and high performance concurrent cache

intaglio

UTF-8 string and byte string interner and symbol table

schnellru

A fast and flexible LRU map

tame-index

access to local and remote cargo registry indices

memoize

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

deja

command line utility to cache output of commands

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

infinitree

Embedded, encrypted database with tiered cache

once_map

Single assignment and lazy maps

lru-cache

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

assets_manager

Conveniently load, cache, and reload external resources

bkt

CLI and Rust library for caching subprocess invocations

twilight-cache-inmemory

In-process-memory based cache for the Twilight ecosystem

comemo

Incremental computation through constrained memoization

dotslash

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

hashlru

LRU cache

cachedir

help interacting with cache directories and CACHEDIR.TAG files

associative-cache

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

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

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

sieve-cache

SIEVE cache replacement policy

lease

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

kash

Function and method cache and memoization

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

foyer-memory

memory cache for foyer - Hybrid cache for Rust

dragonfly-api

Canonical location of the Dragonfly API definition

glyph_brush_draw_cache

Texture draw cache for ab_glyph

pi_assets

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

esri_ascii_grid

reading ESRI Ascii Grid .asc files

aws_secretsmanager_caching

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

fast_pool

The Fast Pool based on channel

dynamic-loader-cache

Reader of the dynamic loader shared libraries cache

debuginfod

interacting with debuginfod servers

version-track

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

momento

Client SDK for Momento services

br-plugin

Plugin

core-to-core-latency-plus

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

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

refreshable

wrapper around a value that changes over time

local_lru

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

strpool

String Pools / Strings Interning

lfu_cache

constant time LFU cache implementation

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

static-id

A memory-efficient library for handling interned identifiers

TinyUFO

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

mtime-travel

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

memcached

async memcached rust client

cache_control

parse the HTTP Cache-Control header

memo-cache

A small, fixed-size cache with retention management

re_query

High-level query APIs

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

pokerust

Pokeapi wrapper

generational-cache

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

michie

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

hashring

A minimal implementation of consistent hashing

get-size2

Determine the size in bytes an object occupies inside RAM

hashconsing

A hash consing library

deduplicate

caching, asynchronous, request deduplication

foyer-intrusive

intrusive data structures for foyer - Hybrid cache for Rust

rom_cache

cache ROM in memory like CPU caching RAM

opentalk-cache

OpenTalk caching of redis data in local memory

fastcache

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

scoped_threadpool

scoped and cached threadpools

ttl_cache_with_purging

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

binary-install

Install a binary from a path to a global cache

cacheapp

Cache inspired by Laravel's cache remember forever

lightspeed_cache

LightSpeed

s3-fifo

An efficient S3-FIFO Cache Implementation

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…

unowned-buf

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

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

pi_cache

LFU-LRU cache

accumulo-access

Rust API for parsing and evaluating Accumulo Access Expressions

lazy-lru

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

ustr-fxhash

Fast, FFI-friendly string interning

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

stateflow

extensible state machine implementation in Rust

tiny_lfu

cache admission control policy

interned

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

low_latency_log

Fast and Low Latency Logging Library for Rust

kesh

Cache library

threadsafe-lru

Thread-safe LRU

ttl_cache

A cache that will expire values after a TTL

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

retained

Retain local variables between function calls

repr-rs

representation invariants with caching and parallelism support

lazy_catch

catch result and lazy compute

arc-cache

An Adaptative Replacement Cache for Rust

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

const-lru

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

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

lazier_static

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

array_pool

tiered caching array pool implementation in Rust

txfs

A cached transactional filesystem layer over tokio::fs

cachedhash

Wrapper for values that caches their hash

parquet-lru

Implement LRU cache reader for parquet::arrow::async_reader::AsyncFileReader

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

bytecon_data_store

storing ByteConverter implementations conveniently

tunnelbana-etags

Generate etags for static files and serve them with tower

http-cache-quickcache

http-cache manager implementation for quick-cache

dashmap-cache

dashmap wrapper to cache results from arbitrary functions and methods

pierce

Avoid double indirection in nested smart pointers

sparkv

Expirable in-memory key-value store

cached_fn

Cache a function's result in a map

pingora-lru

LRU cache that focuses on memory efficiency, concurrency and persistence

anor

Anor In-Memory Data Storage

quickfetch_traits

Traits for quickfetch

yukina

YUKI-based Next-generation Async-cache

bader-db

Key-value cache RESP server with support for key expirations

tlru_cache

Time-Aware LRU Cache

vmi-utils

VMI

kvarn-search

Search engine extension for Kvarn

uiuifree-crawl-cache

Crawl Cache

tinylfu-cached

High performance, LFU based in-memory cache

cache_2q

A 2Q Cache which maps keys to values

multicache

An LRU cache where each object has a given weight

tote

A lightweight data cache for CLI libraries

scryers

alternative to Scryfall with caching and mass image downloading capabilities

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.

interned-string

High-performance and concurrent string interning for general purpose use

foyer-storage

storage engine for foyer - Hybrid cache for Rust

clockpro-cache

CLOCK-Pro cache replacement policy

csv-partial-cache

Csv index with partially cached columns

memcached-rs

A MemCached Library in Rust

minne

Fast and thread-safe cache for Rust

how-install-tealdeer

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

cascara

TinyLFU cache

idx-rs

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

mouscache

store object either in redis or in memory

common_lib_for_router_center_api

A commun lib for the router center api

cachedb

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

supernova

platform client

tmfalloc

Transactional memory-mapped file allocator

light-cache

Async focused caching library

core-to-core-latency

Measures CPU core-to-core latency

cache_bust

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

aoc-cache

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

pond

scoped and cached threadpools that keep a state

memoizer

function memoization struct

cachers

A caching library

hsa

Heterogeneous System Architecture(HSA) bindings for Rust

topo

Tools for incrementally computing repeated callgraphs

r-cache

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

segcache

Pelikan segment-structured cache

infinitree-backends

Embedded, encrypted database with tiered cache -- backends

cached_proc_macro_types

Generic cache implementations and simplified function memoization

lru-cache-map

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

hitbox

Asynchronous caching framework in Rust

ref-stable-lru

An LRU Cache implementation with compile-time reference stability

cron-exp

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

transient-hashmap

HashMap with transient entries

ballista-cache

Ballista Cache

async_user_lookup

lookup user and groups on Unix/Linux. NOTE: This has been renamed to user_lookup to allow for both sync and async versions

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

memory-lru

A memory-based wrapper around the lru crate

aws-secretsmanager-cache

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

rattler-server

A server to solve conda environments with rattler

mutate_once

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

cacache

Content-addressable, key-value, high-performance, on-disk 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

simple-symbol

Convenient, basic String interning

hazptr

hazard pointer based concurrent memory reclamation

cornerstore

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

wimc

Wizards in Memory Cache

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

rsmc-tokio

An async memcached client for Tokio

unifont-bitmap

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

pingora-memory-cache

An async in-memory cache with cache stampede protection

http-cache-mokadeser

http-cache manager implementation for moka stored deserialized

karsher

dumb cache written in rust

waitcache

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

cache_browns

A general-purpose programmable, declarative cache

ggez-assets_manager

assets_manager integration for ggez

re_query_cache

Caching datastructures for re_query

cache-agilor

agilor cache

simple-cache

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

steam-webapi-rust-sdk

Set of utility functions to access Steam Web API

cache_flow

Cache last result

ded

Dead Easy Deduplication

mangadex-home

A MangaDex@Home implementation in Rust

lazy_list

Lazily-populated lists, finite or infinite

vcdiff-common

Common structs, functions, and traits for vcdiff format

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

profilr-db

in memory profiling database

lfan

Generic Caching Library

crude_cache

good enough concurrent caching needs

aruna-cache

cache resources for AOS

ps-rclru

Rc-based LRU cache

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

anor-storage

Anor In-Memory Data Storage

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

cashe

Command line utility for caching and recalling output

rubin

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

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

aba-cache

In-process in-memory cache library

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

enstate

eternity

limit requests and cache results

texture-cache

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

mcpat

The package provides an interface to McPAT

cached_field

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

smallgraph

A small graph based on smallvec

cuckoocache

High performance concurrent cache

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

yamemcache

memcached client library

bustdir

Read a directory and generate cache-busting hashes for it

ieee-registry

cache the IEEE public registries as csv

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

fn-memo

creating the memoization of a function

libcachebust

Compiletime cache-busting web applications written in rust

reloadable-core

A generic reloadable state management core traits

ritecache

RiteCache. A smart cache that knows your data.

rust-actions-cache-api

GitHub Actions Cache API client for actions written in Rust

closure_cacher

Allows caching of user specified closure

ascend

Make static strs from any string

cacheflush-sys

Exposes GCC’s __builtin___clear_cache as a function

simple-interner

append-only interner

easycache

cache system

memselect

No-std compatible memoizing selectors

ccache

Composable Caches

generational-lru

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

random_eviction_cache

A random eviction cache implementation

mincache

Minimal function return caching crate

gwd-backend-firefox

Firefox backend for Godwit-Daemon

libblobd

blobd

reiterate

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

mmap-cache

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

rmw_ttlmap

Minimal async cache in Rust with support for key expirations

rearch-effects

Re-imagined approach to application design and architecture

handle-key

Typed and named or unnamed map keys

plru

concurrent (lockless) pseudo-LRU cache replacement policy

extra_waiters

Wait for notifications without a Mutex

pi_lru

LRU cache

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

razel

a command executor with caching for data processing pipelines

zenkit

client library in Rust

stream-download

streaming content to a local file-backed cache

proxy-map

proxy server that caches responses in memory

flinch

in-memory database

red_memo

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

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

nsqueue

Rust client for the NSQ realtime message processing system

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

kalgan_cache

A wrapper for redis crate used by Kalgan Framework

sloth

generic wrapper struct for lazy initialization

shared_lru

Have multiple caches with heterogenous tracking of recency

cachingmap

A caching Hashmap accepting new entries through interior-mutability

lewp-selectors

CSS Selectors matching for Rust - version used by lewp

dataloader

Facebook's DataLoader using async-await

refcount-interner

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

get-size-derive

Derives the GetSize trait

genmesh

A package for generating 3D meshes

js-intern

A macro for interning JavaScript primitives

bhatho

LRU Caching library with persistent layer using RocksDB

rep-str

caching a repeat pattern of a str

matecito

Concurrent LRU Cache (experimental)

init-once

Concurrent, non-blocking lazy initialization of values

murmurhash

MurmurHash3 implementation in Rust

arc-disk-cache

Concurrently Readable Disk Cache

cart-cache

CART cache replacement policy

mem_cache

memory cache

bloom-server

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

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

dyn-cache

Query cache indexed by type

fnct

caching library that supports cache invalidation via tags

diwata_intel

Contains algorithmns and heuristics to interpret data

renege

Tracking cache validity using fast concurrent invalidation propogation

core_memo

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

poolcache

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

expression_engine

An expression engine written in pure rust

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

fliplru

A LRU cache that shows effectiveness of cache capacity

memcrab-server

datatier

abstractions for byte storage pools

file-lfu

A least-frequently-used cache layered on a directory

nginx-cache-purge

An alternative way to do proxy_cache_purge or fastcgi_cache_purge for Nginx

ogawa-rs

Ogawa Alembic Cache file parser

nvd_cve

Search for CVEs against a local cached copy of NIST National Vulnerability Database (NVD)

endorphin

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

foyer-common

common components for foyer - Hybrid cache for Rust

deposit

Distributed in-process caching with pluggable replacement policies

asset_lru

A two-level cache for objects which are bigger in memory than on disk

cache_loader_async

A thread safe loading cache with async loader functions based on tokio

remember-this

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

cacher_hasher

Demo cacher

ultra-batch

Tokio-based library to batch and cache database queries or other data lookups

symbolic-symcache

An optimized cache file for fast and memory efficient lookup of symbols and stack frames in debugging information

quick-hash-cache

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

memoize-inner

Helper crate for memoize

rocket-static-files

Serve static files with cache headers with Rocket

async_cache

Async refresh cache

rubin-cli

CLI for the Rubin lib

line-col

Convert string slice indices into line/column numbers