Lib.rs

gix-filter

gitoxide project implementing git filters

gix-index

A work-in-progress crate of the gitoxide project dedicated implementing the git index file

recloser

A concurrent circuit breaker implemented with ring buffers

afl

Fuzzing Rust code with american-fuzzy-lop

state

safe and effortless global and thread-local state management

nanocl

Container and virtual machine orchestrator

orpheum

CLI for applying Orpheum SDLC scenarios into project-local orchestration state

fmodel-rust

Accelerate development of compositional, safe, and ergonomic applications/information systems by effectively implementing Event Sourcing and CQRS patterns in Rust

mssf-com

Azure Service Fabric. The COM base layer.

aga8

GERG2008 equations of state

spades

Core 4-player Spades card-game state machine

dioxus-query

Fully-typed, async, reusable cached state management for Dioxus 🧬

atoman

static data that can be accessed safely and concurrently from any part of your program

atomic-progress

A high-performance, cloneable progress tracker with minimal locking overhead

nami

A powerful, lightweight reactive framework

dbuff

Double-buffered state with async command chains, streaming, and keyed task pools for ratatui applications

moduforge-state

不可变数据结构与事务系统基础

serdo

Serializable do/undo library

atomr-agents-state

Channelled state, reducers, and per-super-step checkpointing for atomr-agents

git-warp-time

CLI utility to reset file timestamps to repo state

ramistat

Middleware for web applications. Keeps app state in sync with URL, manages history, async orders, live data feeds.

mockforge-world-state

World State Engine - Unified visualization of all MockForge state systems

grabapl

graph-based programming languages, with pluggable type systems and a focus on visible intermediate states

moosicbox_session

MoosicBox Session Handling package

m1nd-ingest

Language ingest and graph extraction pipeline for m1nd

reifydb

A modern, real-time database with streaming and analytical capabilities

event-simulation

event based simulation of application state

pinget-core

Pure Rust Pinget core library that works directly with source caches, REST endpoints, and installed package state without COM

attuned-cli

CLI tool for Attuned development and testing

clasp-wasm

CLASP WebAssembly bindings

turul-mcp-server-state-storage

Server-global state storage for MCP entity registries (tools, resources, prompts) — pluggable backends for cross-instance coordination

promkit-widgets

Widgets for promkit

clasp-rules

Server-side rules engine for CLASP protocol

gtk_estate

A GTK and libadwaita state association library

altui

A state-driven TUI runtime built on top of altui-core

stategine

An application engine for handling function systems that run based on states and conditions

kotoba-state-graph

UI state management library for Kotoba using graph rewrite rules

zipcodes

Query US zipcodes without SQLite

duet

bi-directional synchronization

runner-core

Core helpers for Greentic runner: pack resolution, signing, session/state glue, and utilities

slop-ai

Rust SDK for the SLOP protocol — let AI observe and interact with your app's state

revolut

communicate with the Revolut API

interlock

Readers-writer locks designed for locking intervals

moloon

RFC-012: The Mirror/Time Layer. 12-Cycle Law, 128-bit state persistence, and autonomous system remodeling for the Aicent Stack 2026.

majordome

A modular state manager for Rust API and Services

qdk_sim_rs

Rust-based simulators for use with the Quantum Development Kit

zep-kvs

Elementary zero config cross platform key-value persistence library

flaga

Flag management engine with support for binary, hex, and enum flags, event triggering, and persistent flag schemas

freya-query

Fully-typed, async, reusable cached data management for Freya 🧬

naija-geo

Nigerian geopolitical zones, states and local government areas (LGAs) — all 6 zones, 37 states and 774 LGAs with navigation helpers

i2pd-launch

Launches i2pd with clean state

attuned-core

Core types and traits for Attuned - human state representation for LLM systems

attuned-infer

Fast, transparent inference of human state axes from natural language

naviz-state

State for NAViz

gpui-hooks

React-style hooks for GPUI framework

reifydb-wasi-bridge

WASI bridge for ReifyDB test suite

anathema-store

Various storage types for Anathema

microsoft-webui-state

Core state management for WebUI framework

process_alive

Cross platform library to verify if a process is alive

mero-auth

Forward Authentication Service for Calimero Network

timerfd

interface to the Linux kernel's timerfd API

fmemory

Memory library for the fiddlesticks agent harness framework

state-shift

Macros for implementing Type-State-Pattern on your structs and methods

measured-tokio

Tokio metrics for measured

reifydb-type

Core type system and value representations for ReifyDB

enum-update

representing state changes as enums

anathema-state

Anathema state and value types

qdk_sim_experimental

Experimental simulators for use with the Quantum Development Kit

atomic-state

static asynchronous data that can be accessed safely and concurrently from any part of your program

reifydb-routine

Built-in routines (functions and procedures) for ReifyDB

xiaoyong-value

Collection of sharing state primitives for async contexts (both Sync and !Sync)

actor12

A lightweight actor framework for Rust with async support

dioxus-tea

Dioxus - The Elm Architecture (TEA) Model

kazam-battle

Battle state tracking and domain types for Pokemon Showdown (experimental)

cardinal-varvara

Varvara Ordinator

tripswitch

Official Rust SDK for the Tripswitch circuit breaker service

infra-compass-cli

Command line application to manage and query NREL's INFRA-COMPASS data

reifydb-cdc

Change Data Capture module for ReifyDB

truce-rack-test

Assertion helpers for truce-rack host implementations (load, render, state, params)

reifydb-store-multi

Multi-version storage for OLTP operations with MVCC support

tibba-state

state for tibba

reifydb-client

Official Rust client library for ReifyDB

reos

ℜeos: A Rust Library for Equations Of State and Thermodynamics

reifydb-sqlite

Shared SQLite configuration types used by ReifyDB storage subsystems

reifydb-runtime

Runtime infrastructure for ReifyDB

oxur-odm

An odd document manager - CLI tool for managing design documentation

elara-state

ELARA Protocol - State field engine with CRDT reconciliation, divergence control, and partition tolerance

anathema-value-resolver

Anathema value resolver

reifydb-sub-column

Storage materialization subsystem for ReifyDB

nuts-storable

Traits for serializing and deserializing NUTS models and states in nuts-rs

anathema-widgets

Anathema widget base

sharedstate

Sync heavily read state across many servers

calimero-context-client

Core Calimero infrastructure and tools

bandit

Algorithms in Rust

pulith-state

Transaction-backed persistent state for Pulith resources

minisnap

Minimal snapshot store for durable state managers

tidepool-heap

Memory management and heap layout for Tidepool Core

reifydb-store-single

Single-version storage for OLTP operations without version history

mogi_statelearner

State learning algorithms for MOGI

reifydb-metric

Observability primitives for ReifyDB — counters, gauges, histograms, and query statement accumulators

rice-sdk

Rust sdk for interacting with Rice

tesser-journal

LMDB-backed persistence for Tesser

anathema-default-widgets

Default widget implementations for Anathema

attuned-http

HTTP reference server for Attuned

the-bus-telemetry

handling data exchange with the api (called telemetry) of the simulation software The Bus

fleascope-rs

interact with a Fleascope

todolint

code comment SAST security scanner

explore-os

An actor system exposed as filesystem

ruma-lean

Formally verified, dependency-free Matrix State Resolution v2 logic

reifydb-sub-flow

Flow subsystem for stream processing and data flows

attuned-store

Storage traits and in-memory backend for Attuned

reifydb-extension

Unified extension loading for ReifyDB (FFI, WASM, native)

reifydb-wasm

WebAssembly runtime for sandboxed execution in ReifyDB (backed by wasmtime)

reifydb-testing

Testing utilities and helpers for ReifyDB

reifydb-policy

Policy engine for ReifyDB — compiles, caches, and evaluates security policies

bevy_spritesheet

bevy extensions with support for selecting a sprite index depending on an associated state

reifydb-sub-server

Common infrastructure for server subsystems

zetamesh_flags

zetamesh-flags is a minimal Rust library for rule-based validation of state combinations

reifydb-sub-api

Subsystem API and interfaces for ReifyDB

madeleine

Transparent object persistence with predefined operations and state containers

mdl

Data model library to share app state between threads and process and persist the data in the filesystem. Implements a simple way to store structs instances in a LMDB database and other methods like BTreeMap

spacetimedb-snapshot

Low-level interfaces for capturing and restoring snapshots of database states

reifydb-sub-server-ws

WebSocket server subsystem for ReifyDB

reifydb-subscription

Protocol-agnostic subscription consumption for ReifyDB

statehouse-daemon

Strongly consistent state and memory engine for AI agents

nobreak

minimal circuit breaker for your functions

reifydb-sub-tracing

Tracing subsystem for ReifyDB using tracing_subscriber

phyz-model

Model and state types for phyz physics engine

httpstate

HTTP State, httpstate.com

anathema-backend

Various backends for Anathema

anathema-runtime

Anathema runtime

reifydb-sql

SQL to RQL transpiler

sidebyside-core

Core domain types for Sidebyside SDK

dota2-gsi

receives Dota 2 GSI updates, converts them into strongly typed states, and dispatches them as high-level events via a listener-based API

reifydb-sub-server-grpc

gRPC server subsystem for ReifyDB

reifydb-sub-server-http

HTTP server subsystem for ReifyDB using Axum

lifx-rs

A synchronous + asynchronous library for communicating with the official LIFX-API and the unoffical offline API

reifydb-sub-subscription

Ephemeral subscription subsystem for ReifyDB

redux-rs

Redux

methods-enum

Two macros for easy implementation of 'state' design pattern and other dynamic polymorphism using enum instead of dyn Trait

input_query

querying key states without a window

reifydb-remote-proxy

Remote subscription proxy for ReifyDB

rsconnect

Fine-grained reactivity in Rust

app-world

A framework agnostic approach to managing frontend application state

vm-pool-snapshot

Save/restore VM state via Virtualization.framework

space-search

providing basic generic depth-first, breadth-first, heuristic-guided, and A* search space exploration algorithms

reifydb-sub-metric

Metric collection subsystem for ReifyDB

reifydb-sub-replication

CDC-based replication subsystem for ReifyDB

goap-ai

Goal-Oriented Action Planning (GOAP) AI

attuned-qdrant

Qdrant storage backend for Attuned

percy-state

Manage application state

termichart-agent

Structured chart state and query API for programmatic inspection

bevy_schedule_utils

Exposes Bevy's schedule state to the user

gollum-action-planning

Goal-directed action planning for the Gollum logic engine

fsl

FakeHub State Language. DSL for managing state in fakehub

symphony-tracker

Issue tracker integration (Linear GraphQL) for Symphony

makepad-android-state

Exposes access to Makepad's context states on Android

modx

A way to handle states with structs in Dioxus inspired by mobx

foothold

Track, checkpoint, and resume long-running operations with detailed progress reporting

cn

An input helper built for winit 🕹️

reifydb-sub-server-otel

OpenTelemetry/Jaeger tracing subsystem for ReifyDB

dbs-snapshot

A version tolerant state serialization and deserialization library

reducer

A predictable reactive framework for Rust apps

ixa-fips

efficiently working with FIPS region codes

gpui-storybook

The gpui-storybook crate

reifydb-compression

Column compression for storage and network in ReifyDB

pam-f

Safe Rust wrappers for PAM authentication

automata-like-programming

that provides mechanisms for controlling the flow of execution in imitation of an automaton

echo_state

State management for echo-agent framework (memory, compression, audit)

skrills-state

State management for skrills runtime options, pins, and persisted overrides

hutch

Checkpoint and undo system for AI agent sessions - safe burrow to return to

pulith-lock

Deterministic lock file model and lock diff for Pulith

oxide-update-engine-display

Display and rendering utilities for oxide-update-engine events

intrepid

Manage complex async business logic with ease

apparat

A lightweight event-driven behavioral state machine

persistx

Tiny async persistence helper: atomically store/load a single typed value using postcard + serde (cross-platform config paths)

dandy

DFAs, NFAs and regular expressions together with a file format

statehouse-proto

Strongly consistent state and memory engine for AI agents

tmux-claude-state

Claude session state detection and tmux helpers

reconstitute

Derive macro that generates a State struct and a reconstitute constructor for hydrating aggregates from persistent state

quokka-state

States with dependencies used for Quokka

skg-state-memory

In-memory StateStore implementation for skelegent

reifydb-store-transaction

Transaction storage for OLTP operations and recent data

fission-semantics

Semantics

reifydb-store-column

Column-oriented storage for analytical queries in ReifyDB

reifydb-function

Function interfaces for ReifyDB

bitwarden-state

Internal crate for the bitwarden crate. Do not use.

riemann_client

A Riemann client library

gemini-live-harness

Durable file-backed harness state and tools for Gemini Live hosts

http1

codec types

dogoap

yewdux-middleware

A Redux-like middleware for Yewdux

co-api

COKIT API to implement a Core

lockex

command executor with locking and state

draw_state

Graphics state blocks for gfx-rs

enum_handler

A macro to generate a handler trait for enums variants

agsim

A discrete event simulation library

reovim-module-completion

Completion module for reovim - pluggable completion sources and popup state

lwactors

Lightweight actors for Rust using futures-rs

too

tui framework

rustz

functional programming in Rust

koi-config

Configuration, breadcrumb discovery, and state persistence for Koi

apiari-common

Shared types, JSONL IPC, and utilities for Apiari tools

nusy-conductor

Agent orchestration conductor — reads kanban state via NATS, decomposes expeditions, tracks agent availability

co-runtime

COKIT WebAssembly Runtime to execute Cores (CO State Reducers)

json_state

managing states using json with file persistence

leptix-checkbox

Leptix Checkbox component — a control that allows toggling between checked, unchecked, and indeterminate states

reversible

A generic wrapper struct that provides reversible editing capabilities

bhc-session

Compiler session state, options, and configuration for BHC

concoct

Cross-platform UI framework

reifydb-metric-old

Storage and CDC metrics tracking for ReifyDB

quokka-config

Configure modular states in Quokka

dicomview-core

WASM-safe DICOM decode, incremental volumes, MPR state, and rendering presets

neuron-state-memory

In-memory StateStore implementation for neuron

reifydb-sub-worker

Worker pool subsystem for task scheduling and execution

skg-state-fs

Filesystem-backed StateStore implementation for skelegent

neuron-state-fs

Filesystem-backed StateStore implementation for neuron

reifydb-network

Network protocol handling for HTTP and WebSocket in ReifyDB

rice-storage

Rust sdk for interacting with Rice

mini-rust-auth

A maybe to simple authentication crate

statewatcher

shared state channel where readers are notified of updates, inspired by tokio::watch but for std

midnight-storage-core

low-level storage primitives for Midnight's ledger

reifydb-macro

Macros for ReifyDB

sovran-state

state management for Rust

wg-toggle

Toggle Wireguard connection state

dashcue

Event, intent, and state model for DashScene

app-universe

A framework agnostic approach to managing frontend application state

constitution

United States

hmmm

Hidden Markov Models in Rust

tokio-agent

Agents are a simple abstraction around state, inspired by Elixir's Agent

user_dirs

A respectful, XDG-first user directories implementation for obtaining the home, cache, config, data, runtime, and state directories

dstate-ractor

Ractor adapter for the dstate distributed state crate

spsd

state persistent serverless devboxes

snapstore

snapshot based database

this-state

way to store state in a thread-safe manner as well as a way to asynchronously wait for state changes

us-state-info

A Fork of a Rust implementation of the state names & abbreviations for the USA

ruma-zk-prover

Matrix State Resolution framework with ZK-SNARK proof generation and verification

fips-codes

Static, zero-dependency mapping of FIPS IDs to U.S. state and county names