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