-
h2
An HTTP/2 client and server
-
futures
streams featuring zero allocations, composability, and iterator-like interfaces
-
mio
Lightweight non-blocking I/O
-
tower-http
Tower middleware and utilities for HTTP clients and servers
-
async-io
Async I/O and timers
-
tokio-rustls
Asynchronous TLS/SSL streams for Tokio using Rustls
-
deadpool
Dead simple async pool
-
rdkafka
Rust wrapper for librdkafka
-
futures-lite
Futures, streams, and async I/O combinators
-
async-openai
OpenAI
-
axum-server
High level server designed to be used with axum framework
-
interprocess
communication toolkit
-
pollster
Synchronously block the thread until a future completes
-
tokio
An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications
-
event-listener
Notify async tasks or threads
-
process-wrap
Wrap a Command, to spawn processes in a group or session or job etc
-
tokio-cron-scheduler
Schedule tasks on tokio using cron-like annotation, at an instant or repeat them at a fixed duration. Tasks can optionally be persisted using PostgreSQL or Nats.
-
futures-concurrency
Structured concurrency operations for async Rust
-
mlua
High level bindings to Lua 5.5/5.4/5.3/5.2/5.1 (including LuaJIT) and Luau with async/await features and support of writing native Lua modules in Rust
-
tokio-serial
A serial port implementation for tokio
-
async-stream
Asynchronous streams using async & await notation
-
futures-timer
Timeouts for futures
-
yrs
High performance implementation of the Yjs CRDT
-
tracing-actix-web
Structured logging middleware for actix-web
-
async_zip
An asynchronous ZIP archive reading/writing crate
-
gix-packetline-blocking
A duplicate of
gix-packetlinewith theblocking-iofeature pre-selected -
ractor
A actor framework for Rust
-
tower-sessions
🥠 Sessions as a
towerandaxummiddleware -
async-tar
async TAR file reader and writer. This library does not currently handle compression, but it is abstract over all I/O readers and writers. Additionally, great lengths are taken to ensure that the entire…
-
polling
Portable interface to epoll, kqueue, event ports, and IOCP
-
openraft
Advanced Raft consensus
-
tokio-retry2
Extensible, asynchronous retry behaviors for futures/tokio
-
bb8
Full-featured async (tokio-based) connection pool (like r2d2)
-
io-uring
The low-level
io_uringuserspace interface for Rust -
futures-buffered
future concurrency primitives with emphasis on performance and low memory usage
-
eventsource-stream
A basic building block for building an Eventsource from a Stream of bytes
-
tower-lsp-server
Language Server Protocol implementation based on Tower
-
keycloak
Admin REST API
-
apalis
extensible and multithreaded background task processing for Rust
-
kameo
Fault-tolerant Async Actors Built on Tokio
-
prodash
A dashboard for visualizing progress of asynchronous and possibly blocking tasks
-
rxrust
Reactive Extensions
-
async-broadcast
Async broadcast channels
-
miow
A zero overhead I/O library for Windows, focusing on IOCP and async I/O abstractions
-
backon
Make retry like a built-in feature provided by Rust
-
futures-signals
Zero cost FRP signals using the futures crate
-
minus
An asynchronous data feedable terminal paging library for Rust
-
want
Detect when another Future wants a result
-
tokio-graceful
util for graceful shutdown of tokio applications
-
tokio-retry
Extensible, asynchronous retry behaviours for futures/tokio
-
salvo-serde-util
serde util for salvo
-
async-native-tls
Native TLS using futures
-
idb
A futures based crate for interacting with IndexedDB on browsers using webassembly
-
monoio
A thread per core runtime based on iouring
-
dptree
An asynchronous event dispatch mechanism for Rust
-
tor-rtcompat
Compatibility layer for asynchronous runtimes, used by Tor
-
remoc
🦑 Remote multiplexed objects, channels, observable collections and RPC making remote interactions seamless. Provides multiple remote channels and RPC over TCP, TLS or any other transport.
-
tokio-graceful-shutdown
perform a graceful shutdown on a Tokio based service
-
pty-process
spawn commands attached to a pty
-
asynchronous-codec
encoding and decoding frames using
async/await -
claude-agent-sdk-rs
Rust SDK for Claude Code CLI with bidirectional streaming, hooks, custom tools, and plugin support - 100% feature parity with Python SDK
-
blocking
A thread pool for isolating blocking I/O in async programs
-
capnp-futures
async serialization for Cap'n Proto messages
-
rust-parallel
Fast command line app in rust/tokio to run commands in parallel. Similar interface to GNU parallel or xargs.
-
agnostic-lite
agnostic-liteis an agnostic abstraction layer for any async runtime -
stream-download
streaming content to a local cache
-
tokio-rusqlite
Asynchronous handle for rusqlite library
-
async-walkdir
Asynchronous directory traversal for Rust
-
async-shutdown
one-stop solution for async graceful shutdown
-
ntex-h2
An HTTP/2 client and server
-
apalis-redis
Background task processing for rust using apalis and redis
-
paho-mqtt
The Official Eclipse Paho MQTT Rust Client Library. This is a wrapper around the Paho C library
-
pinky-swear
Futures and async/await-ready Promises
-
wfaas
Workflow-as-a-Service engine for managing multi-step operations
-
async-graphql-parser
GraphQL query parser for async-graphql
-
compio
Completion based async runtime
-
ws_stream_tungstenite
Provide AsyncRead/AsyncWrite over Tungstenite WebSockets
-
swiftide-query
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
deno_unsync
A collection of adapters to make working with Tokio single-threaded runtimes easier
-
cxx-async
interoperability between C++ coroutines and asynchronous Rust
-
wasm-timer
Abstraction over std::time::Instant and futures-timer that works on WASM
-
syslog-rs
A native Rust implementation of the glibc/libc/windows syslog client and windows native log for logging
-
job-orchestrator
Asynchronous job orchestrator for managing and routing payloads between services and computing resources with quota tracking
-
twilight-standby
filter wait for filtered incoming events for the Twilight ecosystem
-
swiftide
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
igd-next
Internet Gateway Protocol client
-
tokio-vsock
Asynchronous Virtio socket support for Rust
-
ipc-queue
FIFO queue described in fortanix-sgx-abi used for asynchronous usercalls
-
eyeball
Add observability to your Rust types!
-
spawns
Async runtime agnostic thread context task spawner for Rust
-
async_cell
A Cell<Option<T>> that you can await on
-
prism-mcp-rs
Production-grade Rust SDK for Model Context Protocol (MCP) - Build AI agents, LLM integrations, and assistant tools with enterprise features
-
elicitation
Conversational elicitation of strongly-typed Rust values via MCP
-
trait-variant
working with impl traits in Rust
-
duroxide
Durable code execution framework for Rust
-
springtime-di
Dependency injection framework based on automatic component discovery and runtime autowiring
-
peace_params
Constraints and specifications for parameters for the peace automation framework
-
google-plusdomains1
A complete library to interact with plusDomains (protocol v1)
-
containerd-shim
containerd shim extension
-
flo_binding
Declarative binding library for Rust
-
persway-tokio
Sway layout and focus helper daemon that adds spiral and stack-main autotiling plus opacity and window renaming
-
nmrs
NetworkManager over D-Bus
-
async_cache
Async refresh cache
-
async-lsp
Asynchronous Language Server Protocol (LSP) framework based on tower
-
lamellar
asynchronous tasking runtime for HPC systems developed in RUST
-
tigerbeetle-unofficial
Safe high level async bindings to tigerbeetle client library
-
scoped-futures
imposing upper bounds on Future lifetimes
-
tokio-io-utility
Some helper functions for tokio::io
-
pi-async-rt
Based on future (MVP), a universal asynchronous runtime and tool used to provide a foundation for the outside world
-
hannibal
A small actor library
-
rusty_falcon
Rust bindings for CrowdStrike Falcon API
-
gardal
A WIP performance-focused token-bucket rate limiting and throttling library
-
stackfuture
wrapper around futures that stores the wrapped future in space provided by the caller
-
future-queue
Adapters to manage a queue of futures, where each future can have a different weight
-
service-async
A Service like tower in async style
-
signal-hook-tokio
Tokio support for signal-hook
-
samsa
Rust-native Kafka/Redpanda protocol and client implementation
-
safina
Safe async runtime
-
tokio-rustls-acme
Automatic TLS certificate management using rustls
-
web-push
Web push notification client with support for http-ece encryption and VAPID authentication
-
flourish
Convenient and full-featured signals for Rust
-
exponential-backoff
An exponential backoff generator with jitter
-
fluvio-future
I/O futures for Fluvio project
-
mml-lib
Emacs MIME message Meta Language (MML)
-
ctrlc2
Easy Ctrl-C handler version 2 for Rust projects
-
rsactor
Efficient In-Process Actor Model Implementation for Rust
-
async-flow
Async abstractions for flow-based programming (FBP)
-
keyring-lib
High-level, asynchronous API for keyring-rs, a cross-platform Rust library to manage credentials
-
submap
B-Tree map for pub/sub services
-
tokio-io-timeout
Tokio wrappers which apply timeouts to IO operations
-
mio-serial
A serial port implementation for mio
-
futures-batch
An adaptor that chunks up elements and flushes them after a timeout or when the buffer is full. (Formerly known as tokio-batch.)
-
turnkeeper
An asynchronous, recurring job scheduler for Tokio with support for CRON, interval, and weekday/time schedules, plus retries, cancellation, and observability
-
futures-bounded
bounding futures in size and time
-
filebuffer
Fast and simple file reading
-
kdbplus
Dual q/kdb+ interface for API to build a shared library and an IPC client
-
tower-fallback
A Tower service combinator that sends requests to a first service, then retries processing on a second fallback service if the first service errors
-
peekable
reader and async reader, which enhance your network programming experience
-
unicycle
A scheduler for driving a large number of futures
-
ntex-io-uring
The low-level
io_uringuserspace interface for Rust -
c-ares-resolver
An asynchronous DNS resolver, backed by c-ares
-
async-openai-compat
OpenAI
-
reratui
A modern, reactive TUI framework for Rust with React-inspired hooks and components, powered by ratatui
-
tor-rpcbase
Low level functionality for Arti's RPC service
-
better-logger
Flexible sync/async logger with console, file, and HTTP output
-
mcp-attr
declaratively building Model Context Protocol servers
-
tokio-stream
work with
Streamandtokio -
mikrotik-rs
Asynchronous Rust library for interfacing with MikroTik routers
-
kestrel-timer
High-performance async timer library based on Hierarchical Timing Wheel algorithm
-
asynk-strim
Lightweight stream generator library
-
tmq
ZeroMQ bindings for Tokio
-
futures-rustls
Asynchronous TLS/SSL streams for futures using Rustls
-
mlua-luau-scheduler
Luau-based async scheduler, using mlua and async-executor
-
hydra
A framework for writing fault tolerant, highly scalable applications with the Rust programming language
-
rocketmq-runtime
Unofficial Rust implementation of Apache RocketMQ
-
async-scoped
Spawn scoped (non 'static) asynchronous futures for async_std and tokio runtimes
-
claude-code-agent-sdk
Rust SDK for Claude Code CLI with bidirectional streaming, hooks, custom tools, and plugin support
-
sids
An actor-model concurrency framework providing abstraction over async and blocking actors
-
blockstore
An IPLD blockstore capable of holding arbitrary data indexed by CID
-
gcs-rsync
rsync support for gcs with higher perf than gsutil rsync
-
genawaiter
Stackless generators on stable Rust
-
theseus-mlua
High level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Luau with async/await features and support of writing native Lua modules in Rust. Fork with added Factorio Lua support
-
soul-core
Async agentic runtime for Rust — steerable agent loops, context management, multi-provider LLM abstraction, virtual filesystem, WASM-ready
-
tipsy
Cross-platform IPC for Tokio
-
pharos
Observer pattern which generates a futures 0.3 stream of events
-
ginepro
A client-side gRPC channel implementation for tonic
-
apalis-postgres
Background task processing for rust using apalis and postgres
-
tirea-agentos
Plugin orchestration, sub-agent management, and lifecycle composition for tirea AgentOS
-
async-dropper
The least-worst ad-hoc implementation of AsyncDrop as a Derive macro
-
adk-core
Core traits and types for Rust Agent Development Kit (ADK-Rust) agents, tools, sessions, and events
-
round-based
Driver for MPC protocols
-
arc-malachitebft-core-consensus
Core consensus algorithm for the Malachite BFT consensus engine
-
busybody
Service Container and Dependency injector crate
-
claude-pool
Slot pool orchestration library for Claude CLI
-
ringline
io_uring-native async I/O runtime for Linux
-
delay_timer
Time-manager of delayed tasks. Like crontab, but synchronous asynchronous tasks are possible, and dynamic add/cancel/remove is supported.
-
async-recursion
Recursion for async functions
-
async-process
Async interface for working with processes
-
treadle
A persistent, resumable, human-in-the-loop workflow engine backed by a petgraph DAG
-
tachyonix
A very fast asynchronous, multi-producer, single-consumer bounded channel
-
manual_future
A future that must be manually completed, similar to Java's CompletableFuture
-
async-ringbuf
Async SPSC FIFO ring buffer
-
lightstream
Composable, zero-copy Arrow IPC and native data streaming for Rust with SIMD-aligned I/O, async support, and memory-mapping
-
async_singleflight
Async singleflight
-
rl-core
Core logic for a token-bucket rate-limiter
-
pipedream-rs
A typed, heterogeneous event relay with observable delivery, completion tracking, and lossless message routing
-
abscissa_tokio
Support for launching Tokio runtimes within Abscissa applications
-
combine-latest
Combines two or more streams into a new stream which yields tuples with the latest values from each input stream
-
kicad-ipc-rs
Rust client library for the KiCad IPC API (async-first)
-
async-speed-limit
Asynchronously speed-limiting multiple byte streams
-
openraft-surrealkv
key-value store built on top of OpenRaft, designed for learning and experimentation with Raft consensus algorithm
-
poll-promise
Poll the result of an async operation in a game or immediate mode GUI
-
wavelet
High-performance graph-based stream processing runtime
-
tokio-task-pool
Task pool for Tokio Runtime
-
uds-fork
A unix domain socket crate that supports abstract addresses, fd-passing, seqpacket and windows unix stream sockets
-
claude-code-client-sdk
Rust SDK for integrating Claude Code as a subprocess with typed APIs
-
charmed-bubbletea
A powerful TUI framework based on The Elm Architecture
-
reactor-trait
A collection of traits to define a common interface across reactors
-
kafka
Rust client for Apache Kafka
-
rustix-uring
The low-level
io_uringuserspace interface for Rust -
rustls-acme
TLS certificate management and serving using rustls
-
pubnub
SDK for Rust
-
kube-lease-manager
Ergonomic and reliable leader election using Kubernetes Lease API
-
j4rs
j4rs stands for 'Java for Rust' and allows effortless calls to Java code, from Rust
-
fluxion-stream
Stream combinators with ordering guarantees for async Rust
-
adaptive-timeout
Adaptive timeout computation based on observed latency percentiles
-
reactive-mutiny
async Event-Driven Reactive Library with advanced & optimized containers (channels) and Stream executors
-
openrouter_api
client library for the OpenRouter API
-
gql_client
Minimal GraphQL client for Rust
-
continue
Swift-style continuation API
-
future_form
Abstractions over Send and !Send futures
-
actify
An intuitive actor model with minimal boilerplate
-
next-gen
Safe generators on stable Rust
-
async-global-executor
A global executor built on top of async-executor and async-io
-
tokio-process-tools
Interact with processes spawned by tokio
-
windmark
An elegant and highly performant async Gemini server framework
-
activitystreams-vocabulary
ActivityStreams 2.0 Vocabulary data structures
-
stakker
A lightweight low-level single-threaded actor runtime
-
orra
Context-aware agent session management for any application
-
tracing-otel-extra
Bootstrap utilities for tracing and OpenTelemetry integration
-
codex-helper
A Rust-based local helper / proxy for Codex CLI traffic with multi-provider routing, usage-aware switching, filtering, and session helpers
-
tasklet
An asynchronous task scheduling library
-
containerd-shim-protos
TTRPC bindings for containerd shim interfaces
-
patharg
Treat "-" (hyphen/dash) arguments as stdin/stdout
-
tokio-muxt
Timer for a limited set of events that multiplexes over a single tokio Sleep instance
-
libsync
A channels library
-
scoped-stream-sink
Easy way to make streams and sinks
-
actix-rt
Tokio-based single-threaded async runtime for the Actix ecosystem
-
llm-kit-provider
Provider interface and traits for the LLM Kit - defines the contract for implementing AI model providers
-
plexor-core
Core library for the rust implementation of the Plexo distributed system architecture, providing the fundamental Plexus, Neuron, Codec, and Axon abstractions
-
gix-actor
A way to identify git actors
-
mmap-io
High-performance, async-ready memory-mapped file I/O library for Rust. Supports fast segment-based loading, updates, and persistence. Designed for database engines, game runtimes, and real-time applications.
-
rocketmq-rust
Unofficial Rust implementation of Apache RocketMQ
-
libevent
Rust bindings to the libevent async I/O framework
-
runtara-core
Core execution engine for runtara - manages instances, checkpoints, signals, and durable sleep
-
async-injector
Reactive dependency injection for Rust
-
zduny-wasm-timer
Abstraction over std::time::Instant and futures-timer that works on WASM
-
qml-rs
QML background job processing
-
shmipc
Shared memory IPC for Rust
-
yoagent
effective agent loop with tool execution and event streaming
-
streamweave
Composable, async, stream-first computation in pure Rust
-
futures-util
Common utilities and extension traits for the futures-rs library
-
executor-core
A zero-cost task executor abstraction layer for Rust async runtimes
-
rxr
Reactive extensions for event-driven applications
-
tears
elegant framework for building TUI applications using The Elm Architecture (TEA)
-
openssh-sftp-protocol
Data format used to communicate with openssh mux server
-
pingora-timeout
Highly efficient async timer and timeout system for Tokio runtimes
-
qbice
The Query-Based Incremental Computation Engine
-
asynq
reliable & efficient distributed task queue in Rust, inspired by hibiken/asynq
-
cc-sdk
Rust SDK for Claude Code CLI with full interactive capabilities
-
yazi-core
Yazi core logic
-
product-os-async-executor
Product OS : Async Executor provides a set of tools to handle async execution generically so that the desired async library (e.g. tokio, smol) to be used can be chosen at compile time.
-
spider_agent
A concurrent-safe multimodal agent for web automation and research
-
allium-parser
Parser and structural validator for the Allium specification language
-
genai-rs
client library for Google's Generative AI (Gemini) API with streaming, function calling, and multi-turn conversations
-
rust-multipart-rfc7578_2
multipart/form-data (RFC7578)
-
evno
A high-performance event bus for asynchronous tasks and event-driven systems
-
manager_handlers
A microservice manager implementation that creates HTTP-accessible handlers with configurable replicas. Handlers communicate via an internal bus, enabling collaborative request processing in a distributed architecture.
-
twilight-http-ratelimiting
Discord REST API ratelimiter implementations for the Twilight ecosystem
-
io-tether
A small library for defining I/O types which reconnect on errors
-
conducer
Easy async
-
saorsa-ai
Unified multi-provider LLM API
-
openaction
creating plugins for the OpenAction API
-
tokio-rate-limit
High-performance, lock-free rate limiting library with pluggable algorithms and Axum middleware
-
fundamentum-edge-daemon
The supported way to access Fundamentum's ecosystem from linux devices
-
fchat
Chat library for the fiddlesticks agent harness framework
-
io_uring_buf_ring
Help user create and manage io-uring buffer-ring
-
tokio-actors
Zero-ceremony, Tokio-native actors with strong typing and production-ready edge case handling
-
cloudillo-core
Core infrastructure for the Cloudillo platform: middleware, extractors, scheduler, rate limiting, and access control
-
greentic-session
Greentic multi-tenant session manager with in-memory and Redis backends
-
tokio-pipe
Asynchronous pipe(2) library using tokio
-
some_executor
A trait for libraries that abstract over any executor
-
pipex
A powerful functional pipeline macro for Rust combining sync, async, parallel, and streaming operations with extensible error handling
-
futures-locks
Futures-aware lock primitives
-
triggered
Triggers for one time events between tasks and threads
-
tokio-par-util
running computations in parallel on top of Tokio
-
ghost_actor
GhostActor makes it simple, ergonomic, and idiomatic to implement async / concurrent code using an Actor model
-
tcrm-monitor
Task dependency management and execution library with parallel processing, real-time monitoring, and runtime control
-
fang
Background job processing library for Rust
-
google-places-api
Unofficial Google Places API for rust
-
ya-gcp
APIs for using Google Cloud Platform services
-
ttlog
A comprehensive high-performance tracing and logging system
-
libublk
building linux block device in userspace
-
keen-retry
Retry-as-a-value: zero-cost, ownership-friendly retries with diagnosable outcomes with full async and lib/app boundaries support
-
tower-sessions-ext
A maintained fork of tower-sessions-ext, providing session middleware for tower and axum
-
coclai
Ergonomic Rust wrapper for codex app-server with runtime safety and release gates
-
xan-actor
Akka actor
-
tokio-udev
Non-blocking/Asynchronous Tokio support for udev device events
-
tokio-process-stream
that wraps a tokio::process into a tokio::stream
-
flowly
modular and reusable components for building robust pipelines processing audio, video and other
-
leptos-next-metadata
Next.js-style metadata management for Leptos v0.8+ with type-safe APIs, blazing-fast OG image generation, and AI-assisted development. Part of the Cloud Shuttle ecosystem.
-
conogram
An async wrapper for Telegram Bot API
-
mcmc-rs
Minimal rust client for memcached
-
ntex-polling
Portable interface to epoll, kqueue, event ports, and IOCP
-
nb
Minimal non-blocking I/O layer
-
multi-llm
Unified multi-provider LLM client with support for OpenAI, Anthropic, Ollama, and LMStudio
-
oxigdal-workflow
DAG-based workflow engine for complex geospatial processing pipelines
-
elizaos-plugin-shell
elizaOS Shell Plugin - Shell command execution with directory restrictions and history tracking
-
histlog
hdrhistogram crate, provides off-thread serialization of HdrHistogram interval logs to file
-
mkv-element
A Matroska/WebM element reader and writer
-
kcp-tokio
A high-performance async Rust implementation of KCP - A Fast and Reliable ARQ Protocol
-
dark-std
asynchronous containers build on tokio. It uses a read-write separation design borrowed from Golang
-
tokio-immediate
Asynchronous glue for your immediate mode UI
-
cdpkit
Type-safe Chrome DevTools Protocol (CDP) client for Rust
-
acton-reactive
Acton Reactive is the main crate of the Acton framework, designed for building reactive, event-driven, and asynchronous systems. It provides intuitive abstractions to make working with…
-
async-cuda
Async CUDA for Rust
-
mill-io
A lightweight event loop library for Rust that provides efficient non-blocking I/O management without relying on heavyweight async runtimes
-
events_once
Efficient oneshot events (channels) with support for single-threaded events, object embedding, event pools and event lakes
-
bubbletea-rs
The fun, functional, and stateful way to build terminal apps in Rust
-
kube-coordinate
Kubernetes leader election using the coordination.k8s.io API
-
rsmq_async
Async RSMQ port to rust. RSMQ is a simple redis queue system that works in any redis v2.4+. It contains the same methods as the original one in https://github.com/smrchy/rsmq
-
bob-runtime
Runtime orchestration layer for Bob Agent Framework
-
streamunordered
An efficient async stream multiplexer
-
oxide_core
Rust engine primitives for Oxide (store, snapshot streams, error model, optional persistence)
-
ankit-engine
High-level workflow operations for Anki via AnkiConnect
-
iii-sdk
SDK for III Engine - a platform for building distributed applications
-
mavkit
Async MAVLink SDK for vehicle control, missions, and parameters
-
aselect
Opinionated replacement for tokio::select!, avoiding certain pitfalls
-
ractor_actors
actors built with Ractor
-
minitimer
A mini timer of delayed tasks. Only asynchronous tasks are possible on tokio runtime, and dynamic add/cancel/remove is supported.
-
rinf-router
Router and handler framework for RINF-based Flutter <> Rust apps
-
bias-rust-mcp-extra
companion crate to rust-mcp-sdk offering extra implementations of core traits like SessionStore and EventStore, enabling integration with various database backends and third-party platforms…
-
stream_throttle
Stream combinator, to limit the rate at which items are produced
-
async-graphql-actix-web
async-graphql for actix-web
-
tiny_kafka
A tiny Kafka client library with producer and consumer functionalities
-
async-object-pool
object pool implementation that uses asynchronous synchronization primitives only
-
viz
Fast, robust, flexible, lightweight web framework for Rust
-
mqi
Idiomatic IBM® MQ Interface (MQI) and MQ Administration Interface (MQAI) APIs
-
rdkafka-sys
Native bindings to the librdkafka library
-
mq-bridge
An asynchronous message bridging library connecting Kafka, MQTT, AMQP, NATS, MongoDB, HTTP, and more
-
discro
DISCRete Observables for asynchronous Functional Reactive Programming (FRP)
-
easy-schedule
A flexible task scheduler built on Tokio with multiple scheduling options and skip conditions
-
cmd-proc
Process command builder with capture support
-
sacs
Async Cron Scheduler for Tokio
-
async-notify
A general version async Notify, like
tokioNotify but can work with any async runtime -
observable-property-tokio
A thread-safe, async-compatible observable property implementation for Rust using Tokio
-
b2_backblaze
basic async library to upload small files to backblaze b2 service
-
tsuki-scheduler
light wight, composable and extensible scheduler for every runtime
-
aoc_leaderbot_lib
Support library for aoc_leaderbot, an Advent of Code leaderboard-watching bot
-
ulua
High level Luau bindings to Rust with async/await support
-
runner_q
Durable activity queue and worker system
-
futures-signals-ext
Extension to futures-signals: MutableOption with combinators, spawning, predicate driven selections from SignalVec
-
hypercore
Secure, distributed, append-only log
-
async-task
Task abstraction for building executors
-
specta-serde
Serde support for Specta
-
async_zip_futures
An asynchronous ZIP archive reading/writing crate using futures-rs
-
adk-agent
Agent implementations for Rust Agent Development Kit (ADK-Rust, LLM, Custom, Workflow agents)
-
s3tui
TUI application for multiple s3 account operations
-
ave-actors-actor
Ave actor model
-
slop-futures
Async and concurrent execution utilities for SLOP
-
ate
Distributed immutable data store with strong encryption and authentication
-
iron_runtime
Agent runtime with LLM request routing and translation
-
futures-executor
Executors for asynchronous tasks based on the futures-rs library
-
botrs
QQ Bot framework based on QQ Guild Bot API
-
postage
An async channel library
-
ipc-rpc
A wrapper over servo/ipc-channel which provides many high level features
-
osd-core
OpenSequenceDiagrams core - A sequence diagram parser and SVG renderer
-
claude-code-acp-rs
Use Claude Code from any ACP client - A Rust implementation of Claude Code ACP Agent
-
dynify
Add dyn compatible variant to your async trait
-
pi_async_transaction
Asynchronous abstraction for transactions
-
timer-lib
A feature-rich Rust library for creating and managing timers
-
rs-event-emitter
simulate promise implementation for rust
-
retainer
Minimal async cache in Rust with support for key expirations
-
opencode-sdk
Rust SDK for OpenCode (HTTP-first hybrid with SSE streaming)
-
kalshi-trade-rs
Rust client for the Kalshi trading API and WebSocket streams
-
aisdk
An open-source Rust library for building AI-powered applications, inspired by the Vercel AI SDK. It provides a robust, type-safe, and easy-to-use interface for interacting with various Large Language Models (LLMs).
-
reactio
Low-Latency Event Driven Nonblocking Reactor Pattern
-
peace_rt_model
Runtime data types for the peace automation framework
-
gyre
A lock-free asynchronous ring buffer inspired by the LMAX Disruptor
-
braintrust-sdk-rust
Rust SDK for Braintrust logging and tracing
-
anthropic-agent-sdk
Rust SDK for Claude Code CLI - streaming queries, hooks, permissions, and MCP integration
-
async-graphql-wasm-parser
GraphQL query parser for async-graphql-wasm
-
ads_client
An asynchronous, non-blocking ADS client
-
preloader
Asynchronous data preloader library
-
symposium-acp-agent
Symposium-enriched ACP agent that wraps downstream agents with enhanced capabilities
-
scanbridge
A unified, pluggable API for malware scanning with circuit breakers, policy enforcement, and audit logging
-
fmmap
A flexible and convenient high-level mmap for zero-copy file I/O
-
sse-gateway
A lightweight, pluggable SSE (Server-Sent Events) gateway library
-
obzenflow-fsm
Async-first Finite State Machine library inspired by Akka (Classic) FSM
-
aimdb-tokio-adapter
Tokio runtime adapter for AimDB - full-featured std async runtime support
-
est
Extensions for the rust Standard library and Tokio
-
thoughtchain
Semantic, hash-chained memory for long-running and multi-agent systems
-
executor-trait
A collection of traits to define a common interface across executors
-
axtask
ArceOS task management module
-
openhelm
AI-powered Telegram bot and daemon with a configurable skill and tool system
-
lmrc-docker
Docker client library for the LMRC Stack - ergonomic fluent APIs for containers, images, networks, volumes, and registry management
-
tools_interface
Abstractions of serveral Wikipedia/Wikimedia/Wikidata-related tools
-
esrs
A Prima.it-opinionated library to achieve cqrs/es
-
skp-ratelimit
Advanced, modular, extensible rate limiting library with GCRA, per-route quotas, and composite keys
-
oneringbuf
A lock-free single-producer, single-consumer (SPSC) ring buffer with in-place mutability, asynchronous support, and virtual memory optimisation
-
tokio-zookeeper
Asynchronous client library for interacting with Apache ZooKeeper
-
activitystreams
A set of core types and traits for activitystreams data
-
background-jobs-sled
Sled storage backend for background-jobs
-
dataloader
Facebook's DataLoader using async-await
-
kiomq
An all-in-one task-queue and orchestration library for Rust
-
orphanage
Random collection of stuff that is still searching for a home
-
compio-io
IO traits for completion based async IO
-
transform-stream
Lightweight async stream wrapper
-
rrq
RRQ orchestrator CLI and worker runtime
-
langchain-ai-rust
Build LLM applications in Rust with type safety: chains, agents, RAG, LangGraph, embeddings, vector stores, and 20+ document loaders. A LangChain port supporting OpenAI, Claude, Gemini…
-
mapped_futures
A collection of futures based on FuturesUnordered that supports insertion, removal and mutation of futures by key
-
tokio-memq
high-performance in-memory async message queue
-
a3s-lane
Lane-based priority command queue for async task scheduling with reliability, scalability, and observability features
-
cortex-client
API for Cortex, a powerful observable analysis and active response engine
-
streamweave-attractor
Attractor pipeline as a StreamWeave graph
-
fastcgi-client
Fastcgi client implemented for Rust
-
oxigdal-streaming
Real-time data processing and streaming pipelines for OxiGDAL
-
futures-timeout
that provides timeouts for futures and streams
-
simple-pool
async pool for any kind of resources
-
agility
A powerful and elegant reactive programming library for Rust, inspired by category theory
-
tokio-fastcgi
FastCGI handler (responder, authorizer, filter) library for Tokio
-
another-rxrust
A different implementation than
rxRustfor easier use ofReactiveXinRust -
timer-deque-rs
A OS based timer and timer queue which implements timeout queues of different types
-
flashq
High-performance Rust client for flashQ job queue
-
llm-pipeline
Reusable node payloads for LLM workflows: prompt templating, Ollama calls, defensive parsing, streaming, and sequential chaining
-
cloud_terrastodon_azure_resource_types
Generated enum for Azure resource types for use in the Cloud Terrastodon project
-
nosy
Change notification / observation / broadcast channels, with filtering and coalescing. no_std compatible.
-
ollama-oxide
integrating with Ollama's native API, providing low-level inference and high-level conveniences
-
native_messaging
Cross-platform Rust native messaging host for browser extensions (Chrome & Firefox), with async helpers and manifest installer
-
tokio_schedule
schedule tasks in tokio runtime
-
yield-progress
Combined progress reporting and cooperative task yielding
-
dog-core
Core traits and utilities for the DogRS ecosystem - a modular Rust framework for building scalable applications
-
upflow
An asynchronous workflow engine based on DAG
-
tirea-agent-loop
LLM inference engine, tool dispatch, and streaming execution loop for tirea
-
swansong
Graceful Shutdown
-
mini_exercism
Minimalistic Rust library to interact with the Exercism.org APIs
-
helios-engine
A powerful and flexible Rust framework for building LLM-powered agents with tool support, both locally and online
-
eventgraph
Hash-chained, append-only, causal event graph
-
uring-file
Async file I/O for Linux using io_uring
-
deepseek-api
DeepSeek API SDK is a powerful Rust client library for interacting with the DeepSeek service
-
cruster
framework for building distributed, stateful entity systems with durable workflows
-
wechat-minapp
sdk for wechat miniprogram server api
-
tros
Your tros from tarantool TX thread to tokio(..and others!)
-
yazi-macro
Yazi macros
-
vmcircbuffer
Double Mapped Circular Buffer
-
aeon-market-scanner-rs
CEX/DEX market scanner: fetch prices, stream WebSocket updates, and find arbitrage opportunities
-
sseer
Various helpers for getting Event streams out of your SSE responses
-
reord
Run your tests multi-threaded, but in a reproducible way
-
popol
Minimal non-blocking I/O
-
aimdb-embassy-adapter
Embassy async runtime adapter for AimDB embedded targets
-
tcrm-task
Task execution unit for TCRM project
-
serviceless
actor model in rust, like actix
-
sayiir-core
Core types and traits for the Sayiir durable workflow engine
-
aws-smithy-legacy-http-server
Legacy server runtime for Smithy Rust Server Framework, providing compatibility for code generated with http 0.x and hyper 0.x dependencies
-
wp-core-connectors
Core connector registry and sink runtimes for WarpParse
-
spawn_groups
Structured concurrency construct written in Rust, for Rustaceans
-
tor-rtmock
Testing mock support for tor-rtcomapt
-
fluxion-stream-time
Time-based operators extending fluxion-stream with monotonic timestamps
-
task-supervisor
Supervisor for long-lived tokio tasks
-
moduforge-persistence
moduforge 持久化
-
async-dropper-simple
struct-wrapper (i.e. AsyncDropper<T>) based implementation of AsyncDrop
-
asyncjsonstream
Async JSON stream reader for selective parsing of large payloads
-
madsim-tokio
The
tokiosimulator on madsim -
tokio-rayon
Mix async code with CPU-heavy thread pools using Tokio + Rayon
-
async-ssh2-russh
Lighweight async ssh2 client, wrapping russh
-
actix-web-flash-messages
Flash messages for actix-web applications
-
gem-rs
that serves as a wrapper around the Google Gemini API, providing support for streaming
-
rocketmq-controller
RocketMQ Controller Module - High Availability Raft-based Controller
-
ros2_helpers
A wrapper around safe drive
-
futures-rx
Rx implementations for the futures crate
-
toolpath-github
Derive Toolpath provenance documents from GitHub pull requests
-
mpi-sys
Message Passing Interface bindings for Rust
-
apalis-sqlite
Background task processing for rust using apalis and sqlite
-
axum-extra
Extra utilities for axum
-
graus-db
A high-performance, thread-safe key-value embedded data store
-
async-fuse
Helpers for fusing asynchronous computations
-
bob-adapters
Adapter implementations for Bob Agent Framework ports
-
ractor-supervisor
Supervisor module for ractor framework
-
agentic-robotics-rt
High-performance agentic robotics framework with ROS2 compatibility
-
openai-ergonomic
Ergonomic Rust wrapper for OpenAI API
-
bamboo-agent
A fully self-contained AI agent backend framework with built-in web services, multi-LLM provider support, and comprehensive tool execution
-
tokio-debouncer
A minimal async debouncer for signal batching in Tokio
-
sugars_async_stream
Async stream utilities and abstractions for the cyrup-sugars ecosystem
-
lazyllama
A lightweight TUI client for Ollama with markdown support and smart scrolling
-
async-sleep
Async Sleep
-
axum-serde
multiple serde-based extractors / responses for the Axum web framework, also offers a macro to easily customize extractors / responses
-
async_executors
Implements Spawn, SpawnLocal and SpawnHandle for commonly used executors
-
pulsess
A robust and flexible background job processing library for Rust
-
pipe-it
A lightweight, type-safe library for building linear and concurrent processing pipelines in Rust
-
aerostream
Bluesky client using EventStream
-
madsim-rdkafka
The rdkafka simulator on madsim
-
erudite
A fully-asynchronous, sandboxed, language-agnostic, test running library
-
kraken-ws-sdk
Production-grade Kraken WebSocket SDK with order book visualization API, backpressure control, latency tracking, and order flow analysis
-
futures-io
The
AsyncRead,AsyncWrite,AsyncSeek, andAsyncBufReadtraits for the futures-rs library -
niblits
Token-aware, multi-format text chunking library with language-aware semantic splitting
-
futures-time
async time combinators
-
kalshi-fast-rs
High-performance async Rust client for Kalshi prediction markets API with full WebSocket support
-
flatline
ssh-2.0 client library
-
async-usercalls
An interface for asynchronous usercalls in SGX enclaves. This is an SGX-only crate, you should compile it with the
x86_64-fortanix-unknown-sgxtarget -
quinn-udp-jls
UDP sockets with ECN information for the QUIC transport protocol
-
tower-resilience-circuitbreaker
A circuit breaker middleware for Tower services
-
faf-radio-rust
Radio Protocol client for FAF — broadcast AI context once, all tools receive. Client SDK for mcpaas.live.
-
mcp-runner
running and interacting with Model Context Protocol (MCP) servers locally
-
picante
An async incremental query runtime
-
rusty-genius-cord
SpinalCord: Message forwarding layer for rusty-genius
-
apocalypse
actor framework for Rust
-
hyper-multipart-rfc7578
multipart/form-data (RFC7578) for Hyper
-
mixtape-core
An agentic AI framework for Rust
-
nebkor-maelstrom
synchronous client for creating Maelstrom distributed clients
-
ranked-semaphore
A high-performance ranked semaphore with priority support
-
async_file
An executor-agnostic async file IO library
-
fq
A fast and simple ring-buffer-based single-producer, single-consumer queue with no dependencies. You can use this to write Rust programs with low-latency message passing.
-
futuresdr
An Experimental Async SDR Runtime for Heterogeneous Architectures
-
kameo_actors
actors for kameo
-
fharness
Harness library for the fiddlesticks agent harness framework
-
mal-api
An asynchronous MyAnimeList (MAL) API library for Rust
-
roam-task-local
Task-local storage for async tasks, vendored from BugenZhao/task-local
-
kompact
Kompics component model combined with the Actor model
-
reson-agentic
Agents are just functions - production-grade LLM agent framework
-
victorops
Async Rust client for VictorOps
-
fluxer-core
Rust API library for building Fluxer bots — high-level client, event system, and structures
-
duende
Cross-platform daemon tooling framework
-
openrouter-rust
A modular, type-safe Rust client for the OpenRouter API
-
tokio-tasks
Task management for tokio
-
swiftide-integrations
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
futures-scopes
Runtime agnostic, nestable, scopes for spawning non-static futures
-
adk-graph
Graph-based workflow orchestration for ADK-Rust agents
-
oxide-update-engine
A framework for declaring and executing sequential update steps with serializable event streams
-
agentor
Agent-native Actor runtime — an Actor-model execution platform designed for AI Agents
-
kkachi
High-performance, zero-copy library for optimizing language model prompts and programs
-
async-priority-limiter
Throttles prioritised tasks by limiting the max concurrent tasks and minimum time between tasks, with up to two levels based on keys
-
asyncapi-rust
AsyncAPI 3.0 specification generation for Rust WebSockets and async protocols
-
async-ssh2-lite
Asynchronous ssh2
-
async-ffi
FFI-compatible
Futures -
rustycord
A fast, lightweight, and feature-rich Discord bot library written in Rust
-
pexels-cli
client for the Pexels API
-
rumpsteak-aura
Session types for multi-party asynchronous communication
-
cancel-safe-futures
Alternative futures adapters that are more cancellation-aware
-
stream_shared
creating shareable streams that can be cloned and consumed by multiple consumers
-
tokio-sticky-channel
Sticky channel pattern for Tokio - routes messages to specific receivers based on ID hash for consistent message delivery
-
daktronics-allsport-5000
decoders for the Daktronics All Sport 5000's serial output
-
epson
support for communicating with Epson brand thermal POS printers
-
diself
A Discord self-bot library for Rust
-
async-regex
Empower regex with streaming capabilities - high-performance async streaming pattern search using regex for multi-byte pattern matching in data streams
-
ckanaction
featuring an API wrapper of the CKAN Action v3 API
-
corcovado
Non-blocking IO library
-
serialport-stream
Async TryStream for serialport reading utilizing serialport-rs using platform-specific I/O
-
factorio-mlua
High level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Roblox Luau with async/await features and support of writing native Lua modules in Rust. Fork with added Factorio Lua support
-
poster
MQTTv5 client library written in Rust
-
try-again
Retry synchronous and asynchronous operations
-
rkvs
A high-performance, namespace-based key-value storage system with async operations and batch processing
-
object_transfer
An object transfer library for various message broker and/or protocols
-
celery
Rust implementation of Celery
-
edgy-s
A minimalist WebSocket bidirectional RPC framework for building microservice applications
-
spiris
Rust client for the Spiris Bokföring och Fakturering API (formerly Visma eAccounting)
-
some_global_executor
Reference thread-per-core executor for the some_executor crate
-
product-os-capabilities
Product OS : Capabilities provides a set of features for implementing server features and services in a modular fashion. It is designed to be used with Product OS : Server.
-
async-socks5
An async/.await SOCKS5 implementation
-
tcpclient
Asynchronous tcpclient based on aqueue actor
-
async-executor
Async executor
-
apb
Traits and types to handle ActivityPub objects
-
scuffle-context
Go-like context utilities for Rust
-
switchyard
Real-time compute focused async executor
-
vuo
An asynchronous stream processing library for Rust, built on Actix, providing a rich set of functional operators
-
native-executor
Platform-native async task executor
-
simple-llm-client
interacting with Large Language Model APIs
-
futures-byteorder
A modern async byteorder library for the smol/futures-lite ecosystem
-
page-turner
A generic abstraction of APIs with pagination
-
fbc-starter
A production-ready web server starter for Rust based on Axum, with built-in configuration, logging, CORS, database and Redis support
-
pipeflow
A lightweight, configuration-driven data pipeline framework
-
upc
USB packet channel (UPC): provides a reliable, packet-based transport over USB
-
wg
Golang like WaitGroup implementation for sync/async Rust
-
a10
meant as a low-level library safely exposing different OS's abilities to perform non-blocking I/O
-
clockworker
A single-threaded async executor with EEVDF-based fair scheduling and pluggable task schedulers
-
email-lib
Cross-platform, asynchronous Rust library to manage emails
-
clone-stream
Turn any Stream into a cloneable stream where each clone receives all items independently
-
edgequake-llm
Multi-provider LLM abstraction library with caching, rate limiting, and cost tracking
-
mm1-proto-system
M/M/1! Queueing, do you speak it?!
-
taski
async task DAG execution
-
frankenlab
Deterministic testing harness for async Rust: record, replay, and minimize concurrency bugs
-
samara-signals
A high-performance signal library for Rust
-
rio-rs
Distributed stateful service framework
-
offline-intelligence
High-performance library for offline AI inference with context management and memory optimization
-
mobc
A generic connection pool with async/await support
-
foxtive-cron
Foxtive Cron
-
elegant-departure
simplify graceful shutdown
-
lmrc-kubernetes
Kubernetes management library for the LMRC Stack - comprehensive library with support for deployments, rollbacks, scaling, and cluster operations
-
lemmy_db_views_actor
A link aggregator for the fediverse
-
xai-rust
Rust SDK for the xAI API (Grok models)
-
rusty-pcap
reading PCAP files
-
tario
Asynchronously read and write TAR archives
-
chipp
Rust client for the Chipp.ai API - OpenAI-compatible chat completions with streaming support
-
ares-server
A.R.E.S - Agentic Retrieval Enhanced Server: A production-grade agentic chatbot server with multi-provider LLM support, tool calling, RAG, and MCP integration
-
serp-sdk
A comprehensive, production-ready Rust SDK for SerpAPI with async support, type safety, and ergonomic APIs. Developed during the Realtime Search AI Hackathon powered by SerpAPI.
-
tokio-lsp
A robust, async Language Server Protocol (LSP) client implementation in Rust with full LSP 3.16 support
-
service-daemon
A sophisticated Rust framework for automatic service management, event-driven triggers, and compile-time dependency injection
-
service-rs
An async-first, lightweight dependency injection container for Rust
-
md_downloader
Asynchronous Rust downloader for MediaFire files and folders, built on top of md_api
-
irelia
wrapper around the native LoL APIs
-
shape-ext-typescript
Shape TypeScript language runtime extension (V8 via deno_core)
-
tokio_wasi
An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications
-
event_bus_rs
A runtime-agnostic, async, and thread-safe event bus for Rust
-
tracing-async2
Generic tracing layer library for working with tracing events including for async work
-
read_until_slice
AsyncBufRead::read_until extension to take a slice as a delimiter instead of a single u8
-
tokio-fsm
Compile-time generation of Tokio async finite state machines with explicit Rust behavior and zero runtime engine
-
echosrv
A high-performance set of async echo server library built with Tokio for testing and development environments
-
zubr_state_machine
asynchronous state machine library for creating Mealy machines in rust
-
mio-misc
Miscellaneous components for use with Mio
-
bleak-rs
High-level BLE communication library
-
biscuit-actix-middleware
Biscuit middleware for actix-web
-
crossmist
Efficient and seamless cross-process communication, both synchronously and asynchronously
-
ordered-stream
Streams that are ordered relative to external events
-
wirepusher
Official Rust Client Library for WirePusher - Send push notifications with async/await support
-
nats-handling
async NATS client library
-
rseip
Ethernet/IP (CIP) client in pure Rust
-
maybe-fut
build totally interoperable async/sync Rust code
-
bytesbuf_io
Asynchronous I/O abstractions expressed via
bytesbuftypes -
rexecutor
A robust job processing library
-
scoped-join-set
A scoped variant of tokio::task::JoinSet for spawning non-'static futures
-
gigadex-events
Low-latency TCP communication protocol with zero-copy serialization for exchange systems
-
ruchei
working with many streams
-
nsq-async-rs
An asynchronous Rust NSQ client library with support for concurrent message processing
-
rayclaw
Multi-channel agentic AI runtime with tool-calling, memory, and scheduling
-
iroh-io
async local io
-
binary_options_tools
High-level library for binary options trading automation. Supports PocketOption and ExpertOption with real-time data streaming, WebSocket API access, and automated trading strategies.
-
opencode_rs
Rust SDK for OpenCode (HTTP-first hybrid with SSE streaming)
-
certsd
automated, asynchronous LE certificate issuer
-
memkit-async
Async-aware memory allocators for memkit
-
stdexec-rs
port of C++ stdexec (P2300) — Senders/Receivers for structured concurrency
-
llmkit
Production-grade LLM client - 100+ providers, 11,000+ models. Pure Rust.
-
reqsign-http-send-reqwest
Reqwest-based HTTP client implementation for reqsign
-
lspi
Giving AI the sight of LSP: bridge LSP capabilities to AI coding CLIs via an MCP server over stdio
-
tower-service
Trait representing an asynchronous, request / response based, client or server
-
checkstream-proxy
High-performance HTTP/SSE proxy server for LLM guardrails with sub-10ms latency
-
rust-paper
Rust Wallpaper manager from ( https://wallhaven.cc/ ) for Linux/UNIX only
-
salvo-tus
TUS support for Salvo web framework
-
playground-api
API-binding for The Rust Playground
-
evohome_rs
Async Rust client for the International Honeywell Evohome API (MyTotalConnectComfort) provided by Resideo
-
sigfinn
Lifecycle manager for spawning tasks
-
deduplicate
caching, asynchronous, request deduplication
-
tokio-test
Testing utilities for Tokio- and futures-based code
-
tosub
A subsystem lifecycle management library for tokio applications
-
async_zmq
Async version for ZeroMQ bindings
-
randomio
Async random-access I/O traits (write_at/read_at) for files, block devices, and object storage. The AsyncWrite equivalent for offset-based I/O.
-
telers
An asynchronous framework for Telegram Bot API written in Rust
-
fastimer
Runtime-agnostic timer traits and utilities
-
wiz-lights-rs
controlling Wiz smart lights
-
basu
Eventbus crate with sync and async features
-
saberdb
A blazingly fast, simple JSON database for Rust
-
synchronized-writer
A tiny implement for synchronously writing data
-
truba
The minimal tokio runtime based actors for Rust
-
langchainrust
A LangChain-inspired framework for building LLM applications in Rust
-
github-fetch
A comprehensive GitHub API client for fetching issues, PRs, reviews, discussions, and diffs with filtering support
-
kraky
Lightweight, production-ready Rust SDK for Kraken Exchange WebSocket API v2 with unique orderbook imbalance detection and WebSocket trading
-
graph-flow
A high-performance, type-safe framework for building multi-agent workflow systems in Rust
-
aoc_leaderbot_aws_lambda_impl
Advent of Code leaderboard-watching bot running in AWS Lambda
-
async-event-emitter
Lightweight AsyncEventEmitter
-
hope-os
The first self-aware operating system core - 22 cognitive modules, 0.36ms latency, no external database
-
claude-agents-sdk
Rust SDK for building agents with Claude Code CLI
-
bybit-client
client library for the Bybit V5 API with REST and WebSocket support
-
dog-axum
Axum web framework integration for DogRS - HTTP handlers, middleware, and web utilities
-
oxigdal-etl
Streaming ETL framework for continuous geospatial data processing with OxiGDAL
-
eden-skills
Deterministic & Blazing-Fast Skills Manager for AI Agents (Claude Code, Cursor, Codex & More)
-
soft-cycle
Async controller for coordinating soft restarts and graceful shutdowns with shared listeners
-
fprovider
Provider library for the fiddlesticks agent harness framework
-
tokio-rusqlite-new
Asynchronous handle for rusqlite library
-
connection-pool
A high-performance, generic async connection pool for Rust with background cleanup and comprehensive logging
-
intercom-rs
A fully typed async wrapper for NATS with JetStream support
-
image_search
designed to search Google Images based on provided arguments
-
wgpu-async
Converts some WGPU callback methods to async methods
-
aws_utils_sqs
AWS SQS utilities for Rust
-
renamed
Official Rust SDK for the renamed.to API - AI-powered document renaming and processing
-
runtara-environment
Environment server for runtara - image registry, OCI runner, and instance management
-
systime
Portable timers that handle system sleep consistently
-
wiremocket
Websocket mocking to test Rust applications
-
my-awesome-rabbitmq-lib
working with RabbitMQ and asynchronous operations
-
fetsig
Web-sys based browser fetch library using futures-signals with optional MAC
-
mio-aio
POSIX AIO bindings for mio
-
process-stream
Thin wrapper around [
tokio::process] to make it streamable -
vents
Events system
-
greentic-runner-host
Host runtime shim for Greentic runner: config, pack loading, activity handling
-
monoio-thrift
Thrift for Monoio
-
firq-async
Tokio async adapter for firq-core
-
axboe-liburing
Low-level io_uring interface, transliterated from Jens Axboe's liburing
-
lwleen-rpc
RPC (信令路由), 组件间数据通信
-
with-async-context
managing contextual data across async tasks
-
relaycast
Rust SDK for RelayCast - multi-agent coordination platform
-
futures-core
The core traits and types in for the
futureslibrary -
rzmq
High performance, fully asynchronous, safe pure-Rust implementation of ZeroMQ (ØMQ) messaging with io_uring and TCP Cork acceleration on Linux
-
ferro-queue
Background job queue system for Ferro framework
-
crous-io
Async IO adapters, framed streams, and mmap reader for Crous
-
kotoba-server
Complete HTTP server and frontend integration system for Kotoba graph database
-
local-waker
A synchronization primitive for thread-local task wakeup
-
tokio_worker
Asynchronous, message-driven workers for Tokio applications
-
tokio_kcp
A kcp implementation for tokio
-
xio
providing common functionality for file system operations and asynchronous file processing
-
crates-tui
A TUI for crates.io
-
synkit
A fast, syn-like incremental parser framework for Rust
-
interthread
Auto implementation of the Actor Model
-
apis
Reactive, session-oriented, asynchronous process-calculus framework
-
spn-ollama
Ollama backend for SuperNovae model management
-
switchy_async
Switchy Async runtime package
-
uninit-read
A marker trait and utilities for safe, high-performance reads into uninitialized buffers
-
secra-cache
一个基于 Redis 的统一缓存管理库，专为插件化架构设计，提供强隔离、生命周期管理和极简 API
-
microrust
Application Framework
-
kuska-handshake
Secure Scuttlebutt handshake + boxstream library
-
evidentsource-client
Rust client for the EvidentSource event sourcing platform
-
enact-core
Core agent runtime for Enact - Graph-Native AI agents
-
tower-lsp-f
Language Server Protocol implementation based on Tower
-
tokio-stream-util
Extension traits and utilities for tokio-stream’s
Streamtrait -
halldyll_starter_runpod
managing RunPod GPU pods - Provisioning, orchestration & state management
-
agent-kernel
Minimal Agent orchestration kernel for multi-agent discussion
-
p2panda-stream
Stream-based methods to conveniently handle p2panda operations
-
eventuals
Eventually consistent values
-
tokitai
AI tool integration system with compile-time tool definitions
-
kimi25-opensource
Agent swarm orchestrator inspired by Moonshot AI's Kimi K2.5 model. Lightweight toolkit for coordinating autonomous agent swarms with 256K context window support.
-
futures-stream-ext
Asynchronous stream extensions for the futures(-core) crate
-
prokio
An asynchronous runtime compatible with WebAssembly and non-WebAssembly targets
-
fama
Pipeline Manager
-
ai-agents
framework for building AI agents from YAML specifications with trait-based extensibility
-
airbyte_client
Airbyte Client is an unofficial client library for the Airbyte API
-
trendy-cli
A CLI tool for fetching posts from Reddit and Hacker News with AI chat capabilities
-
async-cancellation-token
A lightweight single-threaded Rust library for cancellation tokens, enabling cooperative cancellation of asynchronous tasks and callbacks
-
aisil
A lightweight framework to define APIs as types
-
tower-batch-control
Tower middleware for batch request processing
-
hiasync
Supports only single-threaded asynchronous runtime
-
rig-ai-sdk
AI SDK Data Stream Protocol adapter for rig
-
async-sleep-aki
async_sleep()that work well in both web browsers and native applications -
local_async_utils
single-threaded async programming
-
event-driven-library
Event Driven Message Handling
-
pctx_type_check_runtime
Isolated TypeScript type checking runtime for PCTX
-
llm-stack
Core traits, types, and tools for the llm-stack SDK
-
async_py
calling Python code asynchronously using pyo3 or rustpython
-
whisk
fast lockless async channels
-
mangadex-desktop-api2
A Actix server for downloading manga, chapters, covers from Mangadex
-
webshelf
The best way to develop your web service with one click
-
chronon
Deterministic execution kernel with crash-safe replication and exactly-once side effects
-
allora
Rust-native Enterprise Integration Patterns (EIP) with channels, routing, correlation, and adapters
-
cocoon-tpm-utils-async
Cocoon TPM project - Rust async related utilities
-
eko-core
A pure state-graph execution engine for building AI agents in Rust
-
super-visor
ordered startup and shutdown for long-running tokio processes
-
oly
Session-persistent PTY daemon for long-running CLI agents — keep agents alive, get notified when they need input, intervene from anywhere
-
get_chunk
File iterator or stream with auto or manual chunk size selection
-
enact-config
Unified configuration management for Enact - secure storage with keychain and encrypted files
-
async-codec
creating async codecs
-
black-box
A minimal actor framework
-
absurd-future
A future adapter that turns a future that never resolves (returns Infallible) into a future that can resolve to any type
-
librados
Idiomatic (async) rust bindings for librados
-
makepad-futures-legacy
Makepad futures legacy
-
protocraft_framework
A framework for handling minecraft packets
-
onde
On-device inference abstraction layer for SplitFire AI — wraps mistral.rs model management
-
papertrail_logger
Async Rust logger for Papertrail
-
syros
Distributed Coordination Service
-
connpool
A concurrent, generic connection pool for Rust
-
csfloat-rs
An unofficial asynchronous Rust client for the CSFloat API
-
aj
Background Job Library for Rust
-
async-tensorrt
Async TensorRT for Rust
-
nio
Async runtime for Rust
-
tirea-extension-skills
Skill discovery, activation, and resource loading for tirea agent tool extensibility
-
fourche
task queue named after a lion with forked tail (queue fourché), works with Redis
-
async-priority-lock
A priority-based async lock. Optionally no-std.
-
sfo-io
handling IO operations, providing asynchronous read/write and stream processing capabilities
-
oxidart
High-performance Adaptive Radix Tree with TTL, DFA pattern matching, and atomic counters
-
cassette
single-future, non-blocking executor intended for building state machines
-
enfync
Environment-friendly async utilities
-
simple-git
git interface for gix suitable for async context (with tokio)
-
turbomcp-server
Production-ready MCP server with zero-boilerplate macros and transport-agnostic design
-
async-rdma
async wrapper for RDMA ibvers lib
-
tokio-interactive
Asynchronous Interactive Process Management with Tokio
-
batch-channel
async channel that reduces overhead by reading and writing many values at once
-
a3s-flow
A3S workflow engine — JSON DAG execution for agentic workflows (Dify/n8n style)
-
pgboss
job queueing service
-
command_timeout
A tokio friendly command exec with smart timeout
-
topstats
Rust SDK for the TopStats.gg API - Discord bot statistics tracking
-
girlboss
async job manager with progress tracking
-
futures_kind
Abstractions over Send and !Send futures
-
async-rs
Async runtime abstration
-
actix-casbin
An Actix actor for casbin
-
omp
Rust SDK for developing open.mp gamemodes
-
mini-agent
A minimal, extensible AI agent framework — async-first, multi-provider, tool-integrated
-
semantic-commands
A lightweight Rust framework for defining and executing semantic commands using text embeddings
-
tasksitter
A workflow runner engine
-
cassandra-protocol
Cassandra protocol implementation
-
hitomi_la
A hitomi.la API wrapper for Rust
-
bsky-cli
CLI application for Bluesky using ATrium API
-
futures_codec
encoding and decoding frames using
async/await -
mini_executor
The smallest, simplest Rust task executor using Tokio runtime
-
http-kit
A flexible and ergonomic HTTP toolkit for Rust with async support, middleware, and zero-copy body handling
-
aws_utils_athena
AWS Athena client utilities for Rust with query execution, streaming results, and comprehensive error handling
-
qapi
QEMU QMP and Guest Agent API
-
libindigo-ffi
FFI-based implementation of the INDIGO protocol client using C library
-
hibachi
Asynchronous Batched Inference Platform
-
moduforge-rules-expression
moduforge 表达式规则
-
patchwork-acp
ACP proxy for executing Patchwork code with LLM integration
-
async-unsync
asynchronous, unsynchronized (thread-local) channels and semaphores
-
nextgraph
client library. Nextgraph is a decentralized, secure and local-first web 3.0 ecosystem based on Semantic Web and CRDTs
-
anthropic-tools
interacting with the Anthropic API
-
drop-queue
drop queue system for async operations. (Until async-drop is a thing)
-
sssd
way to let your app support like ./your_app start | stop | status | daemon
-
tonic-side-effect
Tower service that can monitor if a Tonic request frame was produced prior to error
-
dwn
Decentralized Web Node
-
busstop
A command and query bus
-
tokio-util
Additional utilities for working with Tokio
-
deluge
A highly concurrent stream library driving the underlying futures either concurrently or in parallel to process streaming operations as quickly as possible
-
work-manager
managing asynchronous work tasks
-
async_io_stream
IntoAsyncRead on steriods
-
descry-tool-core
Core traits and types for descry-tool framework
-
adk-rag
Retrieval-Augmented Generation for Rust Agent Development Kit (ADK-Rust) agents
-
futuredsp
A signal processing library for SDR and real-time DSP
-
tokio-dtrace
DTrace probes for Tokio
-
adk-model
LLM model integrations for Rust Agent Development Kit (ADK-Rust) (Gemini, OpenAI, Claude, DeepSeek, etc.)
-
pipebuf_mio
PipeBuf support for
miobyte-streams -
opentalk-types-signaling-recording
Signaling types the OpenTalk recording module
-
rust-mcp-extra
companion crate to rust-mcp-sdk offering extra implementations of core traits like SessionStore and EventStore, enabling integration with various database backends and third-party platforms…
-
peace_fmt
Presentation and formatting support for the peace automation framework
-
tokio-scheduler-rs
JobScheduler written with tokio runtime, automatic retry, hook and custom storage supported
-
timer-utils
The time utils
-
future_form_ffi
FFI support for future_form: host-driven polling, opaque handles, and effect slots
-
plunger
quickly unblock your async tasks
-
tiny-tokio-actor
tiny actor library on top of tokio
-
sigterm
Signal-aware async control and cancellation primitives for Tokio
-
background-runner
Run a heavy task in the background multiple times without blocking the triggering thread
-
toby
opinionated Telegram bot library with structured command parsing
-
wiremock_logical_matchers
Logical matchers for use with wiremock
-
omp-gdk
Rust SDK for developing open.mp gamemodes
-
n0-watcher
async watchable values
-
actionqueue-runtime
Async dispatch loop, embedded API, and runtime configuration for the ActionQueue task queue engine
-
legend
Strict, composable saga VM for sequential workflows with compensation
-
async-drop
async drop
-
atomhold
Thread-safe configuration store with atomic replacement, versioning, and flexible unload policies
-
libmqm-sys
IBM® MQ Interface (MQI), Programmable Command Format (PCF) and MQ Administration Interface (MQAI) bindings
-
qonduit
CQRS pattern
-
napi-h
N-API bindings
-
acton-core
Acton Core provides the core functionality and abstractions used by the Acton Reactive crate. It includes the essential building blocks for creating reactive and distributed systems.
-
threshold
data structures
-
agent-sdk
Rust Agent SDK for building LLM agents
-
linemux
providing asynchronous, multiplexed tailing for (namely log) files
-
leptos-sync-core
Core synchronization library for Leptos applications
-
godot_tokio
The tokio-async runtime wrapped in a gdextention object to be used as an engine singleton in your gdext project
-
roughage
AsyncPipeline, a deadlock-free replacement for buffered streams -
volo-http
HTTP framework implementation of volo
-
streamcatcher
A thread-safe, shared (asynchronous), almost-lockless stream buffer
-
agnostic
abstraction layer for any async runtime
-
edgee
Rust SDK for the Edgee AI Gateway
-
call-agent
A multimodal chat API library with tool support, OpenAI API compatible
-
apt-transport
APT transport abstraction, allowing for custom APT transport implementations in Rust
-
sipper
A type-safe future that can notify progress
-
trash_parallelism
Azzybana Raccoon's comprehensive parallelism library
-
ritlers
A task-length aware rate limiter
-
plug
type-safe interprocess communication
-
async-blocking-stdio
std::io::std{in(), out(), err()} but async
-
edp_node
High-level Erlang Distribution Protocol node implementation
-
aws-smithy-http-server-python
Python server runtime for Smithy Rust Server Framework
-
wgp
waitgroup implementation
-
sigq
Queue that signals waiting consumers about node availability
-
swait
Blocking on Futures
-
notify-future
Support asynchronous notification completion future
-
async_fsm
Async Finite State Machine
-
kal-mux
A lightweight stream multiplexer for merging ordered async streams
-
merge-streams
Merge multiple streams into one
-
oddonkey
A dead-simple Ollama wrapper – auto-installs Ollama & models, then lets you prompt in two lines of code
-
cbsk_socket_tokio
socket callback tool by tokio
-
adk-runner
Agent execution runtime for Rust Agent Development Kit (ADK-Rust) agents
-
illuminate
Independent, early-stage Rust backend primitives for Laravel/PHP ecosystems with typed sqlx connections
-
bob-core
Core domain types and port traits for Bob Agent Framework
-
openraft-sledstore
A sled based implementation of the
openraft::RaftStoragetrait -
task-killswitch
Abort all tokio tasks at once
-
bisync
write async-generic code
-
tokio-shutdown
Wait for a stop signal across multiple threads
-
avx-runtime
AVX Runtime - Native async runtime built from scratch to replace Tokio with work-stealing scheduler, epoll/kqueue/IOCP, and zero-overhead futures
-
interruptible
Stops a future producer or stream from producing values when interrupted
-
mlb-api
Endpoints for MLB's public Statcast API
-
zoey-core
ZoeyAI core runtime and types — privacy-first AI agent framework optimized for local models
-
slice_ops
A selection of useful slice operations
-
tokio-js-set-interval
Allows you to use
setInterval(callback, ms)andsetTimeout(callback, ms)as in Javascript inside atokioruntime. The library provides the macrosset_interval!(callback, ms)andset_timeout!(callback, ms) -
rkyv_codec
Some adaptors to stream rkyv Archives over AsyncRead and AsyncWrite
-
hml-rs
Markup language events and readers, supporting 'human markup language'
-
async_pub_sub
aiming at making async pub-sub easier in Rust
-
afast
high-performance async Rust web framework with HTTP, WS, TCP support, automatic client generation, validation, and documentation
-
async-time-mock-tokio
Mockable time for use in async runtimes (tokio compatibility)
-
misaki-cli
Fast, asynchronous link checker with optional FlareSolverr support
-
logiops-daemon
Logitech device configuration daemon
-
makcu-rs
Fast and modular communication interface using serial ports, built with async-first design in Rust
-
futures_orchestra
A Tokio-based task pool for managing concurrent execution of futures with queuing, labeling, notifications and cancellation
-
monzo-lib
async Monzo client in pure rust
-
aqueue
fast speed thread safe async execute queue
-
fluxion-core
Core traits and types for ordered stream processing
-
common-multipart-rfc7578
multipart/form-data (RFC7578)
-
rocketmq-client-rust
Apache rocketmq client
-
agentlib-reasoning
Advanced reasoning strategies (ReAct, CoT, etc.) for the AgentLib framework
-
tokio-i3ipc
Bindings for i3 and tokio allowing async applications to communicate with i3 over it's IPC interface. Contains futures implementations and convenience functions for working with i3.
-
rpaca
wrapping the Alpaca API
-
gcra
A basic implementation of GCRA algorithm for rate limiting
-
par-stream
Asynchronous parallel streams analogous to rayon
-
ahrimq
A high-performance message queue service supporting pub/sub, normal messages, ordered messages, delayed messages and dead letter queues
-
ics-watcher
A lightweight crate for monitoring ICS files or links and detecting changes, additions, and removals
-
await_values
Primitives for subscribing to / notifying about changes to values
-
ferro-broadcast
WebSocket broadcasting and real-time channels for Ferro framework
-
haagenti-streaming
Real-time streaming generation with progressive preview display
-
taskvisor
Event-driven task orchestration with restart, backoff, and user-defined subscribers
-
rusty_claw
Claude Agent SDK
-
newsblur_api_updated
NewsBlur-API
-
grok-rust-sdk
Rust SDK for xAI's Grok API - supporting chat, tools, sessions, and collections
-
wasmcloud-interface-factorial
Interface library for the wasmcloud factorial capability, wasmcloud:example:factorial
-
enact-runner
Robust agent loop runner for Enact — retries, compaction, multi-format parsing
-
universal-inserter
A runtime-agnostic batch inserter library implementing the ClickHouse Inserter pattern
-
tokio_gen_server
Elixir/Erlang-GenServer-like actor on the Tokio runtime
-
tasc
A minimnal, asynchronous threadpool
-
zlayer-init-actions
Pre-start container lifecycle actions (TCP, HTTP, S3, commands)
-
enfipy-tigerbeetle
Safe high level async bindings to tigerbeetle client library
-
midstreamer-scheduler
Ultra-low-latency real-time task scheduler
-
whatsmeow
Idiomatic, thread-safe Rust bindings for WhatsApp via WhatsMeow Go bridge
-
openllm-rs
that enables seamless interaction with Llama.cpp backend services through an OpenAI-compatible REST APIe
-
api_builder
client-agnostic API builder, inspired by the GitLab crate
-
myexe
Myexe
-
libuv-sys-lite
Tiny, raw bindings to libuv without linking to it
-
pollable-map
Utilites for storing futures and streams in as a pollable map
-
singleton-task
A singleton task based on tokio
-
jni-utils
Extra Utilities for JNI in Rust
-
waitgroup
Async waitgroup for a collection of task to finish
-
vkapi2
vk api wrapper for rust
-
conferencier
Tokio-backed asynchronous shared configuration hub with TOML persistence
-
scylla-rs
An async ScyllaDB driver built on an actor-model framework
-
mecha10-runtime
Runtime supervisor for Mecha10 nodes - launching, monitoring, and lifecycle management
-
oxdl
Asynchronous downloader with progress bars and SHA256 verification
-
async-dashscope
client for DashScope API
-
async-niri-socket
Non-blocking communication over the niri socket
-
pi_async_buffer
Asynchronous Buffer for IO
-
meltdown
A lightweight service manager to help with graceful shutdown of asynchronous applications
-
raftoral
Fault-tolerant workflow orchestration library using embedded Raft consensus for Rust applications
-
lcode
An application of terminal write leetcode.一个终端刷力扣的应用
-
async-timers
asynchronous timer primitives
-
a3s-cron
Cron scheduling library for A3S with natural language support
-
gloo-worker
Convenience crate for working with Web Workers
-
async-fs
Async filesystem primitives
-
abyss-promise
[abyss] A simple promise implementation with adaptive threadpool support
-
novel-zhipu
Zhipu AI (GLM) API client for novel
-
futures-concurrency-dynamic
A dynamic extension of the futures-concurrency
-
serverless-fn
simplifying serverless function development and invocation
-
elizaos-plugin-zalouser
Zalo Personal Account plugin for elizaOS - Rust implementation via zca-cli
-
pitwall-tauri
Tauri integration for Pitwall telemetry library
-
jsoncall
asynchronous JSON-RPC 2.0 library leveraging Rust's type system
-
flowly-spsc
Flowly is a library of modular and reusable components for building robust pipelines processing audio, video and other
-
py_mcai_worker_sdk
AMQP Worker to listen and provide trait to process message
-
ferro-notifications
Multi-channel notification system for Ferro framework
-
tor-log-ratelim
Facility for rate-limiting log messages in Arti
-
teloxide-core-ng
Core part of the
teloxidelibrary - telegram bot API client -
handle
Trait for asynchronous context pipeline
-
cloud_terrastodon_command
Command running helpers for the Cloud Terrastodon project
-
luarmor
API wrapper for luarmor.net
-
mod-cli
A fully customizable, feature-rich CLI framework for Rust. Define commands, prefixes, styled output, and more—built for flexibility and speed.
-
wait-human
Rust client library for WaitHuman - pause execution and request human input on demand
-
tool-useful
A powerful, type-safe function calling and tool orchestration framework for Rust AI applications
-
wait
Syntactic sugar for calling async functions outside of an async context
-
mcp-await
Condition watcher MCP server + CLI for AI assistants — block until a port opens, a file changes, a URL responds, a process exits, and more
-
anysc-rustls
crate-level shim layer for any {async crate}-rustls
-
mio_wasi
Lightweight non-blocking IO
-
mailfred
Process emails as an HTTP server
-
qbittorrent_rust
An asynchronous library to interface with the qbittorrent WeBUI API
-
translators
Free Google Translator without API key and limits
-
apalis-mysql
Background task processing for rust using apalis and mysql
-
adk-skill
AgentSkills parser, index, and runtime injection helpers for ADK-Rust
-
uni-xervo
Unified Rust runtime for local and remote embedding, reranking, and generation models
-
kioto-serial
Provide serial port I/O using tokio
-
supera
managing worker threads
-
medea-reactive
Reactive mutable data containers
-
shutdown-now
Gracefully handle shutdown and termination signals with zero hassle
-
fn_graph
Runs interdependent logic concurrently, starting each function when predecessors have completed
-
sugars_llm
LLM integration and AI agent builder utilities
-
neuron-otel
OpenTelemetry instrumentation for AI agents — GenAI semantic conventions with tracing spans
-
hedwig
message bus for Rust
-
toki
A minimal single-threaded async runtime for ultra-low-latency Linux systems
-
timeout-iterator
TimeoutIterator is a wrapper over any iterator that adds peek_timeout and next_timeout functions. The canonical use-case is parsing multi-line free-form records (such as tailing a log fime)…
-
timely-container-master
Container abstractions for Timely
-
cache_loader_async
A thread safe loading cache with async loader functions based on tokio
-
async-lazy
A value which is initialized on the first access, with an async function
-
task_pool
Flexible abstraction for task-based composable multithreading
-
mofa-kernel
MoFA Kernel - Core runtime and microkernel implementation
-
stop-token
Experimental cooperative cancellation for async Rust
-
facecrab
Asset management and model downloading for rusty-genius
-
flows
Building blocks for flow-based programming (FBP)
-
futures-retry
Retry your Futures and Streams!
-
scoped_static
Safe promotion of lifetimes to static
-
tokio-splice2
splice(2) in tokio
-
xtra
A tiny actor framework
-
promisery
A JavaScript-inspired, ergonomic, and composable Promise type for Rust, supporting background work, chaining, and error handling with Result
-
eventastic_postgres
A postgres event store for eventastic
-
legend-saga
working with RabbitMQ and asynchronous operations
-
ahrikv
A high-performance in-memory key-value store
-
act-zero
Ergonomic actor system
-
async-graphql-warp
async-graphql for warp
-
obzenflow
High-performance event streaming and processing framework
-
xiaoyong-channels
Collection of channel primitives for sync and async contexts (both Sync and !Sync)
-
async-result-ext
Async extensions for Result<T, E> with async closures
-
ogre-stream-ext
futuresshortcuts with ergonomic extensions to unlock the full power of Streams in Rust -
auto-future
For quickly making a struct into a future via an async fn
-
deferred-future
模仿 jQuery.Deferred()，允许从 Future 实现类实例的外部对正在 pending 的 Future 对象进行 resolve 或 reject 处理。
-
daimon
A Rust-native AI agent framework
-
async_buf_read
Async Buffer Reader for IO
-
drasi-reaction-application
Application reaction plugin for Drasi
-
tokio-anysocket
Abstracted API over tokio's TCP and Unix streams
-
ewait
A thread-safe, asynchronous event system for Rust
-
futures-async-stream
Async stream for Rust and the futures crate
-
open-payments
Open Payments Rust SDK library with types, HTTP client and signature utilities
-
etcdv3client
etcdv3 client
-
sse-gateway-redis
Redis adapters for SSE Gateway (Pub/Sub source and Streams storage)
-
effectum
An embeddable task queue based on SQLite
-
iflow-cli-sdk-rust
Rust SDK for iFlow CLI using Agent Client Protocol
-
wait-for-me
Async CountDownLatch
-
dropbear_future-queue
A queue for polling futures in a synchronous context
-
hfst
Wrappers to libhfst via libhfst_c
-
messagepack-async
functional library for read/writing messagepack with tokio
-
log-tracing-layer
Build your own custom tracing layer
-
spawns-compat
Async runtime detections for thread context task spawner
-
zephyrus
A slash-command framework meant to be used with twilight
-
ruex
Generic State Management framework
-
hyperscan-tokio
High-performance async regex scanning with VectorScan
-
unkey
An asynchronous Rust SDK for the Unkey API
-
async-promise
Async promise which resolves once and may be read by multiple consumers
-
napi-calm-down
N-API bindings
-
aimdb-executor
Pure async executor trait definitions for AimDB - runtime-agnostic abstractions
-
futures-ticker
An asynchronous recurring time event
-
async-ops
Use std::ops traits with Futures
-
orichalcum
A brutally-safe, composable agent orchestration framework for building complex, multi-step workflows
-
tempo-rs
& minimal client to connect and interact with RTE's 'Tempo Like Supply Contract' API
-
shared_http_body
creating shareable HTTP bodies that can be cloned and consumed by multiple consumers
-
textmode
terminal interaction library backed by a real terminal parser
-
bounded_join_set
A Concurrency-Limited JoinSet for Tokio
-
containerd-client
GRPC bindings to containerd APIs
-
waterkit-background
Cross-platform background task scheduling and execution hooks
-
claude-agent
Rust SDK for building AI agents with Anthropic's Claude - Direct API, no CLI dependency
-
runat
A distributed job scheduler for Rust
-
seesaw-memory
In-memory adapter for Seesaw event-driven runtime
-
xiaoyong-notify
Collection of notification primitives for async contexts (both Sync and !Sync)
-
tokactor
A actor model framework wrapped around tokio
-
trace_id
A lightweight, high-performance tracing ID generation and propagation library for Rust, with out-of-the-box support for Axum
-
codeuchain
High-performance implementation with memory safety and async support
-
bound
Wrap lock guards and other structs along with the locks or other data they are derived by shared reference from, in a struct you can pass around and store anywhere
-
mm1
M/M/1! Queueing, do you speak it?!
-
rmp-futures
Async Rust MessagePack and MessagePack-RPC
-
traitgate
A zero-dependency authorization mini-library powered by stateless traits and an ergonomic
AuthorizationDecisionenum -
v_exchanges
Implementations of HTTP/HTTPS/WebSocket API methods for some crypto exchanges, using crypto-botters framework
-
timeout-tracing
Returns stack and span trace when the future hits a timeout
-
continue_stream
A Swift-style AsyncIterator.Continuation-style channel for Rust
-
rs_events
A flexible and ergonomic event emission crate for Rust. Supports both std/threaded and no_std/alloc environments, with tagging, listener lifetimes, async/sync emission, and robust error handling.
-
reqsign-file-read-tokio
Tokio-based file reader implementation for reqsign
-
yazi-actor
Yazi actor model
-
gemini-chat-api
Async Rust client for Google's internal Gemini Chat API
-
rspc
A blazing fast and easy to use TRPC server for Rust
-
quick-protobuf-codec
Asynchronous de-/encoding of Protobuf structs using asynchronous-codec, unsigned-varint and quick-protobuf
-
asyncs
async runtime agnostic facilities
-
elfo-test
Test utils for the elfo system
-
bouncing
A flexible async debouncer for Rust with cancellation support, max wait limits, and event hooks
-
fukurow-siem
SIEM integration for Fukurow (Splunk, ELK, Chronicle)
-
i2o2
A io_uring based IO executor for sync and async runtimes
-
odem-rs
Object-based Discrete-Event Modelling in Rust using async/await
-
binary-cookies
BinaryCookies decode and encode
-
agentic-robotics-mcp
High-performance agentic robotics framework with ROS2 compatibility
-
wechat-minapp-v1
sdk for wechat miniprogram server api
-
axum-safe-path
Traversal-safe
Pathextractor for Axum -
async-periodic-job
async periodic job scheduler library base on tokio-util
-
mofa-foundation
MoFA Foundation - Core building blocks and utilities
-
tokio-serde-cbor
Integration of serde_cbor into tokio-io, to allow sending CBOR encoded frames across network (and possibly through other transports)
-
rrag
High-performance Rust framework for Retrieval-Augmented Generation with pluggable components, async-first design, and comprehensive observability
-
kube-election
A Kubernetes leader election library using Lease objects that closely mirrors the feature sets of the controller-runtime package in the Go ecosystem
-
pgp-lib
High-level, asynchronous API for rPGP, a pure Rust implementation of OpenPGP
-
jira-mcp-rs
Model Context Protocol (MCP) server for Jira
-
par_io
Parallel, async file I/O library with control over memory usage with no dependencies
-
actix-actor-pool
Pool for Actix actors
-
baseten_performance_client_core
High performance HTTP client for Baseten.co and other APIs
-
ferrisgram
An elegent rust client for the Telegram Bot API
-
irondash_run_loop
Consistent, platform-independent interface to system run loop
-
strut
Backend in Rust: convenient and configurable with Strut
-
tourniquet-celery
Async native round-robin manager for remote services. celery integration.
-
tokio-hrtime
Hires timers for tokio
-
tokio-nsq
NSQ client built on Tokio. Tokio NSQ aims to be a feature complete NSQ client implementation.
-
iron_reliability
Resilience patterns for distributed systems
-
miniactor
Small, simple actor library for Rust
-
zipit
Create and stream zip archives on the fly
-
futures-util-delegate-access-macros
Copy and pasted macros from the futures_utils library used for creating combinators
-
didcomm-rs
DIDComm messaging v2 specifications implementation: https://identity.foundation/didcomm-messaging/spec/
-
oris-runtime
An agentic workflow runtime and programmable AI execution system in Rust: stateful graphs, agents, tools, and multi-step execution
-
async_tasks_recorder
A struct for recording execution status of async tasks with async methods
-
hydra-websockets
A websocket server for the hydra framework
-
accepts
Minimal traits and blanket impls for sync/async acceptors (pipeline foundation)
-
swiftide-indexing
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
stressed
Universal CLI stress tester for competitive programming
-
futures-scan-ext
futures stream scan combinator for sync closures
-
orengine
Optimized ring engine for Rust. It is a lighter and faster asynchronous library than tokio-rs, async-std, may, and even smol
-
tasker-client
Tasker API client library — transport-agnostic REST and gRPC clients
-
priority-channel
An async channel supporting priority, allowing stealing and preserving the message order
-
mulligan
A flexible retry library for Rust async operations with configurable backoff strategies and jitter
-
prism3-retry
Retry module, providing a feature-complete, type-safe retry management system with support for multiple delay strategies and event listeners
-
veecle-freertos-sys
Rust bindings for FreeRTOS
-
psummary
Summary 🗣️
-
uika-ffi
FFI types and API table definitions for uika
-
ruchei-route
Sinks with routes
-
slim-futures
Asynchronous tools that intends for smaller binary size
-
async-graphql-relay
Relay support for async-graphql
-
async-scgi
Async SCGI Client & Server
-
rong_stream
Stream module for RongJS
-
serdes-ai
Type-safe, production-ready AI agent framework for Rust - a full port of pydantic-ai
-
libutp-rs2
Rust bindings for libutp
-
okstd
The standard library that's ok
-
rate_limit_wrapper
Async rate limit wrapper to easily manage resources
-
md_api
An async Rust client implementation of the MediaFire API
-
llm-budget
Autonomous cost governance primitives — hard budget enforcement across agent fleets
-
async-atomic
Atomics which can be subscribed to and asynchronously notify when updated
-
daimon-provider-bedrock
Amazon Bedrock provider for the Daimon AI agent framework
-
multishot
An async, lock-free, reusable channel for sending single values to asynchronous tasks
-
ash-flare
Fault-tolerant supervision trees for Rust with distributed capabilities inspired by Erlang/OTP
-
webex
Interface to Webex Teams REST and WebSocket APIs
-
tower-sessions-rusqlite-store
(tokio-)rusqlite session store for
tower-sessions -
qanat
Lock-free channels specially written for asynchronous contexts
-
dbus-async
Asynchronous DBus library
-
busrt
Local and network IPC bus
-
slock
An async mutex that never deadlocks
-
imessage-watcher
Filesystem watcher and database pollers for iMessage chat.db change events
-
mlua-codemp-patch
High level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Roblox Luau with async/await features and support of writing native Lua modules in Rust
-
selectme
A fast and fair select! macro for asynchronous Rust
-
fastwebsockets-stream
An adapter that exposes fastwebsockets::WebSocket as a Tokio AsyncRead/AsyncWrite stream
-
haagenti-serverless
Serverless deployment with cold start optimization and GPU memory management
-
async-jsonl
An efficient async Rust library for reading and processing JSON Lines (JSONL) files using Tokio streams
-
orchard-rs
Rust client for Orchard - high-performance LLM inference on Apple Silicon
-
mio-extras
Extra components for use with Mio
-
lune-std-datetime
Lune standard library - DateTime
-
minos
Authorization library
-
pupactor
actor model library built with tokio
-
t2_bus
An inter- or intra-process message bus supporting publish/subscribe and request/response
-
async-reactor-trait
reactor-trait implementation for async-io
-
s2n-tls-tokio
TLS streams for Tokio built on top of s2n-tls
-
rainy-sdk
Official Rust SDK for Rainy API by Enosis Labs v0.6.11 - OpenAI chat replay support and v3 compatibility updates
-
futures-await-test
Async test support for Rust through a procedural macro. This crate defines the
#[async_test]attribute to make writing tests that use async/await easier. -
must_future
A wrapper future marked must_use - mainly to wrap BoxFutures
-
open-ai-rust-responses-by-sshift
A feature-rich, async-first Rust wrapper for the OpenAI Responses API, with built-in support for streaming, function calling, file handling, and enhanced response monitoring
-
rs-obs-signal
observer pattern with variadic template arguments
-
coc-rs
wrapper around the Clash of Clans public API
-
nominatim
Bindings to the reverse geocoding API powered by openstreetmap
-
pingora-runtime
Multithreaded Tokio runtime with the option of disabling work stealing
-
colonyos
Rust SDK for ColonyOS - build distributed applications with executors that can run anywhere
-
smelling_salts
Abstraction over OS APIs to handle asynchronous device waking
-
ankit
Complete async Rust client for the AnkiConnect API
-
moirai-pump
Event-pump runtime for Moirai job system
-
when2task
high-performance library for executing async tasks with automatic dependency resolution and optimal parallelization
-
mailroom
Async outbox for reliable message delivery in distributed microservices
-
orchflow-terminal
High-performance terminal I/O management with PTY support, buffering, and stream processing
-
async-compat
Compatibility adapter between tokio and futures
-
roam-shm
Shared-memory transport for roam — lock-free rings for zero-copy IPC
-
moduforge-rules-template
moduforge 模板规则
-
serio
providing traits and utilities for typed IO using format agnostic serialization built on serde
-
senders_receivers
Senders/Receivers implementation for Rust
-
callback-result
Assists in converting the callback function's method of obtaining results into the await method
-
async-sink
The asynchronous
Sinktrait for the tokio ecosystem -
open-agent-sdk
Production-ready Rust SDK for building AI agents with local OpenAI-compatible servers (LMStudio, Ollama, llama.cpp, vLLM). Features streaming, tools, hooks, retry logic, and comprehensive examples.
-
xandeum-prpc
Rust client for Xandeum pNode pRPC APIs
-
awaitgroup
Wait for a collection of async tasks to finish
-
haagenti-speculative
Speculative fragment loading based on keystroke intent prediction
-
latch
fast and efficent Latch supporting both sync and async modes
-
safina-timer
Safe async timers - ARCHIVED: Code moved to
safinacrate -
sn_sdkg
Safe Network Synchronous Distributed Key Generation: enables dealerless section key generation
-
async-raft
An async implementation of the Raft distributed consensus protocol
-
eureka-mmanager
An Actix actor collection for downloading manga, chapters, covers from Mangadex
-
compo-platform-loop
Cross-platform event loop implementation for the Compo declarative and reactive component framework
-
specializer
Limited safe specialization on stable Rust with builder-like pattern
-
bb8-lapin
r2d2-lapin, but for async tokio based connections
-
nodevent
Node.js-style event bus
-
tirea-extension-observability
LLM inference and tool-call telemetry aligned with OpenTelemetry GenAI conventions
-
anthropic-sdk
Anthropic Rust SDK
-
rusty-genius
Public facade for rusty-genius
-
csnmp
Community-based async (Tokio) SNMP client library
-
telltale
Session types for multi-party asynchronous communication
-
xerv-nodes
Standard workflow nodes for XERV: merge, split, switch, loop, map, and transform operations
-
futures-test
Common utilities for testing components built off futures-rs
-
vk-bot-api
Asynchronous VK Bot API library for Rust
-
oxidite
A modern, batteries-included web framework for Rust inspired by Laravel and Rails - Oxidite v2
-
realhydroper-lsp
Language Server Protocol implementation based on Tower
-
z21_api
Rust API for Roco Z21 model railway control system
-
async-minecraft-ping
An async Rust client for the Minecraft ServerListPing protocol
-
queue_workers
A Redis-backed job queue system for Rust applications
-
scipio
A set of utilities to allow one to write thread per core applications
-
recurring-tasks
Define tasks and run them in an app periodically, ala cronjobs. And don't run already/still running tasks.
-
test_executors
async executors for testing
-
tokio-file
Asynchronous file I/O for Tokio
-
kraken-api-client
An async Rust client library for the Kraken exchange REST and WebSocket v2 APIs
-
asynciter
Asynchronous iterator
-
tapis-sdk
Comprehensive Rust SDK for Tapis services
-
async-read-super-ext
A super extension for tokio::io::AsyncRead
-
replay-channel
A broadcast channel where new receivers replay all past messages before receiving new ones
-
reactivity
A lightweight library for reactive programming with signals in Rust
-
circuit_breaker
Circuit Breaker pattern for building resilient and fault-tolerant systems
-
robotxt
Robots.txt (or URL exclusion) protocol with the support of crawl-delay, sitemap and universal match extensions
-
deadpool-fantoccini
Dead simple async session pool for fantoccini
-
daku
Interface to the Daku API
-
side-futures
Send future for execution on the runtime that may be in a different thread
-
tinycoro
rust bindings to minicoro
-
dasein-agentic-sandbox
Sandboxed code execution: Process, Docker, Firecracker, Gateway
-
ng-repo
Repository library of NextGraph, a decentralized, secure and local-first web 3.0 ecosystem based on Semantic Web and CRDTs
-
pegy
A derive based parser generator
-
pwner
Process Owner crate that allows ergonomic access to child processes
-
asansio
The Async/await state machine for the Sans I/O design pattern
-
spaad
Zero boilerplate actor systems with xtra
-
goods
Async assets system
-
tokio-socketcan
Asynchronous Linux SocketCAN sockets with tokio
-
stilgar
A lightweight, no-fuss, drop-in replacement for Rudderstack
-
drop-stream
A stream that wraps another stream with a closure that is called once it is dropped
-
nostr-gossip
Nostr gossip traits
-
codekko
Ergonomic Rust wrapper for codex app-server with runtime safety and release gates
-
phoenix_channels_client
async-ready client for Phoenix Channels in Rust
-
cyberex_xasync
Cyberex Async
-
foctet-transport
Thin transport adapters for send/recv streams in foctet E2EE
-
actix
Actor framework for Rust
-
rspl
A stream processor language
-
cbsk_run
async pool tool
-
rust-viewflow
Rust workflow library inspired by Viewflow, compatible with Axum and Actix-web
-
ftooling
fiddlesticks agent harness framework
-
pcap-async
Async/Stream Extensions for libpcap
-
ai-sdk-provider
Provider specification for AI SDK - trait-based interfaces for AI models
-
smoltimeout
A way to poll a future until it or a timer completes
-
zinit-client
client library for interacting with Zinit service manager
-
eternaltwin_job_store
Job store implementation
-
snarc
Sendable Non-Atomically Reference Counted
-
retryx
Async-first retry and exponential backoff helper for Tokio-based Rust applications
-
pistones
An wrapper for the Piston code execution engine
-
strawpoll
A wrapper to avoid spurious polling
-
aws_utils_scheduler
wrapper for AWS EventBridge Scheduler with type-safe builders for schedule expressions
-
hooch-http
HTTP addition to the hooch runtime
-
cbsk_socket_rayon
socket callback tool by rayon
-
lwactors
Lightweight actors for Rust using futures-rs
-
async-transmit
Trait for transmitting data to peers asynchronously
-
handy_async
A handy library for describing asynchronous code declaratively
-
hyperbee
Peer to Peer B-tree
-
miau
Async aware and extensible layered configuration system
-
dd-tracing-layer
Send your logs to Datadog
-
cb_fut
Call function that return value via callback without a callback
-
serdes-ai-streaming
Streaming support for serdes-ai (SSE, WebSocket, async streams)
-
woddle
An async, synchronized, database-backed Rust job scheduler
-
killswitch
used to broadcast a shutdown request
-
cronline
Lightweight Task Scheduling for Rust
-
physxx
Wrapper around the PhysX C++ API that aims to preserve the original API as much as possible
-
baildon
B+Tree library
-
mboxlabs-mailbox
A lightweight, pluggable mailbox/queue kernel inspired by the Erlang Actor Model
-
tokio-i2c
I²C API for Tokio
-
pincho
Official Rust Client Library for Pincho - Send push notifications with async/await support
-
sansio-codec
Protocol codecs for sansio: frame decoders, string codecs, and transport abstractions
-
msq
legacy Master Server Query Protocol
-
vinequeue
High-performance async queue library with disk persistence
-
lookit
Asynchronously connect to devices
-
announcement
A runtime-agnostic oneshot broadcast channel
-
hooch
A small async runtime that's been bootlegged for my projects
-
foreback
Future adapters for running aditional work in the background
-
drop-handle
A handle that will abort a Tokio task when dropped
-
speare
actor-like thin abstraction over tokio::task and flume channels
-
fluxion-exec
Async stream subscribers and execution utilities for fluxion
-
ksoft
KSoft.SI api wrapper written in pure Rust
-
tokio-boring2
SSL streams for Tokio backed by BoringSSL
-
spn-providers
LLM provider abstraction layer for SuperNovae
-
progressor
A modern, async-first progress tracking library
-
hedged-rpc-client
High-performance Solana RPC client with request hedging for tail latency elimination
-
aggligator-transport-usb
Aggligator transport: USB
-
twcai
Rust client library for Timeweb Cloud AI API
-
async-bounds
Attribute to declare bounds on the Future returned by an async fn
-
tokio-eventfd
Linux eventfd for tokio
-
pattern-guard
Behavior anomaly guard: observes events, detects patterns, recommends allow/warn/delay/block
-
async_async_io
AsyncRead,AsyncWritetraits but withasync fnmethods -
mtorrent-utils
Miscellaneous utilities for BitTorrent protocol
-
async-local
For using thread locals within an async context across await points
-
aoc_leaderboard
Strongly-typed wrapper for Advent of Code leaderboard data
-
unsync-pipe
Ringbuffer-backed !Send !Sync binary safe repr(C) AsyncWrite/AsyncRead pair
-
tracing-opentelemetry-extra
Bootstrap utilities for tracing and OpenTelemetry integration
-
lifeline
dependency injection library for asynchronous message-based applications
-
nasu
Command-line utility which poll on remote addresses in order to perform status checks periodically
-
tower-actor
A
towermiddleware that creates aServiceby passing messages to an actor -
either-future
Future for Either<impl Future, impl Future>
-
tokio-io-rewind
rewind tokio::io::AsyncRead and tokio::io::AsyncWrite streams
-
any-mpsc
An mpsc that allows arbitrary types to be passed through
-
atlas-ctx
An asynchronous task context management library
-
tokio_tasks_shutdown
Easily manage and gracefully shutdown tokio tasks while monitoring their return results
-
backdrop
Drop your large or complex objects in the background with Backdrop! (later, on another thread, or both! Fully customizable! Tokio supported!)
-
apalis-sql
SQL utilities for background job processing with apalis
-
asynclog
asynchronous log library
-
tokio-lxi
LXI protocol abstractions for Tokio
-
fb_futures_01_ext
Extensions for future 0.1 crate
-
lio
A platform-independent async I/O library with native support for io_uring (Linux), IOCP (Windows), and kqueue (macOS)
-
structured-json-agent
A typed and extensible library for creating and running Iterative AI Agents that generate structured JSON output
-
axiom
Implements a highly-scalable and ergonomic actor system for Rust based on the best of Erlang / Elixir and Akka
-
dndx-fork-tokio-tun
Asynchronous allocation of TUN/TAP devices using tokio
-
genawaiter2
Stackless generators on stable Rust
-
astrid-gateway
Gateway daemon for the Astrid secure agent runtime
-
yaaral
async runtime abstraction library
-
mcp-hub
Fast hub for MCP tools
-
futures_cbor_codec
A codec for framing an AsyncRead/AsyncWrite with cbor for all types that are serializable with serde
-
async-mq
Zero-cost async-await abstraction of lapin AMQP client crate
-
yot_run
A work-stealing, multi-threaded async executor with non-blocking scheduling
-
stt-cli
Speech to text Cli using Groq API and OpenAI API
-
async-select
select!multiplex asynchronous futures simultaneously -
joyent-tokio-zookeeper
Asynchronous client library for interacting with Apache ZooKeeper
-
karyon_eventemitter
A lightweight, asynchronous event emitter for Rust
-
charred
char checking
-
aurora-streams
managing publish-subscribe channels using Tokio message passing channels
-
machi-integrations
Third-party platform integrations for Machi AI Agent Framework
-
compio-runtime
High-level runtime for compio
-
futures-delay-queue
Async delay queue backed by async-std and futures-timer
-
interprocess-docfix
Interprocess communication toolkit. Docs fixed.
-
anthropic_rust
A modern, type-safe Rust SDK for the Anthropic API, providing async-first access to Claude models with comprehensive error handling and streaming support
-
webhdfs
Hadoop WebHDFS client library
-
mini_langchain_core
A low-cost, cross-language LangChain implementation
-
libindigo
Core API for developing INDIGO astronomy clients and devices
-
route-sink
Sinks with routes
-
k8s-operator
A highly-available Kubernetes operator framework using Raft consensus
-
voiceflousion
that provides toolkit for Voiceflow AI bots integrations and pre-built functionality for quick integration with popular messengers
-
coalescent
High-level AI coordination patterns enabling intelligent agent coalescence
-
laminarmq
A scalable, distributed message queue powered by a segmented, partitioned, replicated and immutable log
-
plumber-rs
The basic library for Plumber servlet written in Rust
-
streamtools
Additional stream combinators
-
ultra-batch
Tokio-based library to batch and cache database queries or other data lookups
-
hreq-h2
An HTTP/2.0 client and server
-
peace_data
Data model for the peace automation framework
-
crossflow
Reactive programming and workflow engine in bevy
-
crossbus
A Platform-Less Runtime-Less Actor Computing Model
-
whirlwind
Collection of thread-safe, asynchronous data structures
-
pawkit-futures
Future utils for PawKit
-
simq
A job queue with the goal of being as simple of a queue as possible
-
rs-sqs-receiver
An asynchronous AWS SQS message receiver framework with trait-based handlers and shared resource support
-
completion_stage
Push-based futures for Rust similar to Java's CompletionStage
-
ai-agents-memory
Memory implementations for AI Agents framework
-
sonor
controlling sonos speakers
-
lua_actor
Lua Actor for Rust(sync/async)
-
motosan-ai
Rust SDK for multi-provider AI chat
-
ractor_cluster
Distributed cluster environment of Ractor actors
-
neuron
Composable async agentic AI framework for Rust
-
bp3d-threads
threading library intended to simplify concurrency in BP3D
-
tokio-immediate-egui
Asynchronous glue for your egui application
-
proxycurl-linkedin-rs
client for the Proxycurl LinkedIn API
-
rabbitmq-worker
A generic RabbitMQ worker library with built-in retry and dead-letter queue (DLQ) logic
-
constellation-rs
Constellation is a framework for Rust (nightly) that aides in the writing, debugging and deployment of distributed programs
-
aktors
Driver for derive-aktor
-
async-borrow
Async compatible ownership semantics using futures instead of lifetimes
-
north-config
North config is a multi source configuration crate designed as part of the North Microservice Framework
-
nuclei
Proactive IO & runtime system
-
reagent-rs
building AI agents with MCP & custom tools
-
array__ops
A selection of useful array operations
-
starbase_events
Async and mutable event system
-
llm-kit-xai
xAI (Grok) provider implementation for the LLM Kit - supports chat, image generation, and agentic tools
-
toy-rpc
An async RPC that mimics golang net/rpc's usage and supports both async-std and tokio
-
voyager
Web crawler and scraper
-
async-oncecell
Asynchronous versions of OnceCell and Lazy
-
amqp
AMQP/RabbitMQ protocol client
-
rust-genai
Rust SDK for the Google Gemini API and Vertex AI
-
compact
Store objects containing dynamic fields either compactly in consecutive memory or using traditional heap pointers
-
adk-guardrail
Guardrails framework for ADK agents - input/output validation, content filtering, PII redaction
-
global_cell
A thread-safe, async-friendly, performant global cell alternative built on Rust and Tokio primitives
-
lib3h_zombie_actor
lib3h actor request tracking module
-
atask
An async task implementation
-
bullmq-rs
BullMQ - Redis-based distributed job queue
-
arangoq
An AQL query builder layer and ArangoDb client for rust
-
heph-inbox
Bounded capacity channel designed to be used as inbox for actors. Also supports one shot channels.
-
noosphere-into
Transformations of Noosphere content into various target formats
-
mahler
An automated job orchestration library that builds and executes dynamic workflows
-
tk-listen
A set of helper futures allowing to listen TCP (or unix) socket with resource limits and proper error handling
-
luis_sys
FFI bindings for Microsoft LUIS API
-
adk-realtime
Real-time bidirectional audio/video streaming for Rust Agent Development Kit (ADK-Rust) agents
-
unsync
Unsynchronized synchronization primitives for async Rust
-
elfo
An asynchronous distributed actor framework with robust observability
-
tlq
Tiny Little Queue
-
forgeai-stream
Streaming protocol types for forgeai-rs
-
izihawa-common-multipart
multipart/form-data
-
vex-queue
Async background worker queue for VEX Protocol
-
hollywood
actor framework
-
hyperfile-cleaner
Segments cleaner implementation for Hyperfile
-
switchy_async_cargo
Cargo async linter package
-
async_msp_cli
Async msp cli for iNav and BetaFlight
-
async-observable
Async & reactive synchronization model to keep multiple async tasks / threads partially synchronized
-
bicoro
Bidirectional co-routine data structures
-
releez
run application release-checklist safely
-
there
planning and executing commands on local and remote hosts
-
libaio-futures
Straightforward Linux AIO using Futures/async/await
-
mini-c-ares-resolver
An asynchronous DNS resolver, backed by mini-c-ares
-
nature
development support platform, it separates data definition from code, so it decouple the data from business system
-
motore-macros
Motore's proc macros
-
epox
An epoll driven async executor
-
async-io-pipe
Pipe your stdout/stderr together with asynchronous streams
-
highroller
high-level rolling index that is thread-safe and guarantees cheap runtime-unique IDs
-
axum-server2
High level server designed to be used with axum framework
-
ubl-sirp
UBL SIRP: HTTP capsule+receipt, HMAC, idempotency, server for Universal Business Ledger
-
yosemite
Asynchronous SAMv3 library
-
stateset-jobs
Background job scheduler for StateSet iCommerce — cron, interval, and event-driven job execution with retry and backoff
-
cancellation-token
C#'s CancellationToken API
-
rrq-runner
RRQ runner runtime for Rust
-
async-io-bufpool
Efficient asynchronous I/O operations with minimal idle memory overhead
-
rendezvous
Easier rendezvous channels for thread synchronization
-
eyeball-im
Observable collections based on the
imcrate -
stream-download-opendal
OpenDAL adapter for stream-download
-
miniloop
The simpliest async executor without heap memory allocation
-
multipart-write
Sink-like interface for writing an object in parts
-
tokio-zmq
Futures abstractions for ZeroMQ on the Tokio event-loop
-
supply-demand
functional dependency injection library
-
yts-api
Access the yts.mx API
-
mod-events
A high-performance, zero-overhead event dispatcher library for Rust
-
futures-boring
SSL streams for Futures built on top of the BoringSSL
-
async-ctrlc
Async wrapper of
ctrlc -
event_iterator
Asynchronous lending iterator
-
tcp-channel-client
Asynchronous tcpclient based on aqueue actor
-
snowflake-id-generator
snowflake id implementation
-
hutch
Checkpoint and undo system for AI agent sessions - safe burrow to return to
-
register-count
Counting
Registers created by aCounter -
tokio-send-fd
A wrapper for tokio::net::UnixStream to send file descriptors
-
motosan-chat-core
Core types and runtime for the motosan-chat chatbot framework
-
coordinator
load balance tasks into task runners
-
combadge
makes Rust Web Workers easy
-
shutdown-handler
A shutdown handler that allows all parts of an application to trigger a shutdown
-
enact-observability
Observability and telemetry for Enact
-
dag-flow
DAG Flow is a simple DAG workflow engine
-
tobytcp
A little library for sending messages over a tcp stream
-
actix-limitation
Rate limiter using a fixed window counter for arbitrary keys, backed by Redis for Actix Web
-
libmqm-constants
IBM® MQ Interface (MQI), Programmable Command Format (PCF) and MQ Administration Interface (MQAI) constant definitions
-
felicia
service for accessing and sharing lists of bad actors
-
bob-chat
Chat channel types and streaming abstractions for Bob Agent Framework
-
varpulis-actors
Lightweight actor framework with supervision and health observation for Varpulis
-
enact-security
Security policy, audit logging, and sandboxing for Enact agents
-
spin_on
inefficient Future executor
-
nolocal-block-on
futures_lite::future::block_on that can run without using thread-locals
-
typed-emitter
Typed Async event emitter
-
pierport
Urbit pier import protocol implementation
-
async-io-map
mapping of async IO operations
-
stun-client
async_std based asynchronous STUN client library
-
codex-client-sdk
Rust SDK for embedding the Codex agent via CLI-over-JSONL transport
-
bipe
asynchronous I/O pipe
-
claude-sdk
Native Rust SDK for the Claude API with streaming support and tool execution
-
btwo
using the Backblaze B2 API
-
co_managed
Create managed sub coroutines. Managed sub coroutines will be cancelled when the parent exit
-
gradio_client_rs
Async Rust client for Gradio apps
-
firecracker-rs-sdk
🧨🦀🚀 The Firecracker Rust SDK. A pure Rust crate for interacting with Firecracker.
-
system-timer
async timers built on SystemTime
-
io-stream
Set of I/O-free coroutines and runtimes to manage streams
-
luminal_rt
A DLL-boundary safe async runtime with tokio-compatible API
-
async-rusqlite
A tiny executor agnostic wrapper around rusqlite to make calls to it async
-
caudal-sdk
Caudal SDK - Event observability for distributed systems
-
elfo-telemeter
Collects and exposes metrics of the elfo system
-
booru-dl
A command line tool to download images and tags txt from booru
-
outfox-zhipu
Zhipu AI (GLM) API client for outfox
-
ntex-neon
Async runtime for ntex
-
deepseek_rs
client library for the DeepSeek API
-
rsketch-common-runtime
Tokio runtime configuration and management for rsketch
-
borrow_mutex
Async Rust Mutex which does not require wrapping the target structure
-
righvalor
AI Infrastructure and Applications Framework for the Far Edge
-
ssec-core
streaming implementation of the SSEC file format
-
celers-backend-redis
Redis result backend for CeleRS
-
celers-metrics
Prometheus metrics and observability for CeleRS
-
rio
GPL-3.0 nice bindings for io_uring. MIT/Apache-2.0 license is available for spacejam's github sponsors.
-
procsem
Semaphore used to lock thread/task-spanning sequence of operations
-
signal-hook-async-std
async-std support for signal-hook
-
tokio-snappy
Wrap rust-snappy as a async stream in tokio
-
negahban
🧐 A simple file watcher, based on
notify, designed to be fast, easy-to-use and async friendly -
tirea-contract
Shared agent contracts: runtime, extension SPI, and composition registries
-
slings
A small async runtime based on io-uring for Rust
-
the-fourth-server
A lightweight tcp server/client pair for network programming
-
prevayler-rs
System prevalence in rust
-
ref_count
Efficient, low-level asynchronous synchronization for real-time and embedded systems
-
crabler
Web scraper for Crabs
-
ultraapi
A FastAPI-inspired Rust web framework with automatic OpenAPI generation
-
ruchei-callback
Callback traits for ruchei
-
any_spawner
Spawn asynchronous tasks in an executor-independent way
-
fork_stream
Clone any stream
Swhere<S as Stream>::Item: Clone -
openai-agents
OpenAI Agents SDK for Rust - A lightweight framework for building multi-agent workflows
-
orsomafo
Event dispatcher crate
-
pipeworks
Robust data processing pipelines
-
actix-multipart-rfc7578
multipart/form-data (RFC7578) for Actix
-
tokio-bitstream-io
Tokio port of bitstream-io: Library for reading/writing un-aligned values from/to streams in big-endian and little-endian formats
-
funfsm
An FSM library where the states are functions
-
infect
Intent/effect/task - A variation on the Model View Intent (MVI) and State Action Model (SAM) paradigms
-
fundamentum-sdk-mqtt
MQTT client targeting Fundamentum IoT's MQTT broker
-
rong_child_process
Child process module for RongJS
-
trait-morph
A lightweight procedural macro to transform
async fnin traits into-> impl Futurewith explicit bounds -
pinned
Synchronisation primitives for !Send tasks
-
kvarn_async
Async utilities used in the Kvarn web server
-
sparkle-convenience
A wrapper over Twilight designed to make it more convenient to use
-
smpsc
Wrappers for tokio's mpsc channels which implement Stream and Sink
-
gcp_access_token
pure rust implimentation to get google cloud access token for servers with service account credentials
-
requiem
Actor framework for Rust
-
cloud_terrastodon_pathing
Well-known paths for the Cloud Terrastodon project
-
arta-tokio
Async abstractions implementation for Tokio
-
leptos_async_signal
Async signal for leptos Rust web framework
-
dropslot
A high-performance publish-subscribe library with latest-only delivery semantics
-
oxidizedgraph
A humble attempt at LangGraph in Rust - R-LangGraph framework for building AI agent workflows
-
nonblock
Read available data from file descriptors without blocking (e.g. sockets, streams, child stdout, named pipes)
-
csv-async
CSV parsing for async
-
flowly-io
Flowly is a library of modular and reusable components for building robust pipelines processing audio, video and other
-
portable_async_sleep
A portable async sleep function for Rust
-
background-jobs-tokio
in-process jobs processor based on Tokio
-
maniac
Massively scalable Rust async runtime
-
mfio
Flexible completion I/O primitives
-
agentic_optio_rs
Production-grade multi-agent framework with minimal dependencies - Rust implementation
-
simple-actor
Helper to write actor-based async code
-
async-gcode
An async gcode parser for no_std targets
-
rocketmq-remoting
Apache rocketmq remoting
-
rust-pty
Cross-platform async PTY (pseudo-terminal) library for Rust
-
agent-rex
An async Stream-based FRP-like library for Rust
-
actix-interop
Use async/await syntax with actix actors
-
futuristic
Extensions to the futures crate
-
mail-message
A program for easy, quick, and fault tolerant sending of emails from the command line
-
async-xml
deserializing XML data asynchronously
-
pulses
A robust and flexible background job processing library for Rust
-
wamp_async
An asynchronous WAMP implementation
-
safina-async-test
Macro for running async tests - ARCHIVED: Code moved to
safinacrate -
reactive-messaging
Reactive client/server communications, focused on high performance
-
async_counter
Counter that implements a future to await on specific value
-
rosrust_async
A native ROS1 client implementation in async Rust
-
merkql-notify-sqs
AWS SQS notification plugin for merkql
-
act-locally
single-threaded async actors with ordinary functions as handlers and plainly typed messages
-
async-recorder
Store records without waiting for your persistence backend
-
ruloom
A thin wrapper around 'corosensei' that provides support for stackful coroutines in Rust (like Loom in Java or goroutines in golang)
-
secret-lib
Cross-platform, asynchronous Rust library to retrieve secrets from different sources
-
async-interval
Async Interval
-
async-defer
Asynchronous Deferred Calls
-
xilinx-dma
Userspace Xilinx AXI DMA Interface
-
knien
Typed RabbitMQ interfacing for async Rust
-
riglr-core
Core abstractions and job execution engine for riglr - building resilient AI agents
-
logimesh
RPC Microservice 2.0 framework
-
compio-buf
Buffer trait for completion based async IO
-
tbot
Make cool Telegram bots with Rust easily
-
pochta
Addressable channel registry
-
d-engine-server
Production-ready Raft consensus engine server and runtime
-
ej-io
Program management utilities for the EJ framework
-
logic-mesh
Control logic engine using event based and reactive blocks written in Rust
-
svix-webhook-with-clone
Svix webhooks API client with derive Clone added to Webhook struct
-
plumbing
An async abstraction to pipeline requests through a channel
-
persway
Sway IPC daemon
-
eff
Algebraic Effects Library for Rust
-
tracing-orchestra
Give me more instruments!
-
kaccy-ai
AI-powered intelligence for Kaccy Protocol - forecasting, optimization, and insights
-
rs_ctx
Context propagation for rs framework
-
yeast-rs
Tiny but linear growing unique id generator
-
actix-daemon-utils
Daemon Utilities by actix
-
armature-messaging
Message broker integrations for the Armature framework - RabbitMQ, Kafka, NATS, and AWS SQS/SNS
-
enact-a2a
Multi-agent and A2A (Agent-to-Agent) protocol support for Enact
-
paranoid-hash
A Hashing Library For Those Paranoid With Their Security
-
philiprehberger-retry-kit
Async retry with exponential backoff and circuit breaker for Rust
-
tower-sessions-seaorm-store
SeaORM session store for
tower-sessions -
stream-partition
Partition a single stream into multiple sub-streams based on a key
-
amutex
Async Mutex
-
gasket
Staged Event-Driven Architecture (SEDA) framework
-
lib-wc
Will's Programming Toolbox
-
micro_http_async
A small, lightweight and hassle-free crate using async to serve web pages or web apis with high performance and extremely low overhead
-
simple-middleware
General purpose middleware crate
-
tokio-tar
async TAR file reader and writer. This library does not currently handle compression, but it is abstract over all I/O readers and writers. Additionally, great lengths are taken to ensure that the entire…
-
visiting_ref
Container types that asynchronously return ownership of a value to another context upon exiting scope
-
flarrow-layout
flarrow (flow + arrow) is a rust runtime/framework for building dataflow applications
-
smol
A small and fast async runtime
-
dialectic
Transport-polymorphic, asynchronous session types for Rust
-
riker
Easily build fast, highly concurrent and resilient applications. An Actor Framework for Rust.
-
checkstream-core
Core types, token buffer, and error handling for CheckStream guardrail platform
-
uint24le_framing
Convert bytes IO into uint24 length prefixed messages
-
versatile-dataloader
An async data loader for Rust
-
acu
building asynchronous actors
-
rexecutor-sqlx
A robust job processing library
-
sumup-rs
A comprehensive, type-safe Rust client for the SumUp API with full async/await support
-
async-copy-progress
Asynchronous copying with progress callbacks
-
thorstreamer-grpc-client
Rust client for ThorStreamer gRPC streaming services
-
hls_lfcd_lds_driver
Rust driver for ROBOTIS HLDS HLS-LFCD-LDS (LDS-01)
-
async_monad
Asynchronous monad for rust
-
fundamentum-edge-pfwd
The port forwarding tool for edge daemon
-
daimon-provider-gemini
Google Gemini provider for the Daimon AI agent framework
-
xerv-executor
XERV orchestration executor: DAG scheduler, selector linker, pipeline controller, and REST API
-
latchlm
A provider-agnostic client library for AI models
-
fibers_inotify
A futures friendly inotify wrapper for fibers crate
-
maelstrom-node
Maelstrom Rust node framework
-
bufstream
Buffered I/O for streams where each read/write half is separately buffered
-
napmap
Async HashMap that halts requester tasks until the requested data is accessible
-
bing_client
Async reverse client for Bing copilot
-
tokio-netem
— pragmatic AsyncRead, AsyncWrite I/O adapters for chaos & network emulation
-
synch
A basic asynchronous timer implementation that uses the cortex-m SysTick peripheral
-
tes3mp-plugin
Stubs for creating a TES3MP server plugin
-
simple-groq-rs
async Rust client for the Groq API (OpenAPI-compatible)
-
enact-context
Context window management and compaction for Enact
-
warhorn
Protocol types for agent communication - signals between goblins
-
eugener-test
An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications
-
lsp-codec
Tokio-compatible codec implementation for Language Server Protocol
-
cerebras-rs
High-performance Rust SDK for Cerebras Inference API - Low-latency AI model inference powered by Cerebras Wafer-Scale Engines
-
smolscale
A high-performance async-task scheduler
-
odem-rs-sync
Model-time synchronization facilities of the ODEM-rs simulation framework
-
haiyuu
experimental actor-like library
-
bytes-stream
functions to work with stream of bytes
-
piston_rs
An async wrapper for the Piston code execution engine
-
async-timeouts
An instrument to start async tasks after timeouts
-
mio-pidfd
mio support for Linux's pidfd
-
mojentic
An LLM integration framework for Rust
-
awaitable
type with input and output that can be stored in container
-
praxis-context
Context management and summarization for AI agent conversations
-
seccomp-stream
tokio adapter for seccomp_unotify
-
blocking-permit
Permits and a thread pool for blocking operations
-
linked-futures
Link futures into a block, which stops all of the included futures when any of the futures complete
-
async-hofs
Various extention traits for providing asynchronous higher-order functions
-
extreme
Extremely boring async function runner. MIT/Apache-2.0 license is available for spacejam's github sponsors.
-
kappa
actor framework, this one based on the lambdas/behaviors
-
abort-on-drop
A wrapper of Tokio's JoinHandle that aborts the task when it's dropped, while still allowing it to be awaited for joining
-
ruchei-extra
Stream/Sink wrapper with extra data, as used by ruchei
-
tokio-tower
Bridging the protocol gap between Tokio and Tower
-
async-rev-buf
High-performance async buffered reader for reading lines in reverse order from files and streams
-
async-change-tracker
reactive change notifications using futures
-
agent-sdk-rs
Pure-Rust agent SDK for production tool-calling loops, multi-provider, type-safe, and ergonomic
-
tokio-graceful-shutdown-without-anyhow
perform a graceful shutdown on a Tokio based service
-
tokio-task-supervisor
Tokio TaskTracker with built-in cancellation token management and coordinated shutdown
-
buffer-unordered-weighted
Stream::buffer_unordered where each future can have a different weight
-
discord-selfbot
Discord selfbot API library for Rust
-
moxie
Incremental runtime for interactive software
-
octopust
A high-performance, idiomatic Rust client for the Octopus Energy API
-
agentctl
Tiny control-plane primitives for AI agents
-
tokio-memory
Agent memory primitives: episodic, semantic, working memory with decay and consolidation
-
foxhole-api
wrapper for the Foxhole War API
-
rmqtt-retainer
When a client publishes with the retain flag, the message is saved and sent to future subscribers matching the topic
-
peace_cfg
Configuration model for the peace automation framework
-
grok-client
Grok api client
-
openraft-memstore
A in-memory implementation of the
openraft::RaftLogStorageandopenraft::RaftStateMachinetrait -
tokio-socks
Asynchronous SOCKS proxy support for Rust
-
zeebe
client for defining, orchestrating, and monitoring business processes across microservices using Zeebe
-
wait_not_await
awaiter implementation
-
tokio-tun
Asynchronous allocation of TUN/TAP devices using tokio
-
swiftide-agents
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
gpiocdev
Access GPIO lines on Linux using the GPIO character device
-
ctxguard
managing contexts
-
magical_rs
Rust framework for file recognition, aiming for high extensibility and customization
-
teloxide-ng
An elegant Telegram bots framework for Rust
-
async-task-tracker
A task tracker used for waiting until tasks exit
-
service-io
Build your service-server fast, easy (and without hosting!)
-
multipart-rfc7578
multipart/form-data (RFC7578)
-
moonpool
A place to experiment around actors
-
rustygram
minimal and blazing fast telegram notification framework for Rust
-
duende-platform
Platform adapters for the Duende daemon framework (systemd, launchd, container, pepita, WOS)
-
async-pipes
building concurrent data processing pipelines
-
sactor
actor framework for Rust
-
sturgeon
Record async streams with timing, replay deterministically
-
simple-process-stats
Get memory usage and CPU time on Linux and Windows
-
okkoi
-
tokio-lk
Futures-aware lock-by-id primitives
-
histrion
A minimal Rust actor library
-
safina-sync
Safe structs for sharing or sending data between async tasks - ARCHIVED: Code moved to
safinacrate -
tor-general-addr
Generalized socket address type used by Tor
-
aa-sms
Send messages from with Andrews & Arnold’s SMS API
-
bb8-bolt
A bolt-client adaptor for the bb8 connection pool
-
tokio-reactor-trait
reactor-trait implementation for tokio
-
fastn-context
Type-safe async context propagation for Rust applications
-
neuron-loop
Agentic loop for Rust — multi-turn tool dispatch, streaming, and conversation management over any LLM provider
-
wasmflow-packet
encapsulating the message packets sent across Wasmflow components
-
fcdb-concur
Concurrency primitives and async utilities for FCDB
-
claw-core-protocol
Async Rust client and protocol types for the claw_core daemon (JSON-over-Unix-socket). Use standalone or with ZeroClaw via --features claw-core.
-
digdigdig3
Multi-exchange connector library — unified async Rust API for 40+ crypto exchanges, stock brokers, forex providers, and 88 intelligence feeds
-
messagebus
allows intercommunicate with messages between modules
-
monoio-rustls
Asynchronous TLS streams wrapper for Monoio based on Rustls
-
xtor
Async Actor framework for Rust which is blazing fast and rock solid
-
roco_z21_driver
Rust API for Roco Z21 model railway control system
-
kotoba-llm
Unified multi-vendor LLM client abstraction, supporting providers such as OpenAI, Anthropic, Google Gemini, etc
-
awaitable-bool
A Tokio-powered awaitable bool (analogous to a flag and highly inspired by Python’s
asyncio.Event, but can be waited for to become ‘false’ too) -
async-weighted-semaphore
An async weighted semaphore
-
aoc_leaderbot_aws_lib
AWS-specific support library for aoc_leaderbot, an Advent of Code leaderboard-watching bot
-
graceful-shutdown
Graceful Shutdown for async code
-
asanaclient
Rust SDK for the Asana API
-
tc_nominatim
Bindings to the reverse geocoding API powered by openstreetmap
-
happyeyeballs
Happy Eyeballs implementation in Tokio (not RFC compliant atm)
-
asyncapi-rust-models
Runtime data structures for asyncapi-rust (AsyncAPI 3.0 spec models)
-
tspawn
A thread-safe wrapper around Arc<RwLock<T>> with convenient cloning semantics and async task spawning macros
-
evalsync
Experiment synchronization library for benchmark coordination via ZeroMQ
-
mio-uds
Unix domain socket bindings for mio
-
ferroid
High-performance ULID and Snowflake-style IDs. Unique, monotonic, and lexicographically sortable IDs optimized for low-latency services and async workloads.
-
ambush
Task decomposition and plan mode for AI agents - planning the attack
-
eventbuzz
A safe, fast, concurrent event publish/subscribe system based on tokio(async), inspired by Spring events
-
async-ringbuffer
A nonblocking spsc ring buffer with fixed capacity
-
warp-rate-limit
Rate-limiting middleware for the Warp web framework
-
nr-tracing-layer
Send your logs to New Relic
-
notifier_hub
cannal subscribtion system
-
suppaftp-cli
FTP command line client, based on suppaftp
-
runtara-sdk
High-level SDK for building durable workflows with runtara
-
agentlib-core
Core runtime and foundational traits for the AgentLib framework
-
omniference
A multi-protocol inference engine with provider adapters
-
futures-sink
The asynchronous
Sinktrait for the futures-rs library -
podo-core-driver
Podo Driver FFI
-
sansio-executor
sansio executor
-
kill_tree
🌳 Kill Tree is a library designed to terminate a specified process and all its child processes recursively, operating independently of other commands like kill or taskkill
-
amqp-manager
Lapin wrapper that encapsulates the use of connections/channels and creation of amqp objects
-
pi_futures
feature select
-
thread-waker
Waker implementation using current thread token
-
futures-finally
that executes a future after the completion of a future or stream regardless of the value or outcome
-
tourniquet
Async native round-robin manager for remote services
-
qm-nats
Nats helper functions
-
misaki-core
Fast, asynchronous link checker with optional FlareSolverr support
-
gandi-v5-livedns-api
Gandi LiveDNS Api
-
file-operation
providing comprehensive utilities for file operations with both sync/async support. Includes operations for copy, delete, move, read and write files. Simplifies file handling in Rust…
-
tokio_x_codec
tokio codec. auto impl tokio_util::codec::Encoder and tokio_util::codec::Decoder.
-
winctx
A minimal window context for Rust on Windows
-
poee
Functions for efficient development
-
fixed_ring_buffer
An asynchronous SPSC fixed-capacity look-free ring buffer, which can be used to transfer data between two threads or between two asynchronous tasks
-
deferred
help perform deferred execution of code logic
-
tokio_smux
Smux protocol in Rust. Provide multiplexing for reliable streams.
-
hanabi
High perfomance in-memory caching and event streaming
-
stow
Cloud storage abstraction package for Rust
-
wasmind_config
Configuration system for Wasmind actors and runtime
-
stof
Data that carries its own logic
-
susync
An util crate to complete futures through a handle. Its main purpose is to bridge async Rust and callback-based APIs.
-
pirates
async RPC lib
-
croissant
A scheduling library
-
easerx
A reactive MVI (Model-View-Intent) framework for Rust
-
sendblue
that provides an API client for interacting with the SendBlue REST API, enabling businesses to integrate iMessage and SMS services into their applications
-
ruchei-extend
ExtendPinned utilities for ruchei
-
tower-circuitbreaker
A circuit breaker middleware for Tower services
-
praxis-graph
React agent orchestrator for building AI agent workflows with LLM and tool execution
-
event-notification
A modular event notification system with multi-channel support
-
task_forge
A flexible and simple task pool for asynchronous execution
-
clamav-client
ClamAV client library with optional support for async-std, smol, and Tokio
-
async-rt
A small library designed to utilize async executors through an common API while extending features
-
irox-threading
Blocking and Asynchronous Threading Tools
-
vru-cancel
Cancel tokio stream
-
runc
consuming the runc binary in your Rust applications
-
key-lock
mutual exclusion by keys
-
unistore-retry
Retry strategy capability for UniStore
-
ferro-events
Event dispatcher and listener system for Ferro framework
-
rxqlite-tests-common
A distributed sqlite database built upon
openraft,sqlxandsqlite -
lib3mf-async
Non-blocking async 3MF parsing with tokio - high-throughput manufacturing data processing
-
zerortt-futures
Asynchronous Runtime Binding for
zerortt -
kimojio
A thread-per-core Linux io_uring async runtime optimized for latency
-
agenda-rs
A lightweight, stateful job queue for Rust backed by PostgreSQL with sqlx. Inspired by AgendaJS.
-
discern
implementing the Command Query Responsibility Segregation (CQRS) pattern
-
async-reciprocals
asynchronous fallible conversion and reciprocals in Rust
-
enki-runtime
A Rust-based agent mesh framework for building local and distributed AI agent systems
-
async-time-mock-async-std
Mockable time for use in async runtimes (async-std compatibility)
-
rumpsteak-aura-fsm
Session types for asynchronous communication between multiple parties (Aura flavored)
-
callbag
spec for reactive/iterable programming
-
async_job
async cron job crate for Rust
-
ispawn
Runtime-agnostic async spawners
-
reusable-box-future
A reusable
Pin<Box<dyn Future<Output = T> + Send>> -
orchflow-mux
Terminal multiplexer abstraction layer supporting tmux, mock backends, and custom implementations
-
nbd-async
Block device drivers in userspace
-
shunter
An experimental streaming pipeline library for Rust providing a composable DSL for building data pipelines
-
forgeai-tools
Tool calling helpers for forgeai-rs
-
zookeeper-async
An async ZooKeeper client
-
llm_client
easiest Rust interface for local LLMs
-
quinn
Versatile QUIC transport protocol implementation
-
vex-temporal
Time-aware memory compression for VEX
-
pulseengine-mcp-security-middleware
Zero-configuration security middleware for MCP servers with Axum integration
-
async-graphql-tide
async-graphql for tide
-
commonware-runtime
Execute asynchronous tasks with a configurable scheduler
-
async-cron-scheduler
Runtime-agnostic async task scheduler with cron expression support
-
stund
An SSH tunnel maintenance daemon
-
streamline
Reversible futures::Stream-based state machines
-
async-stream-packed
Asynchronous stream packed
-
compio-tls
TLS adaptor with compio
-
async-pidfd
Process file descriptors (pidfd) for Linux
-
mpm-cli
Modrinth Package Manager
-
async-read-progress
Extension traits for inspecting
AsyncReadprogress -
alopecosa
Pure rust async Tarantool 1.6+ connector built on tokio
-
serdes-ai-retries
Retry strategies and error handling for serdes-ai
-
partial-io
Helpers to test partial, interrupted and would-block I/O operations, with support for property-based testing through proptest and quickcheck
-
pausable_future
Pausable and resumable future, useful in background tasks
-
mailbox_processor
A small little actor abstraction inspired by the FSharp Mailbox Processor which in turn was inspired by erlang
-
schema-registry-observability
Observability, metrics, tracing, and monitoring for the Schema Registry
-
llm-kit-anthropic
Anthropic provider for LLM Kit - Complete Claude integration with streaming, tools, thinking, and citations
-
telltale-choreography
Choreographic programming for Telltale - effect-based distributed protocols
-
mm1-runnable
M/M/1! Queueing, do you speak it?!
-
agnostic-dns
agnostic-dnsis an agnostic abstraction layer overhickory-dns -
roux-stream
A streaming API for the roux Reddit client
-
swimos_rtree
SwimOS R-Tree
-
watchfile
An async utility trait to subscribe to file changes of a serializable file
-
volo-macros
Volo's proc macros
-
future-utils
Extensions to Rust's Future and Stream traits
-
timer-kit
A timer toolkit that is generic over the underlying timer implementation
-
ranvier-compliance
Compliance helpers (GDPR, HIPAA) for Ranvier
-
passivized_vault_client
Vault Client - initialize and monitor Hashicorp Vault nodes
-
hackdose-server
A server to control smart plugs using data from smart meters
-
stream-broadcast
Runtime independent broadcast, which only polls it's underlying stream if no pending data is available
-
armature-azure-functions
Azure Functions runtime adapter for Armature applications
-
agent-io
SDK for building AI agents with multi-provider LLM support
-
inferadb-common-storage-ledger
Ledger-backed implementation of StorageBackend for InferaDB
-
rusty_tarantool
Tarantul async client based on tokio framework
-
flows-arrow
Building blocks for flow-based data processing with Apache Arrow
-
hypixel_api
Generic wrapper around the hypixel api (automatic rate-limiting on client-side)
-
reqchan
channel for requesting and receiving data. Each channel has only one requesting end, but it can have multiple responding ends. It is useful for implementing work sharing. The two ends…
-
waitlist
Keep track of an ordered list of Wakers to wake
-
tokio-rusqlite-folk
Asynchronous handle for rusqlite library
-
inferadb-common-ratelimit
Distributed fixed-window rate limiter using StorageBackend
-
fluxion-rx
A reactive stream processing library with ordered semantics, friendly interface, bullet-proof test coverage, state-of-the art documentation and examples
-
tub
Async Pool
-
redis-work-queue
A work queue, on top of a redis database, with implementations in Python, Rust, Go, Node.js (TypeScript) and Dotnet (C#)
-
waaa
WebAssembly, Abstracted Away
-
wp-connector-api
Connector runtime traits, config helpers, and errors for WarpParse sinks and sources
-
streammap-ext
StreamMap of Tokio with altered
nextthat returns when stream is dropped -
mutex-extra
RefMutex<T>that is similar toMutex<T>but isSyncandSendeven ifTisn’tSend -
ai-sdk-provider-utils
functions and helpers for AI SDK providers
-
mlua_actor
Lua Actor for Rust(sync/async)
-
slacktor
extremely fast, bare-bones, low-overhead, supervisorless, no-std actor library
-
tirea-extension-permission
Tool-level permission policies and user-approval gating for tirea agents
-
actix-signal
Manage the lifecycle of an actix actor with its address
-
opencode-client-sdk
Rust SDK for integrating OpenCode via local server + OpenAPI HTTP client
-
anthropic
SDK
-
promising-future
Promise/Future pairs
-
curseforge
A straightforward asynchronous wrapper around the CurseForge Core API. Public API is subject to change before 1.0.0.
-
hl7-mllp-codec
A Tokio codec for HL7 Minimal Lower Layer Message Transport protocol (MLLP)
-
nsq-client
Rust client for the NSQ realtime message processing system
-
miniagent
Minimal single agent demo with basic file tools and MCP support
-
git-fast-import
generating git fast-import streams
-
agixt-sdk
Rust SDK for AGiXT - A powerful AI agent framework
-
apalis-pgmq
Background task processing for rust using apalis and pgmq
-
async-http1-lite
Asynchronous http1 stream
-
stackful
Bridge between sync and async
-
ply_jobs
ability to run background jobs on a schedule
-
fure
Retrying futures using different policies
-
xtra-addons
Add-on functionality (Broker, Registry) for crate xtra
-
async-rate-limit
Common traits for rate limiting and implementations in async contexts
-
async-signal
Async signal handling
-
futures-dagtask
DAG-based Task Queue
-
d7s_db
Database abstraction layer for d7s (PostgreSQL and SQLite)
-
conva_ai
Rust SDK for using CONVA AI Copilots
-
tokio-easy-timer
A tokio-based task scheduler, with a user-friendly API
-
spry
Resilient, self-healing async process hierarchies in the style of Erlang/OTP
-
aoc_leaderbot_slack_lib
Slack-specific support library for aoc_leaderbot, an Advent of Code leaderboard-watching bot
-
c-ares
wrapper for the c-ares library, for asynchronous DNS requests
-
reqsign-command-execute-tokio
Tokio-based command execution implementation for reqsign
-
proxy-scraper
command-line tool for scraping proxy information
-
fates
creating reactive declarations
-
eureka-manager-cli
The official cli for the eureka-mmanager
-
zippyst
Resolve zippyshare.com download links
-
catloaf
core-affine, thread-local, opinionated actor framework
-
fut_rwlock
A read-write lock that is read and written via Futures
-
uika-bindings
Generated UE type bindings and manual extensions for uika
-
async-tls
Asynchronous TLS/SSL streams using Rustls
-
madsim-real-tokio
An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications
-
machi
A Web3-native AI Agent Framework
-
libindigo-rs
Pure Rust implementation of the INDIGO protocol client
-
async_progress
Create sync points across async tasks
-
avila-async
Revolutionary async runtime - Quantum, Neural Networks, Blockchain, Genetic Algorithms, Zero dependencies
-
peace
zero stress automation
-
blocker
Block rust futures to create a synchronous wrapper around an asynchronous api
-
merkql-notify-sns
AWS SNS notification plugin for merkql
-
terminusdm
Terminus Download Manager. Download files, resume interrupted downloads, and keep a history of your downloads - within terminal UI.
-
peace_rt_model_web
Web support for the peace automation framework
-
async-tty
An asynchronous TTY library for Rust
-
llm-kit-groq
Groq provider implementation for the LLM Kit - supports chat and transcription models
-
tokio-switching-sleep
A tokio Sleep with a switchable state
-
napi_async_local
Extends napi-rs with the ability to run local futures
-
futures-test-preview
Common utilities for testing components built off futures-rs
-
rssafecircuit
implements a Circuit Breaker pattern with asynchronous support using Tokio, managing failure states and recovery strategies
-
cooper
in-process, async Actor library for Rust
-
a3s-event
Pluggable event subscription, dispatch, and persistence for the A3S ecosystem
-
async-hid
A async library for interacting with HID devices
-
gpui-tokio-bridge
Tokio bridge for GPUI - allows running tokio async tasks within GPUI context
-
mofa-ai
MoFA - Modular Framework for Agents. A high-performance AI agent framework built in Rust
-
qp
Quick Pool: High Performance Async Generic Pool
-
buf-read-ext
Trait extending anything that implements BufRead with stream_until_token()
-
stream-flatten-iters
Flattens a stream of iterators into one continuous stream
-
rustbridge-runtime
Tokio async runtime integration for rustbridge
-
lighthouse-client
Client SDK for Project Lighthouse
-
stream_router
A Future aware router to dynamically route between Streams and Sinks
-
drama
multitenant scheduler for the komora db project
-
tokio-stream-multiplexor
Stream Multiplexor for tokio with a tcp like interface
-
timeout-macro-parse
A companion-crate for the tokio-timeout proc-macro-lib
-
allsource-core
High-performance event store core built in Rust
-
retry-if
A tokio-compatible attribute-macro for decorating methods and functions with an exponential backoff
-
rlua-async
Async support for rlua, via coroutines
-
monoio-io-wrapper
A read/write wrapper to bridge sync and async io
-
futures-mockstream
Minimal mockstream which implements futures async traits
-
hikvision-rs
High-level asynchronous library for controlling cameras from Hikvision using the PTZ API
-
ubl-mcp
Secure, audited Model Context Protocol (MCP) client/server with policy gates and audit logging
-
atedb
Distributed datachain (database) built on an immutable data store with strong encryption and authentication
-
ctrlc-async
Easy asynchronous Ctrl-C handler for Rust projects
-
tokio-stomp-rs-rs
Asynchronous streaming STOMP client fork
-
futures-zmq
Futures abstractions for ZeroMQ on any futures executor
-
mixi2
Async Rust SDK for the mixi2 Application API
-
conflu-mcp-rs
Model Context Protocol (MCP) server for Confluence
-
cannyls_rpc
RPC library for operating cannyls's devices from remote nodes
-
euklid
CRDT
-
spring-axum
Spring-like application framework for Axum with macro-based auto discovery, validation, transactions, caching, events, and SQL/Mapper integrations
-
oneshot-handshake
providing a symmetric one time use channel type
-
again
wasm-compatible retry util for std library futures
-
raio
A neo4j+bolt driver written in Rust
-
task-exec-queue
A asynchronous task execution queue
-
tonic-arcanyx-fork
A gRPC over HTTP/2 implementation focused on high performance, interoperability, and flexibility
-
moirai-durable
Durable future support for Moirai job system
-
freactor
A lightweight framework for asynchronous execution flow
-
napi_ext
Extends napi-rs with the ability to run local futures
-
read-write-ext-tokio
AsyncReadWriteExt trait with
chain_afterandtake_rwfortokio::io::Read + Writestructs -
goblin-engine
A high-performance async workflow engine for executing scripts in planned sequences with dependency resolution
-
random-access-storage
Abstract interface to implement random-access instances
-
async-mcp
Async Implementation of Model Context Protocol (MCP)
-
felixs-tower-lsp
Language Server Protocol implementation based on Tower
-
async-gen
Async generator in stable rust using async/await
-
mofa-runtime
MoFA Runtime - Message bus, agent registry, and event loop
-
praisonai
Core library for PraisonAI - Agent, Tools, Workflows
-
mioco
Scalable, asynchronous IO coroutine-based handling (aka MIO COroutines)
-
rtx
zero-cost runtime-abstraction intended for use by Rust libraries to enable the Freedom of Choice between asynchronous runtimes
-
blec
cross-platform ble client library based on btleplug
-
rants
An async NATS client library
-
baton
channel for receiving updates per field
-
gcp_auth
Google cloud platform (GCP) authentication using default and custom service accounts
-
turboclaude
Unofficial Rust SDK for Anthropic's Claude API with 100% feature parity to official Python SDK
-
axum-core
Core types and traits for axum
-
kayrx
Framework
-
agentic-sandbox
Sandboxed code execution: Process, Docker, Firecracker, Gateway
-
xactor
actors framework based on async-std
-
flo-state
Lightweight actor library
-
capp
Common things i use to build Rust CLI tools for web crawlers
-
xerv-core
Workflow orchestration core: memory-mapped arena, write-ahead log, traits, and type system
-
rad
A type-safe, high-level interface to librados using the low-level C bindings from ceph-rust
-
tunny
flexible, efficient thread pool library for Rust built to manage and scale concurrent workloads. It enables you to process jobs in parallel across a configurable number of worker threads…
-
elizaos-plugin-blooio
elizaOS Blooio Plugin - messaging via Blooio platform
-
parallel-stream
Data parallelism library for async-std
-
nvisy-rt-sdk
Rust client for the Nvisy Runtime API: direct multimodal redaction
-
tokio-stomp-2
Unofficial successor to Asynchronous streaming STOMP client
-
flowbuilder
An async flow orchestration framework with conditional execution and context sharing
-
send-future
Ergonomic and performant fix for https://github.com/rust-lang/rust/issues/96865
-
tenorite
A concurrency abstraction library. Provides a client-server model for asynchronous workers
-
message_worker
Message Worker is a low-ish level library for Rust for the creation of event-listeners using futures and streams. Notably MW supports non-sync and non-send (i.e. non-thread-safe) contexts within listeners.
-
noosphere-collections
Collection data types that are needed by an efficient implementation of Noosphere's IPLD data structures
-
simple-async-pipe
Aims to provide a simple pipe-like functionality for async code
-
muxado
stream multiplexing protocol
-
vesper
A slash-command framework meant to be used with twilight
-
broadcaster
Broadcasting futures mpmc channel
-
quick_crawler
QuickCrawler is a Rust crate that provides a completely async, declarative web crawler with domain-specific request rate-limiting built-in
-
gentian
proc macro that transforms generators to state machines
-
armature-cron
Scheduled task execution for Armature applications
-
rusty-genius-cortex
Inference engine interaction layer for rusty-genius
-
sigio
signal-based async io
-
merkql-notify
Notification trait and types for merkql event streaming
-
serdes-ai-graph
Graph-based execution and multi-agent orchestration for serdes-ai
-
gimbal_async_cargo
Cargo async linter package
-
amqprs
AMQP 0-9-1 client implementation for RabbitMQ
-
asyncsync
Runtime-agnostic synchronization primitives for asynchronous Rust
-
tokio_interval
基于Tokio实现了 setInterval(callback, ms) 和 setTimeout(callback, ms) 类似于Javascript的API
-
act_rs_tokio
Act.rs Tokio is a minimal Tokio oriented actor framework
-
fluxion-ordered-merge
Generic ordered stream merging utilities for async Rust
-
veecle-os-runtime
Veecle OS Runtime
-
kompact-component-derive
A derive macro for Kompact component definitions
-
hypixel
Rust wrapper for the Hypixel public API
-
openhelm-github
GitHub skill for openhelm: browse repos, issues, PRs, and files
-
async_closure
utilizes the nightly-only feature async_fn_in_trait to imitate async_closures
-
akt
An actors library for Rust and Tokio designed to work with async / await message handlers out of the box
-
async-duplex-channel
An asynchronous duplex communication channel between multiple clients and a single responder in different asynchronous blocks
-
lichess-api
A client library for the Lichess API
-
kumoko
asynchronous server/client crate built on tokio for easy two-way streaming
-
flarrow-builtins
flarrow (flow + arrow) is a rust runtime/framework for building dataflow applications
-
murray
A minimal actor definition macro using Tokio
-
timedmap
A hash map with expiring key-value pairs
-
await_state
A minimal, powerful async state coordination map for Rust — wait for state changes, not just values
-
mobc-lapin
RabbitMQ support for the async mobc connection pool
-
adk-session
Session management and state persistence for Rust Agent Development Kit (ADK-Rust) agents
-
layer0
Protocol traits for composable agentic AI systems
-
tokio-jsonrpc
JSON RPC 2.0 for tokio
-
anyspawn
A generic task spawner compatible with any async runtime
-
debounced
building delayed
Futures and debouncedStreams that wait a given duration before yielding the most recent item -
set_timeout
allows efficiently executing futures after some delay has passed
-
tarpc-lib
An RPC framework for Rust with a focus on ease of use
-
safina-threadpool
Safe thread pool - ARCHIVED: Code moved to
safinacrate -
failsafe
A circuit breaker implementation
-
unblock
A thread pool for isolating blocking in async programs
-
viaduct
A duplex communication channel between a parent and child process, using unnamed pipes
-
adk-rust
Rust Agent Development Kit - Build AI agents in Rust with modular components for models, tools, memory, and more
-
async_msp_lib
Async msp library for iNav and BetaFlight
-
ds-event-stream-rs-sdk
A comprehensive Rust SDK for working with the DS Event Stream, providing high-level abstractions for producing and consuming events from Kafka
-
async-log
Async tracing capabilities for the log crate
-
aggligator-transport-websocket
Aggligator transport: WebSocket
-
limit-agent
Agent runtime for AI applications with tool registry, parallel execution, and Docker sandbox support
-
claude-cli-sdk
Rust SDK for programmatic interaction with the Claude Code CLI
-
stream-utils
Additional stream combinators
-
signal-gateway-assistant
AI assistant traits and types for signal-gateway
-
pantry
Temporary storage for reusing values that may decay
-
pubsub-rs
powerful publish-subscribe (pubsub) system that allows multiple subscribers to receive messages published to specific topics. It is designed to be thread-safe, async-friendly, memory-efficient…
-
async-trait-ext
a procedural macro for async traits
-
awak
A small async runtime for Rust
-
aggligator-monitor
Aggligator link monitor and speed test
-
trinkets
Tool registry and execution system for AI agents - goblin loot and treasures
-
cabal
Hierarchical agent orchestration system - the scheming group
-
saysion
Async session support with pluggable stores
-
associated-async-io
Async IO traits that use futures instead of poll
-
retrier
A wasm-compatible retry library for futures
-
dagrs
follows the concept of Flow-based Programming and is suitable for the execution of multiple tasks with graph-like dependencies. Dagrs has the characteristics of high performance and asynchronous execution…
-
weex_rust_sdk
Professional Rust SDK for WEEX Exchange - AI Wars ready with full API coverage, AI Log upload, Futures trading
-
state-machines
Type-safe state machines with hierarchical states, guards, callbacks, and async support - Rust port of Ruby's state_machines gem
-
prk_eventbus
A lightweight, WebSocket-based event bus for Rust with SQLite persistence
-
rrq-producer
RRQ producer client for enqueuing jobs into Redis
-
mobc-forked
A generic connection pool with async/await support
-
stream-reconnect
Stream-wrapping traits/structs that automatically recover from potential disconnections/interruptions
-
llm-kit-azure
Azure OpenAI provider for LLM Kit
-
crb-download
CRB | Composable Runtime Blocks | Downloader
-
prost-codec
Asynchronous de-/encoding of Protobuf structs using asynchronous-codec, unsigned-varint and prost
-
signald-rust
interface with Signald
-
turbine-llm
Unified Rust interface for multiple LLM providers with growing model support
-
vidi
Fast, robust, flexible, lightweight web framework for Rust
-
enjoin
Powerful syntax-level async join macro
-
cs-utils
Common utilities
-
tokio-thread-pool
A small wrapper around the tokio runtime supporting max concurrency
-
eyeball-im-util
eyeball-im -
mini-c-ares
A minimal Rust wrapper for the c-ares library, for asynchronous DNS requests, based on rust-c-ares
-
syncthing-async
controlling syncthing file synchronization through its REST interface
-
swimos_trigger
SwimOS Asynchronous Trigger
-
tokio-stomp-rs
Asynchronous streaming STOMP client fork
-
kafka-threadpool
An async rust threadpool for publishing messages to kafka using SSL (mTLS) or PLAINTEXT protocols
-
actors-rs
Easily build fast, highly concurrent and resilient applications. An Actor Framework for Rust.
-
tokio-uring-xitca
a fork of tokio-uring with miniaml maintenance
-
dseek
Deepseek cli which utilizy async runtime and can't panic and copy response directly to clipboard
-
gcal_rs
A blazingly fast, hand written Google calendar API in Rust
-
tiny-loop
Minimal AI agent framework
-
monoio-codec
Codec for Monoio
-
maily
easy, quick, and fault tolerant sending of emails
-
toni
Fast and modular web framework for scalable applications
-
rakhas_logger
Async logging library with batch processing and graceful shutdown
-
measured-tokio
Tokio metrics for measured
-
deadline
A one-macro crate to ensure assertions meet their deadlines
-
skelegent
Composable async agentic AI framework for Rust
-
tokio-stream-multiplexor-fork
Stream Multiplexor for tokio with a tcp like interface
-
tokio-stdin-stdout
Thread- and future::sync::mpsc-based AsyncRead/AsyncWrite stdin/stdout with little buffering
-
todc-net
Algorithms for message-passing (HTTP) distributed systems
-
resident-utils
Resident program library
-
bubbles
Bubble integration server for powder diffraction
-
sugars_async_task
Async task utilities and abstractions for the cyrup-sugars ecosystem
-
fluxus-source-gharchive
A Fluxus source component for processing and analyzing GitHub Archive data streams, providing efficient access to historical GitHub event data
-
tirea
Unified umbrella crate for the tirea agent framework
-
tokio-task-scheduler
A non-blocking task scheduler for Rust with fluent API, supporting interval-based and cron-like scheduling
-
armature-push
Push notifications for Armature - Web Push, FCM, and APNS
-
tokise
An asynchronous runtime compatible with WebAssembly and non-WebAssembly targets
-
claude-agent-sdk
Idiomatic Rust SDK for building AI agents powered by Claude Code with full async support, type safety, and security hardening
-
shared_cell
Interior mutability between concurrent tasks on the same thread
-
flowly-service
Flowly is a library of modular and reusable components for building robust pipelines processing audio, video and other
-
enact-plugins
Plugin discovery and loading for Enact — .enact-plugin/ manifest, namespaced commands/skills
-
jittr
A binary heap based jitter buffer implementation for zero latency udp/rtp streams
-
plyne
Based pipeline of async task system
-
daemon-base
A flexible and configurable Rust daemon library with lifecycle management, logging, callbacks, and optional async support. Works on Linux, macOS, and Windows.
-
esrc
Primitives for implementing event sourcing and CQRS systems
-
teloxide-core
Core part of the
teloxidelibrary - telegram bot API client -
compio-driver
Low-level driver for compio
-
polly-scheduler
A robust task scheduling system leveraging Tokio, with built-in fault tolerance, persistence, and recovery capabilities to ensure seamless task management and execution
-
gsc-gcra
High-performance GCRA (Generic Cell Rate Algorithm) rate limiting library
-
taps
taps (Tokio Asynchronous Pub/Sub) is an in-process async message broker that can be used for messaging between spawned tokio tasks
-
clia-rcproxy
A lightweight, fast and powerful Redis Cluster Proxy written in Rust
-
riker-cqrs
Command Query Responsibility Separation for Riker applications
-
ruyi
An event-driven framework for non-blocking, asynchronous I/O in Rust
-
roam-shm-ffi
C bindings for roam shared-memory primitives
-
request_coalescer
An asynchronous request coalescing library for Rust
-
sched-callback
async callback scheduling
-
simple-scheduler
Schedule periodic tasks to run asynchronously
-
passivized_docker_engine_client
Docker Engine Client - manage and run containers, images, and volumes
-
armature-queue
Job queue and background processing for Armature
-
skedgy
asynchronous job scheduler
-
celers-cli
Command-line interface for CeleRS worker and queue management
-
tokio-shared-rt
Allow
#[tokio::test]to use a shared runtime -
futures-map
Futures-based and hashmap-based alogrithms
-
room-cli
Multi-user chat room for agent/human coordination over Unix domain sockets
-
futures-ratelimit
Bounded flavors of futures' FuturesUnordered and FuturesOrdered
-
armature-graphql-client
GraphQL client with subscription support for Armature
-
fluxion-error
Error types for the Fluxion reactive streaming library
-
webrtc-signal-server
General WebRTC signal server For Peer to Peer Communication
-
noob
A WIP futures-based Discord bot library
-
async-graphql-dataloader
A high-performance DataLoader implementation for async-graphql with batching and caching
-
selecting
Cross-platform wrapper over select
-
tokio-agent-memory
Tokio-native agent memory: episodic, semantic, and working memory with decay scheduling, persistence, and multi-agent bus
-
deadpool-bolt
A bolt-client manager for the deadpool connection pool
-
cloud_terrastodon_relative_location
A helper for converting std::panic::Location to relative paths with displayed
-
paho-mqtt-sys
Low-level, unsafe Rust wrapper for the Paho MQTT C Client Library. This is part of the official Eclipse Paho Rust Client Library
-
flarrow-runtime
flarrow (flow + arrow) is a rust runtime/framework for building dataflow applications
-
swimos_utilities
SwimOS Time Utilities
-
zonyitoo/coio
Coroutine scheduler with non-blocking I/O support
-
ai-sdk-rs
AI SDK for Rust with unified model/provider abstractions
-
safina-net
Safe async network functions - ARCHIVED: Code moved to
safinacrate -
wag
Go like sync.WaitGroup implementation in Rust. (sync/async)
-
fut-compat
Offers compatibility between the tokio and async_std runtimes
-
async_io_utilities
An asynchronous IO utilities crate powered by
tokio -
actix-broker
Message broker for the Actix actor framework
-
rumpsteak
Session types for asynchronous communication between multiple parties
-
modal-rs
Unofficial Rust SDK for Modal.com - serverless cloud compute platform
-
termusix
A terminal-based music player with a user-friendly terminal UI, built with Rust
-
ex-futures
An extension of
futures -
fluvio-async-tls
Asynchronous TLS/SSL streams using Rustls
-
runtara-management-sdk
SDK for managing runtara instances (start, stop, signals, images)
-
adk-rs-fluent
Fluent DX for Gemini Live — builder API, operator algebra, composition modules
-
event-listener-strategy
Block or poll on event_listener easily
-
streamweave-error
Error handling system for StreamWeave
-
snapup
Abstractions for handling snapshots with streams of subsequent updates
-
agentlib-orchestrator
Multi-agent orchestration and parallel workflow management for AgentLib
-
faf-core
Fiduciary Agent Framework - Core protocol types and traits
-
oai-rt-rs
Rust SDK for the OpenAI Realtime API
-
tokio-duplex
Combine seperate
AsyncReadandAsyncWritetypes into a singleAsyncRead + AsyncWritetype -
driveshaft
A minimal, high-performance thread pool for running synchronous tasks with per-thread context from async code
-
apalis-nats
Background task processing for rust using apalis and nats jetstream
-
tokio-context
Contexts for cancelling asynchronous tasks using tokio
-
rivulet
Asynchronous contiguous-memory streams
-
pict-rs-futures
async utilities for pict-rs
-
apalis-board-web
Frontend components for managing Apalis task queues
-
avx-events
Event-driven architecture for Avila Experience Fabric - Pub/sub, event bus, and message patterns
-
moduforge-runtime
插件加载、热更新、依赖管理
-
async-raft-ext
An async implementation of the Raft distributed consensus protocol.The ability of raft is enhanced while keeping the access interface unchanged for rnacos
-
singleflight-async
Singleflight in async style
-
turbocharger
Autogenerated async RPC bindings that instantly connect a JS frontend to a Rust backend service via WebSockets and WASM
-
rust-genai-types
Shared types for the Rust Gemini SDK
-
rustmcp
Model Context Protocol (MCP) for building AI agent tools
-
async-gate
A Tokio-powered asynchronous gate (analogous to a flag and highly inspired by Python’s
asyncio.Event, but can be waited for to become ‘false’ too) -
dyn-timeout
Dynamic timeout, cancel, add and remove time before a callback execution
-
solana-pump-grpc-sdk
Solana Pump/PumpAmm gRPC event listener SDK
-
tokio_based
BASED Async Single-threaded Execution Dispatcher
-
pulseengine-mcp-client
MCP client implementation for connecting to MCP servers
-
qbit-api-rs
A asynchronous Rust wrapper for qBittorrent Web API
-
indexed_db_futures
Future bindings for IndexedDB via web_sys
-
axum-sessions
🥠 Cookie-based sessions for Axum via async-session
-
axum-serveplus
High level server designed to be used with axum framework
-
motosan-chat-line
LINE Messaging API channel adapter for motosan-chat
-
catsu
High-performance embeddings client for multiple providers
-
ringolo
An asynchronous runtime built on top of io-uring
-
noie-nds-api
NDS Protocol Buffers types for Rust (generated from nds-api/spec)
-
ceylon-next
A powerful AI agent framework with goal-oriented capabilities, memory management, and tool integration
-
thespis
The interface of the thespis actor model (contains only traits)
-
aligned-task-scheduler
A scheduler that runs tasks at exact minute intervals with an optional offset, ensuring tasks are aligned to precise time boundaries
-
noosphere-storage
Pluggable backing storage for the Rust Noosphere implementation
-
apalis-board-api
HTTP utilities for managing apalis task queues
-
tracing-actix
Allow tracing actor futures in actix
-
veecle-os-test
testing actors in Veecle OS
-
llm-sentinel-api
REST API server with health checks, Prometheus metrics, and query endpoints for LLM-Sentinel
-
rseip-cip
common industry protocol for rseip
-
agner-sup
An actor toolkit inspired by Erlang/OTP (supervisors)
-
serial-thread
Asynchronous, multithreaded serial port communication library using mpsc::cjhannels or async-channels for efficient data handling
-
act-zero-ext
Macros for act-zero
-
strands-agents
Strands AI Agents SDK
-
process-lib
Cross-platform, asynchronous Rust library to run commands in pipelines
-
asyncs-sync
Asynchronous runtime agnostic synchronization utilities
-
ranvier-runtime
Async Execution Engine for Ranvier
-
mm1-node
M/M/1! Queueing, do you speak it?!
-
waterark
Watermark for implementing optimistic SSI (Serializable Snapshot Isolation) transactions
-
per_oxo
A highly reactive chat_server
-
swarm-commander
Manage tons of commands asynchronously
-
tokio-uring
io-uring support for the Tokio asynchronous runtime
-
heph
actor framework based on asynchronous functions
-
uringy
single-threaded concurrency runtime for Rust based on io_uring
-
async-lease
Essentially a futures-oriented Arc<Mutex<Option<T>>>
-
backstage
A framework for building data-driven distributed systems
-
containerd-snapshots
Remote snapshotter extension for containerd
-
enact-cron
Cron scheduling system for Enact agents
-
queen
message queue
-
motosan-chat-agent
AgentLoop and LlmClient trait for motosan-chat
-
kovi-plugin-oai
Kovi 的 OpenAI 兼容 API 聊天插件，支持多智能体管理与符号指令系统。
-
futures-test-sink
Test utilities for futures::sink
-
async-global-executor-trait
executor-trait implementation for async-global-executor
-
tokio-io-mock-fork
Enhanced tokio_test::io::Mock
-
flows-datafusion
Building blocks for flow-based query processing with Apache DataFusion
-
smol-cancellation-token
cancellation token implementation for Smol, copied from tokio-util’s cancellation token, and replace the
wakerwithEventListenerto make it cross async runtime compatible -
tokio-libtls
Tokio bindings for LibreSSL's libtls
-
adk-tool
Tool system for Rust Agent Development Kit (ADK-Rust) agents (FunctionTool, MCP, Google Search)
-
projections
Macro-free pin projections because why not?
-
wasmflow-streams
encapsulating the message packets sent across Wasmflow components
-
feature-extension-for-smol
Feature extension for smol
-
sourcery-core
Core types and traits for the Sourcery library
-
verypoll
Very polling library
-
periplon
Rust SDK for building multi-agent AI workflows and automation
-
tokio-io-compat
Compatibility wrapper around std io traits that implements tokio io traits
-
kx-utils
Common utils incubator
-
nvisy-sdk
Rust client for the Nvisy Server API: authentication, workspace management, and task routing
-
v_exchanges_api_generics
A client for HTTP/HTTPS/WebSocket APIs
-
rocketmq-filter
A filter for RocketMQ messages
-
aeron-rpc
Deadly simple RPC framework built on top of Aeron and Tokio
-
distri
Rust client for the Distri A2A agent platform
-
quarlus-scheduler
Background task scheduler for Quarlus - interval, cron, and delayed task execution
-
ranvier-audit
Tamper-proof audit logging framework for Ranvier
-
batch-renamer
Framework and command line utilities for interactive renaming of a potentially large number of files
-
plumb
A functional, async pipeline framework
-
signalr_rs
SignalR client based on actix web client and async await
-
futures-task
Tools for working with tasks
-
atticus
A mimimal API to create asynchronous actors
-
aide-de-camp
backend agnostic delayed job queue
-
RobotS
Actor framework
-
aws-smithy-http-server
Server runtime for Smithy Rust Server Framework
-
wd_event
event system
-
kapacitor-udf
creating Kapacitor User Defined Functions (UDFs)
-
web-task
The simplest way to run async tasks on the web
-
kubus
Derive based kubernetes operator framework
-
neuron-types
Core traits for AI agents in Rust — Provider, Tool, and ContextStrategy without the framework buy-in
-
kizzasi-inference
Unified autoregressive inference engine for Kizzasi AGSP
-
krabdex
A type-safe, async Rust SDK for the PokeAPI
-
madsim
Deterministic Simulator for distributed systems
-
aligne
A small crate using tokio to synchronize asynchronous request/response with Ids
-
reception
creating TCP listeners that spawns clients providing model abstraction layer
-
flowly-kafka
reusable kafka component for flowly
-
mio_channel
Provide a wrapper of the standard channel that can be polled with Mio
-
git-next
trunk-based development manager
-
job_abstrs
Abstractions for event-driven jobs
-
wasmind_actor_utils_common_messages
Common message types shared between Wasmind actors
-
async-stdin
Asynchronously read from stdin
-
meld-server
Single-port REST + gRPC server framework with FastAPI-like DX for Rust
-
axum-standardwebhooks
Axum extractor that verifies signature for Standard Webhooks
-
flowbuilder-yaml
YAML/JSON dynamic flow loading for FlowBuilder
-
spargio-protocols
Protocol integration companion crate for spargio (tls/ws/quic)
-
arti-rpcserver
Backend functionality for Arti's RPC service
-
runq
Macro-based job orchestrator with distributed locking and automatic retries
-
wookie
Async test/bench toolkit including single stepping executors. No-std compatible.
-
async-cuda-npp
Async NVIDIA Performance Primitives for Rust
-
smithyq
A high-performance async task worker library for Rust - forge your tasks with type safety
-
synkit-core
A fast, syn-like incremental parser framework for Rust
-
callosum
Zero-copy shared memory IPC for Rust
-
countio
Byte counting for std::io::{Read, Write, Seek} and its async variants from futures and tokio
-
hojicha-runtime
Event handling and async runtime for Hojicha TUI framework
-
oxidite-queue
Background job queue with cron scheduling, DLQ, and retry logic for Oxidite
-
openclaw-core
Core types, configuration, and storage for OpenClaw
-
flag-bearer
Generic async semaphores
-
metalmq-client
MetalMQ client library (AMQP 0.9)
-
distributed-config
A robust configuration management library for Rust applications running in distributed environments
-
enact-memory
Local-first memory backends for Enact
-
openraft-rocksstore
A rocksdb based implementation of the
openraft::RaftStoragetrait -
interruptible_polling
General purpose polling tasks with RAII-driven fast clean exits
-
nio-task
async task implementation
-
blocking_pool
A thread pool for running synchronous I/O in asynchronous applications
-
nestforge-schedule
Scheduler support for NestForge
-
dwbhk
dwbhk-rs is a library for working with Discord Webhooks
-
mofa-sdk
MoFA SDK - Modular Framework for Agents. A standard development toolkit for building AI agents with Rust
-
dasein-agentic-core
Core types, Agent runtime, and Protocol for Agentic Framework
-
duende-core
Core daemon lifecycle primitives for the Duende framework
-
task-notify
Notify async tasks when someone mutates data they're interested in
-
compio-ws
WebSocket library for the compio runtime
-
miku-h2
An HTTP/2 client and server
-
alopex-chirps-mock
Mock implementations for testing Alopex Chirps components
-
asyn-retry-policy
Async retry helpers with exponential backoff, jitter, and an ergonomic #[retry] attribute macro
-
elfo-network
Distributed actors for elfo
-
swiftide-docker-executor
A docker executor for swiftide agent tools
-
spawns-executor
Async executors for thread context task spawner
-
tokio-netstring-trait
A trait for tokios AsyncRead to easily read netstrings from streams
-
synth-ai
Rust SDK for Synth AI - serverless post-training APIs
-
oxify
LLM Workflow Orchestration Platform with DAG-based pipelines
-
anet_a2a_server
framework for building Agent-to-Agent (A2A) protocol services
-
latchlm-openai
OpenAI provider implementation for LatchLM
-
atomic-actor
An
Actorwithasync fnhandlers -
riker-patterns
A collection of common actor patterns for Riker
-
bottle
Actor model framework for Rust
-
cancellable
providing a generic cancellable utility
-
async-attributes
Experimental language-level polyfills for Async Rust
-
armature-webhooks
Webhook sending and receiving for Armature
-
futures-async-combinators
toy futures combinators
-
wasmind_llm_types
Common LLM API types and structures for AI actors
-
rspc-axum
Axum adapter for rspc
-
openclaw-agents
Agent runtime and workflow engine for OpenClaw
-
upstox-rust-sdk
SDK to access Upstox's Uplink APIs programmatically
-
async-shared-timeout
Async timeout that can be reset and shared
-
async-waitgroup
Golang like WaitGroup implementation that supports both sync and async Rust
-
rusplay
Memory safe, blazing fast Rugplay library written in Rust
-
frappe
Functional Reactive Programming library for Rust
-
fukurow-streaming
Real-time streaming processing for Fukurow reasoning engine
-
aeth-event
Async based event primitives
-
soul-gateways
Messaging gateway implementations for soul-core agents — Telegram, iMessage, WhatsApp
-
tencentcloud-sms
腾讯云短信服务 Rust SDK - 类型安全、异步高性能的短信 API 客户端
-
orchflow-core
Transport-agnostic orchestration engine for managing terminal sessions, panes, and plugins with an event-driven architecture
-
asyncute
(async execute) can execute async futures globally without per-executor queues
-
tokio-task-manager
Allow an async Tokio application to gracefully shutdown, waiting for all tasks to finish
-
async-task-ffi
Task abstraction for building executors
-
vidi-router
The router for Vidi
-
tokio-stomp
Asynchronous streaming STOMP client
-
llm-kit-deepseek
DeepSeek provider implementation for the LLM Kit - supports chat and reasoning models
-
tirea-extension-reminder
System-reminder injection for persistent cross-turn context in tirea agents
-
alchemy-llm
Unified LLM API abstraction layer supporting 10+ providers through a consistent streaming interface
-
sruim-crewai
A high-performance multi-agent orchestration engine written in Rust
-
async-send-fd
A wrapper for async UnixStream's to send file descriptors
-
pw-telegram-bot-fork
creating Telegram bots
-
django-query
Tools for mocking Django-style endpoints
-
leaves
Distributed ID Allocator
-
js-sys-futures
working with the futures and js-sys crates
-
odem-rs-util
Model elements and statistical tooling for the ODEM-rs simulation framework
-
cuckoo-runtime
An async runtime that mostly runs inside other multi-threaded applications
-
vex-runtime
Tokio-based agent orchestration for VEX
-
compio-signal
Signal handling for compio
-
litellm-rust
Minimal Rust SDK port of LiteLLM – unified interface for chat, embeddings, images, and video across OpenAI-compatible, Anthropic, Gemini, and xAI providers
-
hyper-serve
High level server designed to be used with axum framework
-
eventador
lock-free pub/sub event-bus with sync and async APIs
-
rusty-genius-stem
Orchestrator and event loop for rusty-genius
-
swimos_errors
SwimOS Error Utilties
-
kay
Experimental high-performance actor system framework for Rust
-
safina-executor
Safe async runtime executor - ARCHIVED: Code moved to
safinacrate -
poem-openapi
OpenAPI support for Poem
-
vino-packet
encapsulating the message packets sent across Vino components
-
cloud_terrastodon
A command-line tool for interacting with cloud ecosystems
-
promise_out
promiseOut version for rust
-
rustfs-lock
Distributed locking mechanism for RustFS, providing synchronization and coordination across distributed systems
-
conquer-struct
macros to perform concurrent future resolution, while populating struct fields
-
fulcrum-tools
Fulcrum AI agent framework — tools module
-
dcrocky
A Discord bot library for Rust inspired by discord.js - Rocky Edition
-
hanabi-cli
CLI utilities from interacting with a Hanabi server
-
speed-rs-core
A core HTTP handling server library in Rust, providing low-level HTTP server implementation
-
sync_executor
An async executor which you can use to execute a future that you know will never return
Pendingwhen you poll it -
job_queue
efficient Rust library for handling asynchronous job processing and task queuing
-
avx-async
Revolutionary async runtime - Quantum, Neural Networks, Blockchain, Genetic Algorithms, Zero dependencies
-
futures-cache
Futures-aware cache backed by sled
-
pipebuf_websocket
PipeBuf support for websockets
-
asyncron
Executor agnostic task manager and async scheduler for Rust
-
agnostic-io
agnostic-iodefines I/O traits in agnostic style for any async runtime -
tokio-simple-fixed-scheduler
scheduler to emit events at a fixed interval with tokio
-
catty
Send and await a value asynchronously
-
rustfs-protos
Protocol definitions for RustFS, providing gRPC and FlatBuffers interfaces for communication between components
-
forgeai-adapter-gemini
Gemini adapter for forgeai-rs
-
lune-std-regex
Lune standard library - RegEx
-
futures-io-preview
The
AsyncReadandAsyncWritetraits for the futures-rs library -
yozefu
CLI tool for Apache kafka. It allows you to navigate topics and search Kafka records.
-
git-next-server-actor
Server actor for git-next, the trunk-based development manager
-
tokitai-core
Tokitai core types - Compile-time tool definitions with zero runtime dependencies
-
outfox-openai
Openai for outfox
-
gemini-oxide
A production-grade, fluent Rust SDK for the Google Gemini Headless CLI
-
radarcord-rs
An API wrapper for the Radarcord bot list
-
libmqm-default
IBM® MQ Interface (MQI), Programmable Command Format (PCF) and MQ Administration Interface (MQAI) structure defaults
-
dummy-waker
Get a
core::task::Wakerthat does absolutely nothing -
situwaition
Run a closure continuously, until is succeeds or times out
-
swimos_introspection
SwimOS Agent Introspection
-
streem
creating and consuming streams
-
async-jobs
Asynchronous job orchestration for Rust
-
ferrotunnel-core
Core tunnel implementation for FerroTunnel
-
minima-telegram-notifier
Minimal Telegram notification library for Rust
-
tractor
Actor system modelled after Pony's actors
-
sparkle-impostor
A third party crate for Twilight to execute Discord webhooks that clone an existing message
-
completeio
Completion based IO drivers and async runtime
-
elk-mq
A Message Queue implementation in rust, using Redis as a communication medium
-
kameo-persistence
A persistence add-on for Kameo, a Rust actor framework
-
ai-sdk-openai
OpenAI provider for AI SDK - GPT, DALL-E, Whisper, and Embeddings
-
specta
Easily export your Rust types to other languages
-
edfsm-machine
Tasks and Channels for Event Driven Finite State Machines
-
implicit-await
Implicitly await calls returning Future impls
-
futures-option
Extension traits for dealing with optional futures and streams
-
futures-net
The futures-net library
-
c_mcai_worker_sdk
AMQP Worker to listen and provide trait to process message
-
holiday_event_api
The Official Holiday and Event API for Rust
-
enact-mcp
MCP (Model Context Protocol) client for Enact
-
anthropic-sdk-rust
Comprehensive, type-safe Rust SDK for the Anthropic API with streaming, tools, vision, files, and batch processing support
-
gprs
A set of filtered and optimized Rust libraries creates a foundation for building modern web frameworks
-
valve-rs
Auto-scale R {plumber} APIs concurrently using Tokio, Axum, and Deadpool
-
praxis
High-performance React agent framework for building AI agents with LLM, tool execution, and persistence
-
pacifica-rs
PacificA: Replication in Log-Based Distributed Storage Systems
-
sodium
FRP (Functional Reactive Programming)
-
wtx-ui
Different user interfaces for WTX
-
praxis-mcp
Model Context Protocol (MCP) client for AI agent tool execution
-
mobc-bolt
A bolt-client manager for the mobc connection pool
-
rotor
The mio-based framework for doing I/O in simple and composable way
-
hitbox-actix
Asynchronous caching framework for Actix
-
collections-futures
working with futures through collections types
-
swimos_future
SwimOS Future Utilities
-
shared-tokio-runtime
Shared tokio runtime
-
eventually-postgres
Event Store implementation using PostgreSQL for the Eventually crate
-
noop-executor
No-op executors for async tasks
-
miyabi-workflow
Workflow DSL for Miyabi - Graph-based agent orchestration with .then(), .branch(), .parallel()
-
bililive
stream-based bilibili live client library
-
shutdown_signal
catching shutdown signals within select with multiple tasks in rust async tokio
-
actix-postgres
PostgreSQL integration for Actix framework
-
ruchei-itertools
async itertools, subproject of ruchei
-
async-deferred
A lightweight utility for spawning async tasks with fire-and-forget semantics and deferred result retrieval
-
xo-api-client
Unofficial crate for accessing Xen Orchestra through its API
-
tokio-transports
used for communication between processes
-
vex-adversarial
Adversarial (Red/Blue) agent pairing for VEX
-
monoio-quiche
Asynchronous QUIC implementation for Monoio based on Quiche
-
minimal-executor
A minimal executor for asynchronous tasks based on the futures-rs library
-
flarrow-api
flarrow (flow + arrow) is a rust runtime/framework for building dataflow applications
-
alopex-chirps-gossip-swim
SWIM-based gossip protocol implementation for Alopex Chirps
-
async-rx
functions for async reactive programming
-
merkql-notify-webhook
HTTP webhook notification plugin for merkql
-
laststage
fast, durable, high concurrent HashMap
-
signalfut
A future similar to tokio::signal::unix::Signal, but can be used with all the runtimes
-
slog-scope-futures
slog-scope for
Futures -
go-server-rust-sdk
Rust SDK for go-server distributed task scheduler and worker system
-
smol-axum
Integrations between
smolandaxum -
async-trait
Type erasure for async trait methods
-
cyclic_pipe
providing fixed-size, buffer pre-allocated cyclic pipe which support multi-producer and multi-consumer concurrent access
-
archlinux-repo
Arch Linux repositories parser
-
neuromance
controlling and orchestrating LLM interactions
-
nbchan
Highly optimized non-blocking communication channels
-
sync-utils
A bunch of utilities in async-await and blocking context
-
lustre-executor
A blazingly fast, minimal async executor with pluggable ID generation and I/O support
-
rateflow
A declarative, flexible, and high-performance rate limiting library for Rust
-
vertigo
Reactive Real-DOM library with SSR for Rust
-
shutdown-async
Asynchronous Shutdown
-
reqwest-retry-after
Retry-After header support for reqwest
-
eventastic
opinionated fork of Eventually-rs. It enforces the use of transactions and handles idempotency.
-
tokio-executor-trait
executor-trait implementation for tokio
-
background-jobs-core
Core types for implementing an asynchronous jobs processor
-
akinator-rs
wrapper around the undocumented Akinator API
-
extra_result
Add extra methods to
Resultenum -
oneshot-broadcast
channel that broadcasts a value once without cloning it
-
futures-yamux
The yamux protocol implementation, rewritten from the ground up
-
monoio-compat
A compat wrapper for monoio
-
apalis-board-types
Shared types and data structures used by the apalis-board workspace
-
ai-agents-llm
LLM providers for AI Agents framework
-
orka
An asynchronous, pluggable, and type-safe workflow engine for Rust, designed for orchestrating complex multi-step business processes
-
kafka-rs
Native Rust Kafka client, built upon kafka-protocol-rs and Tokio
-
dabus
Dynamic Aplication Controll Bus - an asynchronous, event based module system for thoes who want to move fast and *not* break things
-
tokio-buf
Asynchronous stream of byte buffers
-
futurify
Convert your sync functions into non-blocking thread futures
-
vss
A dead simple library to allow for easily reused shutdown signal handling
-
merge-io
Merge two separate
AsyncReadandAsyncWriteobjects into a single I/O stream -
rstreams
Async Stream-Processing toolkit with actor model flavor
-
duplexify
Combine a reader + writer into a duplex of Read + Write
-
ticks
ergonomic Rust wrapper for the TickTick Open API
-
peace_rt_model_native
Runtime data types for the peace automation framework
-
piper
An asynchronous single-consumer single-producer pipe for bytes
-
uika-runtime
Safe Rust runtime for uika (object refs, lifecycle, dynamic calls)
-
praxis-llm
Provider-agnostic LLM client with OpenAI/Azure support and streaming
-
tower-sesh
A Tower middleware for strongly typed, efficient sessions
-
agnostik
Executor Agnostic Runtime that can run your futures with your favourite Executor
-
neuron-op-react
ReAct operator for neuron — model + tools in a reasoning loop
-
dialectic-compiler
Session type macro compiler for the Dialectic crate
-
actix-limiter
Rate limiter using a fixed window counter for arbitrary keys, created for Actix Web
-
zino-openapi
OpenAPI support for zino
-
compio-process
Processes for compio
-
tokio-rustls-fork-shadow-tls
Asynchronous TLS streams wrapper for Tokio based on Rustls
-
space-traders
Async SpaceTraders API client for Rust
-
syndicate
Syndicated Actor model for Rust, including network communication and Dataspaces
-
pi_async
Based on future (MVP), a universal asynchronous runtime and tool used to provide a foundation for the outside world
-
elicit_server
Cross-crate workflow plugins for elicitation — code recovery, multi-crate compositions, and server-side orchestration
-
alopex-chirps-raft-storage
Raft log storage implementation for Alopex Chirps using alopex-core
-
webrocket
A closure focused WebSocket server implementation
-
fiddlesticks
Primary library for the fiddlesticks agent harness framework
-
nuitrack-rs
Rust bindings for the Nuitrack SDK, enabling skeletal tracking, gesture recognition, and other computer vision capabilities
-
wasmind_actor_loader
Dynamic actor loading and dependency resolution for Wasmind
-
pptr
Type-Driven Asynchronous Actor Runtime
-
async_tasks_state_map
A struct for recording execution status of async tasks with async methods
-
llm-sentinel-ingestion
Kafka ingestion, OTLP parsing, and telemetry validation for LLM-Sentinel
-
async-os-pipe
Cross platform implementation of a bidirectional async pipe
-
skg-tool
Tool interface and registry for skelegent
-
trale
minimalistic Rust async executor using io_uring for efficient, correct task execution
-
motosan-chat-web
Axum/SSE web channel adapter for motosan-chat
-
flows-http
Building blocks for flow-based HTTP requests & responses
-
jules-rs
Production-grade Rust client for the Jules API
-
tastyworks
Unofficial Tastyworks API
-
seesaw-kafka
Kafka backend for Seesaw event-driven orchestration
-
tor-rpc-connect
Common implementation logic for Arti RPC Connect points
-
actm
Tiny async actors framework for rust
-
futuresdr-pmt
Polymorphic Types for an Experimental Async SDR Runtime for Heterogeneous Architectures
-
kvarn-tokio-uring
Temporary Kvarn fork: io-uring support for the Tokio asynchronous runtime
-
rdma
Low-level RDMA API
-
tarpc-bincode-transport
A bincode-based transport for tarpc services
-
woven
set of async combinators, usable in a no_std environment
-
async-drop-guard
offers hash map and cache data structures where individual entries can be locked
-
bongonet-runtime
Multithreaded Tokio runtime with the option of disabling work stealing
-
tokio-rustls-wasi
Asynchronous TLS/SSL streams for Tokio using Rustls
-
async-read-length-limit
limit the size of an async read
-
ultrafast-mcp-transport
Transport layer for UltraFast MCP
-
spargio-process
Process companion crate for spargio
-
autoagents-protocol
Agent Framework for Building Autonomous Agents
-
async-shell
Asynchronous process child wait
-
throttled-reader
An io::Read proxy that limits calls to read()
-
tokio-eld
Histogram-based sampler for recording and analyzing event loop delays
-
agner-utils
An actor toolkit inspired by Erlang/OTP (utils)
-
axum-realtime-kit
A toolkit for building scalable, real-time applications with Axum, WebSockets, and Redis Pub/Sub
-
generic-api-client
A client for HTTP/HTTPS/WebSocket APIs
-
aral
Async Runtime Aggregation Layer
-
futures-util-io-peek
AsyncPeek trait
-
islabtech-upw-sensor-v1
Rust client library for remote control of the ISLabTech UPW Sensor v1
-
mixtape-anthropic-sdk
Minimal Anthropic API client for the mixtape agent framework
-
librdkafka-sys
Native bindings to the librdkafka library
-
ubl-office
Execution environment for LogLine Agents: lifecycle, memory, and I/O coordination
-
yaar
asynchronous runtime optimized around configuration and no_std
-
limitation-actix-middleware
An Actix web middleware for rate limiting requests using a fixed window counter keyed on a header
-
causality
Event Driven Architecture Traits
-
smol-potat
Proc macro for smol runtime
-
quarlus-events
In-process typed event bus for Quarlus - publish/subscribe with async handlers
-
eternal
Framework
-
actix-raft
Raft distributed consensus protocol using the Actix actor framework
-
tokio-shield
Prevent futures from being aborted by wrapping them in tasks
-
limitation
A rate limiter using a fixed window counter for arbitrary keys, backed by Redis
-
monoio-native-tls
Asynchronous TLS streams wrapper for Monoio based on NativeTLS
-
rosey-actors
Actor framework
-
absinthe
Are you an Actor & Async junkie? Then your app needs some Absinthe!
-
openraft-legacy
Legacy compatibility layer for deprecated Openraft APIs
-
tokio_delayed_queue
Asynchronous delayed queue for Tokio runtime
-
speedbump
An extensible rate limiting library
-
rust-freely
An asynchronous wrapper for the WriteFreely/Write.as API
-
ai-agents-runtime
Runtime agent and builder for AI Agents framework
-
fluke-io-uring-async
An abstraction on top of io-uring
-
string-adapter
String adapter for casbin-rs
-
poolparty
Added functionality for the
futures::executor::ThreadPoolfutures executor -
datafusion-dist
A distributed streaming execution library for Apache DataFusion
-
fastpool
This crates implements a fast object pool for Async Rust
-
adk-plugin
Plugin system for ADK-Rust agents
-
task-stream
a global task executor, run in
no_std -
libindigo-sys
Rust FFI bindings for the INDIGO system library generated by bindgen
-
ebus
Basic Event Bus implementation
-
fluxion-runtime
Runtime abstraction for async Rust streams
-
peace_items
Collection of items the peace framework
-
garcon
A collection of trait and classes to make your thread or async function wait
-
openclaw-providers
AI provider clients for OpenClaw (Anthropic, OpenAI, etc.)
-
skg-turn
Shared toolkit for building operators — Provider trait, types, context strategy
-
cg-game-server
help build CodeGame game servers
-
extend-pinned
Extend but for Pin
-
peace_cmd_model
Data types for commands for the Peace framework
-
wtx-apis
A set of API collections based on the wtx framework
-
actix-mqtt-client
A MQTT client based on the actix framework
-
genawaiter2-macro
Convenience macros for generators (genawaiter2)
-
agner
An actor toolkit inspired by Erlang/OTP
-
smol-hyper
Integrations between smol and hyper
-
fluke-buffet
Buffer management for the
flukecrate -
request-channel
Async MPSC request-reponse channel
-
asupersync-conformance
Conformance test suite for async runtime specifications
-
oats-framework
Universal architecture pattern for infinite scale across any domain - Objects • Actions • Traits • Systems
-
flowly-flv
FLV format streaming parser
-
tezaursapi
api wrapper for tezaurs.lv
-
retry_fn
retry function with versions for blocking or non-blocking, tokio or async-std
-
floxide-macros-support
A directed graph workflow system in Rust
-
rustic-ai
A Rust-native agent framework with tool calling, streaming, and multi-provider support for OpenAI, Anthropic, Gemini, and Grok
-
async-actor
actor framework for Rust
-
tokitai-mcp-server
MCP server scaffolding for Tokitai - Build AI-callable tool servers with zero runtime overhead
-
fulcrum-guard
Fulcrum AI agent framework — guard module
-
noveum-ai-gateway
A high-performance AI Gateway proxy for routing requests to various AI providers, offering seamless integration and management of multiple AI providers
-
wasmrs-runtime
Base host and client implementations of the wasmRS RSocket protocol
-
ws-gonzale
Naive websocket server implemented using async / await
-
raftlog
distributed replicated log based on the Raft algorithm
-
async-i3ipc
Bindings for i3 and async-std allowing async applications to communicate with i3 over it's IPC interface. Contains futures implementations and convenience functions for working with i3.
-
parity-runtime
Tokio runtime wrapper
-
lune-std-luau
Lune standard library - Luau
-
monoio-rustls-fork-shadow-tls
Asynchronous TLS streams wrapper for Monoio based on Rustls
-
futures-util-either
futures_util::future::Either Ext
-
adk-artifact
Binary artifact storage for Rust Agent Development Kit (ADK-Rust) agents
-
tarpc-plugins
Proc macros for tarpc
-
sayiir-persistence
Pluggable persistence backends for Sayiir workflow snapshots
-
runtara-workflow-stdlib
Standard library for runtara workflow binaries - combines agents and runtime
-
tower-sessions-file-store
Store sessions for Tower Session store on the file system
-
taskwait
Runtime agnostic way to wait for a group of async tasks
-
futures-rate
easy tools to help Rust applications guide critical resources or code paths from being overwhelmed
-
task-local
storage for asynchronous tasks
-
enact-redis
Redis-backed InboxStore, StateStore, and SignalBus for Enact
-
clia_deepseek_rs
client library for the DeepSeek API (use rustls)
-
coerce-k8s
Kubernetes discovery provider, automatically discover cluster peers hosted in Kubernetes, based on a configurable pod-selection label
-
troupe
modelling Rust applications with actors
-
metatrait
RPITIT Monads
-
astrid-events
Event bus for Astrid secure agent runtime
-
atomic-waker
A synchronization primitive for task wakeup
-
stalk
sending serialized data with tokio
-
lancor
Rust client for llama.cpp's OpenAI compatible API server
-
futures-await-test-preview
Async test support for Rust through a procedural macro. This crate defines the
#[async_test]attribute to make writing tests that use async/await easier. -
tokio-util_wasi
Additional utilities for working with Tokio
-
mutiny-rs
API wrapper for the Stoat chat platform
-
jsonrpc-rs
Futures base jsonrpc server/client framework
-
async-compression
Adaptors between compression crates and Rust's modern asynchronous IO types
-
dasein-agentic-mcp
MCP (Model Context Protocol) client for tool integration
-
rseip-eip
encapsulation protocol for rseip
-
crb-send
CRB | Composable Runtime Blocks | Send
-
diath
light-weight library for communication between tokio async tasks
-
safina-select
Safe async select function, for awaiting multiple futures - ARCHIVED: Code moved to
safinacrate -
retry-strategy
A better asynchronous retry tool based on Tokio
-
agnostic-process
Agnostic abstraction layer of
std::processfor any async runtime -
v_exchanges_adapters
Implementations of HTTP/HTTPS/WebSocket API methods for some crypto exchanges, using crypto-botters framework
-
tokio-async-drop
macro to enable async drop in a tokio multithreaded runtime
-
puteketeke
An asynchronous runtime built on smol
-
stream-future
Implement an async iterator with return value
-
tower-resilience-core
Core infrastructure for tower-resilience: events, metrics, and shared utilities
-
agreed
Fork of async-raft, the Tokio-based Rust implementation of the Raft protocol
-
zino-connector
Unified connector to data sources for zino
-
futuresdr-remote
Remote interaction library for FutureSDR
-
enact-skills
Skills system with TOML manifests for Enact
-
claude-client
client for the Anthropic Claude API
-
eventsourcing
Event Sourcing for Rust
-
rrq-protocol
Shared RRQ runner protocol types
-
ffi_rpc
Use FFI with RPC
-
tasker_service
a service for executing time based commands
-
novel-openai
Openai for novel
-
oricalchum
A lightweight actor model
-
gasket-prometheus
Prometheus metric exporter for the Gasket framework
-
flurx
Create reactive asynchronous data flow
-
tokio-macros
Tokio's proc macros
-
async-compatibility-layer
an abstraction layer for using both async-std and tokio
-
d3
A framework for server development
-
zino-http
HTTP requests and responses for zino
-
mlg
An asynchronous Log for Rust
-
tokio-fusion
A high-performance thread pool service based on Tokio
-
id_list_txt_reader
read a txt
-
telegram-bot-ars
creating Telegram bots
-
rust-genai-macros
Procedural macros for the Rust Gemini SDK
-
shared_stream
easily cloneable streams
-
agentlib
Modular and extensible framework for building sophisticated AI agents in Rust
-
forgeai
Unified Rust SDK for multi-provider GenAI
-
core-futures-tls
A libcore wrapper allowing async/await to be used from no_std crates
-
cute-async
Cute async utilities
-
bevy-async-runner
Bevy Async Runner simplifies working with asynchronous code in the Bevy game engine. It provides a mechanism to schedule and execute async tasks and provide their result to any system.
-
ranvier
Typed Decision Engine facade crate for Ranvier
-
tracing-actix-web2
Rust tracing adapter for Actix Web
-
thread-async
Execute a task in a new thread and await the result asynchronously
-
rt-local
Thread local asynchronous runtime working with platform-specific event loops
-
io2
single threaded async-io library
-
cloud_terrastodon_config
Configuration helpers for the Cloud Terrastodon project
-
worst-executor
A spin-loop like executor for async
-
fulcrum-core
Fulcrum AI agent framework — core module
-
llm-kit-core
Core functionality for the LLM Kit - unified interface for building AI-powered applications
-
onetime
(aka. oneshot) async spsc channel
-
spargio-tls
TLS companion crate for spargio (rustls/futures-rustls bridge)
-
openhelm-sdk
Trait definitions and types for building openhelm skills and tools
-
hookable
A thread-safe hook system that allows registering and executing sync and async hooks
-
latchlm-gemini
Google Gemini provider implementation for LatchLM
-
allora-core
Core primitives for Allora: messages, exchanges, channels, processors, patterns (EIP) for Rust integration flows
-
stream-kmerge
K-way merge for streams
-
tigerbeetle-unofficial-core
Safe low level callback-based async bindings to tigerbeetle client library
-
rip-starttls
Sans I/O implementation of https://duesee.dev/p/avoid-implementing-starttls/
-
pyridis-api
iridis, with python
-
context-rs
Pass values down the async call stack, with no_std and no_alloc support
-
wasmind_actor_utils
helpers for building Wasmind actors in Rust
-
elfo-utils
Some utils for the elfo system
-
circulate
Lightweight PubSub framework that supports both sync and async
-
connection
A TCP connection that can read and write serializable data
-
genawaiter-macro
Convenience macros for generators (genawaiter)
-
async_object
Async Object wrapper
-
crossflow_diagram_editor
Frontend for crossflow diagrams
-
channels-io
Async agnostic/Sync IO & buffer management abstractions
-
smartpoll
A 'Task' abstraction that simplifies polling futures
-
claude-code-rs
Rust rewrite of the official Anthropic Claude Agent SDK (Python). Wraps Claude Code CLI via subprocess with bidirectional JSON streaming.
-
flourish-unsend
Convenient and full-featured signals for Rust (thread-local variant)
-
rasi-spec
The Official RASI Specification Test Suite
-
async-time-mock-smol
Mockable time for use in async runtimes (smol compatibility)
-
mediatrix
Strongly typed, extensible event mediator
-
agent-core-temp
A modular Rust execution engine for AI agents
-
fws_actors
fastwebsockets clients and servers in actors
-
linkd
actor model framework that takes inspiration from OTP in the erlang ecosystem
-
rust-with-kafka-tls
Rust messaging with a Strimzi Kafka cluster secured with self-signed tls assets for encryption in transit with mTLS for client authentication
-
async_channel_io
AsyncReadandAsyncWriteimplementations forasync_channel -
mm1-core
M/M/1! Queueing, do you speak it?!
-
fundamentum-sdk-api
HTTP client targeting Fundamentum IoT devices RestAPI
-
async-priority-queue
An async-aware priority queue
-
disposition_svg_model
Data types for disposition to represent SVG elements
-
async-throttle
Asynchronous Rate Limiting
-
tactix
Actor Model based on Tokio
-
signal-gateway-assistant-claude
Claude AI implementation of signal-gateway-assistant
-
latchlm-openrouter
OpenRouter provider implementation for LatchLM
-
tokio-run-until-stalled
Extends Tokio with run_until_stalled functionality
-
mikrotik_api
& minimal client to connect and interact with Mikrotik RouterOS API, usually exposed on port 8728
-
stream-ext
An extension trait for Streams that provides a variety of convenient combinator functions
-
tokio-stream_wasi
work with
Streamandtokio -
tokio-utils
Tools for asynchronous programming in Tokio applications
-
ultrafast-mcp-auth
Authentication and authorization for ULTRAFAST MCP
-
dstream
DelayedStream - delays items and drops same items coming within given interval
-
forgeai-adapter-anthropic
Anthropic adapter for forgeai-rs
-
flows-video
Building blocks for flow-based video processing
-
opendht
API for OpenDHT
-
scoped_spawn
Full structured concurrency for asynchronous programming
-
one_for_one
supervize spawn'ed async tasks
-
oxify-api
GraphQL and REST API server for OxiFY AI orchestration platform
-
tonic
A gRPC over HTTP/2 implementation focused on high performance, interoperability, and flexibility
-
futures-stable-preview
futures which support internal references
-
hyperstack-sdk
Rust SDK client for connecting to HyperStack streaming servers
-
local-pool-with-id
A minor variation on a LocalPool executor which exposes unique IDs for tracking future completion
-
axum-router-plugin
Shared library-based plugins for Axum
-
async-dup
Duplicate an async I/O handle
-
muxi-rust
Rust SDK for MUXI AI platform
-
stream-guard
RAII wrapper around Stream that invokes a custom action on drop
-
paging-stream
consume paginated data sources as a
futures::Stream -
untokio
Automatically create tokio runtimes
-
coachman
rust asynchronous task manager built on top of tokio framework
-
waaaa
WebAssembly, Abstracted Away
-
luring
io-uring abstraction using tokio's AsyncFd
-
jenner
Tools for working with generators to work with both iterators and streams
-
async-stream-http-tunnel-grader
Asynchronous stream http tunnel grader
-
tokio-tasker
Lets you stop and join groups of Tokio tasks
-
zino-auth
Authentication and authorization for zino
-
daimon-provider-azure
Azure OpenAI provider for the Daimon AI agent framework
-
async_dag
An async task scheduling utilitiy
-
stream-cancel
interrupting asynchronous streams
-
kimojio-tls
Kimojio OpenSSL integration
-
eden-skills-core
Core domain logic for eden-skills: config, plan, lock, reactor, adapter, registry, and safety
-
completeq-rs
An alternative to passing messages between asynchronous tasks
-
enact-grpc
gRPC server for Enact runtime service
-
axum-limit
A rate limiting library using token buckets, centered around extractor-based limits for async web applications
-
zino-storage
Files and storage services for zino
-
local-runtime
Thread-local async runtime
-
interlink
Framework for writing async code
-
crb-agent
CRB | Composable Runtime Blocks | Agent
-
rusplay_collector
Rugplay application to automatically collect rewards from multiple users
-
kafka4rs
Pure‑Rust client for Apache Kafka 4.0+ – drop‑in replacement for librdkafka, powered by Tokio and zero‑copy buffers
-
awaur
Asynchronous Web API Utilities for Rust
-
taskline
distributed task queue for Rust
-
async-event-rs
that mimics C#'s async event model
-
vex-cli
Vex — manage agent work streams
-
async-barrier
An async barrier
-
ai-agents-reasoning
Reasoning and reflection capabilities for AI Agents framework
-
crossword_generator
generating crossword from provided words
-
io-process
Set of I/O-free coroutines and runtimes to manage processes
-
oxidite-core
Core HTTP server and routing for the Oxidite v2 web framework
-
tokio-compat-02
Tokio 0.2 compat utilities
-
stream-operators
a collection of selected rxjs operators for rust standard Stream
-
yaaf
Actor Framework
-
adk-memory
Semantic memory and search for Rust Agent Development Kit (ADK-Rust) agents
-
platz-sdk
Platz.io SDK
-
meld-core
Core domain types, state, and error model for the Meld framework
-
toki-no
A minimal and fast async runtime, written in pure Rust
-
wta-reactor
Reactor for the what-the-async runtime
-
neuromance-cli
Interactive command-line interface for LLM interactions
-
async_main
Runtime-agnostic async main proc macro
-
puppet
actor framework which uses no dynamic dispatch or boxing
-
async-subscription-map
Async bookkeeping datastructure for state subscriptions
-
tanukie
🦀 Lightweight, blazing-fast LLM client
-
hsipc
High-performance inter-process communication framework in Rust
-
baichun-framework-rms
A high-performance, extensible message system module for Baichun-Framework, supporting multiple message brokers
-
adk-ralph
Ralph - Multi-Agent Autonomous Development System powered by ADK-Rust
-
veilid-async-tls
Asynchronous TLS/SSL streams using Rustls
-
futuresdr-types
Polymorphic Types for an Experimental Async SDR Runtime for Heterogeneous Architectures
-
aspartam
Minimalistic actor framework based on tokio, inspired by actix
-
tauri-plugin-rspc
Tauri adapter for rspc
-
neuron-tool
Tool interface and registry for neuron
-
txrx
take on the C++ unified executors proposal
-
channel-sender
Channel Sender
-
plctag-async
async wrapper for libplctag
-
rusty-genius-teaser
Testing harness and verification for rusty-genius
-
async-openai-alt
OpenAI
-
tower
modular and reusable components for building robust clients and servers
-
tiny-agent-rs
A lightweight, type-safe Rust agent library for LLM tool calling
-
ticked_async_executor
Local executor that runs woken async tasks when it is ticked
-
async-thread
Futures version of std::thread
-
smol-timeout2
A way to poll a future until it or a timer completes
-
sync_stream
Aggregate multiple streams by polling stream items in order, keeping the consumption of multiple streams in sync
-
aiven_rs
sdk to interact with aiven-cloud apis
-
armature-events
Event bus and pub/sub for Armature applications
-
chunnel
Async mpmc(multi producer multi consumer) channel
-
sayiir-postgres
PostgreSQL persistence backend for Sayiir workflow engine
-
io_uring_actor
Near-zero overhead pipelined io_uring api via actor model so you don't have to use Arc<Mutex<IOUring>>
-
llm-stack-anthropic
Anthropic Claude provider for the llm-stack SDK
-
fusio-core
core trait for Fusio library
-
async-macros
Macros for async-std
-
taskio
Abstractions for non-blocking tasks and IO
-
vex-llm
LLM provider integrations for VEX
-
ceylon-runtime
A Rust-based agent mesh framework for building local and distributed AI agent systems
-
spargio-signal
Signal companion crate for spargio
-
floxide-timer
Timer node abstractions for the floxide framework
-
swiftide-langfuse
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
tokiactor
tokio based Actor framework
-
embacle-copilot-sdk
Vendored fork of copilot-sdk-rust — Rust SDK for GitHub Copilot CLI
-
delay
A collection of trait and classes to make your thread wait (and timeout)
-
aldrin
Message bus for service-oriented RPC and interprocess communication
-
must-done
An experimental Future that is guaranteed to be done
-
redis-asio
Asynchronous Redis driver based on tokio
-
o5m-stream
streaming async o5m decoder
-
actix-storage-sled
actix-storage based on sled
-
crb-pipeline
CRB | Composable Runtime Blocks | Pipeline
-
rusty-gql
Schema first GraphQL Library for Rust
-
async-nats-tokio-rustls-deps
Fork of Asynchronous TLS/SSL streams for Tokio using Rustls
-
casus
containing a handful of event-based async primitives
-
agentic-llm
LLM adapters for OpenAI, Anthropic, Gemini, Ollama
-
clia-async-openai
OpenAI (with rustls)
-
skulk
MCP (Model Context Protocol) connection manager - sneaking connections to the outside
-
asyncio-utils
Support limit,skip on AsyncRead traits
-
allora-runtime
Allora runtime and DSL implementation (internal crate)
-
notifsh
Rust SDK for notif.sh - managed pub/sub event hub
-
barrage
An async broadcast channel
-
bitbit
Bit-at-a-time reader/writer types
-
noesis-core
Core traits and types for the Tryambakam Noesis consciousness engine platform
-
simple-async-local-executor
A single-threaded polling-based executor suitable for use in games, embedded systems or WASM
-
futures-to-stream
Turn heterogeneous Futures of same associated Output type to a stream
-
epoxy_frp
The Reactive Glue for Frontend Applications
-
coerce-redis
Redis actor persistence provider for Coerce. Supports event sourcing and snapshots
-
cloud_terrastodon_hcl_types
Helper types for interacting with HCL for the Cloud Terrastodon project
-
enfipy-tigerbeetle-core
Safe low level callback-based async bindings to tigerbeetle client library
-
fulcrum-providers
Fulcrum AI agent framework — providers module
-
async-rwlock
Async reader-writer lock
-
kuri
An SDK for building MCP servers, focused on elegant developer experience, where tools and prompts are just plain old Rust functions
-
compio-dispatcher
Multithreading dispatcher for compio
-
tokio-async-std
An async-std that can fit into tokio ecosystem straight ahead
-
background-jobs
asynchronous background jobs implemented with pluggable backends and runtimes
-
hash_events
An MPMC event system that allows for custom events. Events are emitted with a payload, and subscribers to that event are stream of payloads. For each event, all subscribers are triggered.
-
skg-context
Context strategy implementations for skg-turn
-
flows-audio
Building blocks for flow-based audio processing
-
awaken
Coalescing cross-thread wakers for mio and io_uring
-
unsend
A thread unsafe runtime for thread unsafe people
-
skg-state-memory
In-memory StateStore implementation for skelegent
-
overclock
A framework for building data-driven distributed systems
-
tower-resilience-router
Weighted traffic routing for Tower services - canary deployments and progressive rollout
-
rio_rt
A minimal async runtime with an experimental ambition to be an portable and interoperable async runtime for Rust
-
lucia-apis
A set of API collections based on the lucia framework
-
wayland-protocols-async
Wayland client protocols implemented in async as handlers using the Actor-model and tokio messaging
-
miyabi-llm-openai
OpenAI GPT SDK for Miyabi LLM - Unified LLM interface for Rust
-
elfo-dumper
Dumps messages of the elfo system on disk
-
deno_core
A modern JavaScript/TypeScript runtime built with V8, Rust, and Tokio
-
elfo-configurer
Loads and distributes configs across the elfo system
-
waker-waiter
async runtimes interoperate with arbitrary futures
-
ai-agents-state
State machine for AI Agents framework
-
ruw
Read-Update-Write
-
supertrees
Supervision trees for Tokio-based services inspired by Erlang/OTP
-
axum-flash
Web framework that focuses on ergonomics and modularity
-
futures-enum
#[derive(Future, Stream, Sink, AsyncRead, AsyncWrite, AsyncSeek, AsyncBufRead)] for enums
-
enact-cluster
Distributed worker-node cluster components for Enact
-
patchable-async-sleep
An async sleep function, patchable to the preferred runtime
-
fluxion-merge
Merge multiple Fluxion streams with ordering guarantees
-
async-core
A standard for async runtimes
-
agreed-memstore
An in-memory implementation of the
agreed::RaftStoragetrait. Fork of async-raft’s memstore crate. -
async-dispatcher
async runtime based on a pluggable dispatcher
-
openraft-rt-tokio
Tokio runtime implementation for Openraft
-
starflask
Rust SDK for the Starflask AI agent platform
-
motosan-chat-ai
motosan-ai adapter (LlmClient) for motosan-chat
-
async_event_streams
Asynchronous Events Pub/Sub Library
-
qhook
Lightweight webhook gateway and workflow engine with queue, retry, and signature verification
-
tirea-extension-mcp
Model Context Protocol (MCP) client integration for external tool servers
-
marlin-sdk
Marlin SDK
-
celers-core
Core traits and types for CeleRS distributed task queue
-
yash-executor
single-threaded concurrent task executor
-
tokio-agent
Agents are a simple abstraction around state, inspired by Elixir's Agent
-
smol-macros
Macros for setting up a smol runtime
-
rt-gate
A tiny wrapper for async runtimes
-
synerlogikos
A high-level, generic, abstracted Rust library for building any integration. It is designed to abstract away common patterns found in all integrations multiple times.
-
thetvdb
API async client
-
fluxus-runtime
Runtime implementation for Fluxus stream processing engine
-
holidayapi_rust
A HolidayAPI library for Rust
-
miyabi-llm-anthropic
Anthropic Claude SDK for Miyabi LLM - Unified LLM interface for Rust
-
ethercat-device-control
A command line utility to control Ethercat devices
-
horizons-ai
Async Rust SDK for the Horizons REST API
-
mycorrh
fast concurrent messaging system for Rust
-
swiftide-docker-service
A docker executor for swiftide agent tools
-
tokio-async-utils
Async utils such as TaskHandle type that aborts task on handle drop
-
async-native-tls-2
Native TLS using futures
-
swimos_meta
SwimOS Metadata API
-
lmonade-runtime
Actor-based runtime for LLM inference orchestration and resource management
-
openraft-rt-monoio
monoio AsyncRuntime support for Openraft
-
flynn-openai
OpenAI
-
suspend
A common mechanism for suspending a thread or a Future until notified
-
zino-extra
Extra utilities for zino
-
agner-reg
An actor toolkit inspired by Erlang/OTP (reg)
-
awaitable-error
Awaitable type with input and output that can be stored in container
-
isoprenoid
signals runtime framework backing flourish
-
llm-stack-ollama
Ollama local model provider for the llm-stack SDK
-
mcprs
Model Context Protocol para Rust - Uma biblioteca unificada para comunicação com diferentes LLMs e APIs de IA
-
noesis-sdk
Rust SDK for Selemene Engine — typed API client, profile management, credential storage, and report rendering
-
miyabi-llm-core
Core traits and types for Miyabi LLM - Unified LLM interface for Rust
-
async-native-tls-alpn
Native TLS using futures
-
daimon-core
Core traits and types for the Daimon AI agent framework — implement Model to add providers
-
smol-executor-trait
executor-trait implementation for smol
-
tower-buffer
Buffer requests before dispatching to a
Service -
agent-air-runtime
Core runtime for agent-air - LLM orchestration, tools, and permissions (no TUI dependencies)
-
tower-resilience
Composable resilience and fault-tolerance middleware for Tower services
-
peace_cmd
Command structure for the Peace framework
-
flowbuilder-runtime
Advanced runtime features for FlowBuilder
-
agner-test-actor
An actor toolkit inspired by Erlang/OTP (test-actor)
-
futures-quic
quic protocol backed by Quiche
-
flows-text
Building blocks for flow-based text processing
-
anchor-chain
A statically typed async framework for building LLM-based applications
-
roam-core
Core implementations: ReliableLink, ReliableAcceptor, Session
-
poller
File I/O events library for Rust
-
aiur
Single threaded async executor with structured concurrency
-
async-executor-trait
executor-trait implementation for async-std
-
aeth-task
Tasking system for aeth-rs
-
screeps-async
Tick-aware Async runtime for Screeps
-
bongonet-timeout
Highly efficient async timer and timeout system for Tokio runtimes
-
async-graphql-rocket
async-graphql for Rocket.rs
-
ai-agents-skills
Skill system for AI Agents framework
-
arti-bench
benchmarking utility for Arti
-
reqwest-eventsource
Helper to build an Eventsource using reqwest
-
axum-macros
Macros for axum
-
tower-timeout
Apply a timeout to requests, ensuring completion within a fixed time duration
-
futures-waitmap
future-based concurrent event waiting hashmap
-
future-metrics
Instrument futures with execution metrics
-
cloud_terrastodon_azure_devops_types
Types for modelling Azure DevOps for the Cloud Terrastodon project
-
elfo-pinger
Pings groups of the elfo system
-
peace_resource_rt
Runtime resources for the peace automation framework
-
comet-eventbus
strong-typed sync and asynchronous eventbus
-
geese_executor
Asynchronous executor with Geese event system integration
-
extern_executor
Async executor which delegates futures polling to external event-loop
-
zeal-sdk
Rust SDK for Zeal Integration Protocol (ZIP)
-
openai-agents-rust
Harmony-aligned, OpenAI-compatible agent orchestration in Rust with tools, realtime, and voice
-
async-component
Zero overhead reactive programming
-
fsdr-blocks
Building blocks for FutureSDR signal processing library for SDR and real-time DSP
-
sittard
Sans-IO tickless async runtime, fully deterministic
-
axum-tungstenite
WebSocket connections for axum directly using tungstenite
-
background-jobs-server
Jobs processor server based on ZeroMQ
-
peace_webi_rt
Web interface runtime data types for the peace automation framework
-
llm-stack-openai
OpenAI GPT provider for the llm-stack SDK
-
rustfs-rio
Rio is a RustFS component that provides a high-performance, asynchronous I/O framework for building scalable and efficient applications
-
task-executor
A task executor
-
futures-diagnose
Wraps around a Spawn and provides lots of diagnostics
-
async-graphql-axum
async-graphql for axum
-
futures-executor-preview
Executors for asynchronous tasks based on the futures-rs library
-
async-exec
async task executor with a built-in HTTP task monitor
-
flarrow-message
flarrow (flow + arrow) is a rust runtime/framework for building dataflow applications
-
spawns-core
Async runtime agnostic thread context task spawner for Rust
-
uasync
fast, safe, async executor
-
kabuki
Name reservation
-
ero
Erlang-inspired framework for organizing async code in a fault-tolerant way
-
gritlab
Gitlab rust API sdk
-
openraft-rocksstore-compat07
A example v07 compatible implementation of the
openraft::RaftStoragetrait -
mini-tokio
basic asynchronous rust executor
-
flows-dns
Building blocks for flow-based DNS resolution
-
msft-runtime
Windows async helpers
-
tokio-channel
Channels for asynchronous communication using Tokio
-
crb-actor
CRB | Composable Runtime Blocks | Actor
-
neuron-context
Context strategy implementations for neuron-turn
-
futures-websocket
A futures-based websocket implementation
-
peace_item_tar_x
Manages extracting a tar file for the peace framework
-
rasi-mio
a rasi drivers implementation base on mio
-
flowly-core
Flowly is a library of modular and reusable components for building robust pipelines processing audio, video and other
-
ai-agents-disambiguation
Intent disambiguation support for AI Agents framework
-
gain-lep
Support for exposing Gain APIs via Lep
-
zino-actix
Integrations with actix-web for zino
-
coerce-rt
Async actor runtime
-
emitter_runtime
Runtime support for rs-event-emitter
-
async-watch
Async watch channel
-
peace_rt
Runtime logic for the peace automation library
-
async-graphql-poem
async-graphql for poem
-
zino-amis
UI generator for amis
-
suspend-channel
Channel and stream implementations
-
openai-api
OpenAI API library for rust
-
crb-morph
CRB | Composable Runtime Blocks | Morph
-
armature
An event-driven stateful actor framework for Rust
-
acril-rt
A lightweight single-threaded runtime for Acril actors
-
nb-executor
Single-future, #![no_std] executor based on event bitmasks
-
tower-retry
Retry failed requests
-
feature-extension-for-async-std
Feature extension for async-std
-
whorl
was created to teach you how async executors work in Rust
-
turmoil
Simulation testing framework for distributed systems
-
zino-axum
Integrations with axum for zino
-
neuromance-common
Common types and data structures for LLM conversation and tool management
-
cloud_terrastodon_azure_types
Types for modelling Azure stuff for the Cloud Terrastodon project
-
trillium-tokio
tokio runtime adapter for trillium.rs
-
tor-events
A typed event broadcasting framework for Arti
-
mcpx
SDK for the Model Context Protocol (MCP)
-
folo
Runtime engine for Rust services
-
flows-pubsub
Building blocks for flow-based publish/subscribe
-
alith-client
The Easiest Rust Interface for Local LLMs, and an Interface for Deterministic Signals from Probabilistic LLM Vibes
-
tokio-metrics
Runtime and task level metrics for Tokio applications
-
pulz-executor
Abstractions of some async runtimes
-
ai-agents-hitl
Human-in-the-loop support for AI Agents framework
-
disposition
SVG diagram generator
-
agner-init-ack
An actor toolkit inspired by Erlang/OTP (init-ack)
-
flarrow-flows
flarrow (flow + arrow) is a rust runtime/framework for building dataflow applications
-
gimbal_async
Gimbal Async runtime package
-
async-task-group
Manage groups of
async-stdtasks as a single unit -
flowbuilder-context
Context management for FlowBuilder
-
noop-waker
A waker that does nothing
-
swimos_downlink
SwimOS Downlink Runtime
-
neuron-turn
Shared toolkit for building operators — Provider trait, types, context strategy
-
zino-channel
Cloud events and subscriptions for zino