-
mio
Lightweight non-blocking I/O
-
tower
modular and reusable components for building robust clients and servers
-
futures
streams featuring zero allocations, composability, and iterator-like interfaces
-
tokio-rustls
Asynchronous TLS/SSL streams for Tokio using Rustls
-
futures-lite
Futures, streams, and async I/O combinators
-
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
-
rdkafka
Rust wrapper for librdkafka
-
async-io
Async I/O and timers
-
tokio
An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications
-
axum-server
High level server designed to be used with axum framework
-
bb8
Full-featured async (tokio-based) connection pool (like r2d2)
-
pollster
Synchronously block the thread until a future completes
-
futures-concurrency
Structured concurrency operations for async Rust
-
tokio-serial
A serial port implementation for tokio
-
async-stream
Asynchronous streams using async & await notation
-
futures-timer
Timeouts for futures
-
scc
High-performance containers and utilities for concurrent and asynchronous programming
-
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.
-
tower-sessions
🥠 Sessions as a
towerandaxummiddleware -
blocking
A thread pool for isolating blocking I/O in async programs
-
async-openai
OpenAI
-
asynchronous-codec
encoding and decoding frames using
async/await -
io-uring
The low-level
io_uringuserspace interface for Rust -
keycloak
Admin REST API
-
minus
An asynchronous data feedable terminal paging library for Rust
-
gix-actor
A way to identify git actors
-
tracing-actix-web
Structured logging middleware for actix-web
-
ractor
A actor framework for Rust
-
async-broadcast
Async broadcast channels
-
ipc-channel
A multiprocess drop-in replacement for Rust channels
-
paho-mqtt
The Official Eclipse Paho MQTT Rust Client Library. This is a wrapper around the Paho C library
-
futures-signals
Zero cost FRP signals using the futures crate
-
tokio-tar
async TAR file reader and writer. This library does not currently handle compression, but it is abstract over all I/O readers and writers. Additionally, great lengths are taken to ensure that the entire…
-
futures-locks
Futures-aware lock primitives
-
tarpc
An RPC framework for Rust with a focus on ease of use
-
diatomic-waker
An async, lock-free synchronization primitive for task wakeup
-
apalis
extensible multithreaded background job processing for Rust
-
monoio
A thread per core runtime based on iouring
-
containerd-shim
containerd shim extension
-
madsim
Deterministic Simulator for distributed systems
-
tokio-graceful
util for graceful shutdown of tokio applications
-
web-push
Web push notification client with support for http-ece encryption and VAPID authentication
-
openraft
Advanced Raft consensus
-
stream-download
streaming content to a local cache
-
failsafe
A circuit breaker implementation
-
actix
Actor framework for Rust
-
tokio-graceful-shutdown
perform a graceful shutdown on a Tokio based service
-
tokio-retry2
Extensible, asynchronous retry behaviours for futures/tokio
-
async-global-executor
A global executor built on top of async-executor and async-io
-
unicycle
A scheduler for driving a large number of futures
-
capnp-futures
async serialization for Cap'n Proto messages
-
eyeball
Add observability to your Rust types!
-
axum-streams
HTTP body streaming support for Axum: json/csv/protobuf/arrow/txt
-
pi-async-rt
Based on future (MVP), a universal asynchronous runtime and tool used to provide a foundation for the outside world
-
tokio-metrics
Runtime and task level metrics for Tokio applications
-
triple_buffer
triple buffering, useful for sharing frequently updated data between threads
-
async-task
Task abstraction for building executors
-
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
-
eventsource-stream
A basic building block for building an Eventsource from a Stream of bytes
-
swiftide
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
exponential-backoff
An exponential backoff generator with jitter
-
async-shutdown
one-stop solution for async graceful shutdown
-
google-taskqueue1_beta2-cli
A complete library to interact with taskqueue (protocol v1beta2)
-
futures-buffered
future concurrency primitives with emphasis on performance and low memory usage
-
rxrust
Reactive Extensions
-
tor-rtcompat
Compatibility layer for asynchronous runtimes, used by Tor
-
polling
Portable interface to epoll, kqueue, event ports, and IOCP
-
async-walkdir
Asynchronous directory traversal for Rust
-
future-queue
Adapters to manage a queue of futures, where each future can have a different weight
-
gix-object
Immutable and mutable git objects with decoding and encoding support
-
tokio-retry
Extensible, asynchronous retry behaviours for futures/tokio
-
twilight-standby
filter wait for filtered incoming events for the Twilight ecosystem
-
tokio-tun
Asynchronous allocation of TUN/TAP devices using tokio
-
igd-next
Internet Gateway Protocol client
-
rustix-uring
The low-level
io_uringuserspace interface for Rust -
mio-serial
A serial port implementation for mio
-
kdbplus
Dual q/kdb+ interface for API to build a shared library and an IPC client
-
futures-bounded
bounding futures in size and time
-
mio-aio
POSIX AIO bindings for mio
-
tokio-io-utility
Some helper functions for tokio::io
-
tauri-specta
Completely typesafe Tauri commands
-
fn_graph
Runs interdependent logic concurrently, starting each function when predecessors have completed
-
ipc-queue
FIFO queue described in fortanix-sgx-abi used for asynchronous usercalls
-
ntex-h2
An HTTP/2 client and server
-
cxx-async
interoperability between C++ coroutines and asynchronous Rust
-
tmq
ZeroMQ bindings for Tokio
-
hydra
A framework for writing fault tolerant, highly scalable applications with the Rust programming language
-
tokio-pipe
Asynchronous pipe(2) library using tokio
-
gcs-rsync
rsync support for gcs with higher perf than gsutil rsync
-
esrs
A Prima.it-opinionated library to achieve cqrs/es
-
crb
CRB | Composable Runtime Blocks
-
ws_stream_tungstenite
Provide AsyncRead/AsyncWrite over Tungstenite WebSockets
-
pharos
Observer pattern which generates a futures 0.3 stream of events
-
deno_unsync
A collection of adapters to make working with Tokio single-threaded runtimes easier
-
service-async
A Service like tower in async style
-
poll-promise
Poll the result of an async operation in a game or immediate mode GUI
-
kafka
Rust client for Apache Kafka
-
async-speed-limit
Asynchronously speed-limiting multiple byte streams
-
want
Detect when another Future wants a result
-
trait-variant
working with impl traits in Rust
-
tonic-types
A collection of useful protobuf types that can be used with
tonic -
tokio_schedule
schedule tasks in tokio runtime
-
lamellar
asynchronous tasking runtime for HPC systems developed in RUST
-
scoped-futures
imposing upper bounds on Future lifetimes
-
reactive-mutiny
async Event-Driven Reactive Library with advanced & optimized containers (channels) and Stream executors
-
hyper-multipart-rfc7578
multipart/form-data (RFC7578) for Hyper
-
c-ares-resolver
An asynchronous DNS resolver, backed by c-ares
-
async-lsp
Asynchronous Language Server Protocol (LSP) framework based on tower
-
tor-rpcbase
Low level functionality for Arti's RPC service
-
async-native-tls
Native TLS using futures
-
rocketmq-client-rust
Apache rocketmq client
-
a10
io_uring library
-
tower-lsp-server
Language Server Protocol implementation based on Tower
-
delay_timer
Time-manager of delayed tasks. Like crontab, but synchronous asynchronous tasks are possible, and dynamic add/cancel/remove is supported.
-
quinn-proto
State machine for the QUIC transport protocol
-
syslog-rs
A native Rust implementation of the glibc/libc syslog
-
safina
Safe async runtime
-
pty-process
spawn commands attached to a pty
-
local-waker
A synchronization primitive for thread-local task wakeup
-
interruptible
Stops a future producer or stream from producing values when interrupted
-
peekable
reader and async reader, which enhance your network programming experience
-
async-scoped
Spawn scoped (non 'static) asynchronous futures for async_std and tokio runtimes
-
conogram
An async wrapper for Telegram Bot API
-
open-coroutine
efficient and generic stackfull-coroutine library
-
dark-std
asynchronous containers build on tokio. It uses a read-write separation design borrowed from Golang
-
celery
Rust implementation of Celery
-
async-event
An efficient async condition variable for lock-free algorithms
-
dataloader
Facebook's DataLoader using async-await
-
wg
Golang like WaitGroup implementation for sync/async Rust
-
lcode
An application of terminal write leetcode.一个终端刷力扣的应用
-
stream_throttle
Stream combinator, to limit the rate at which items are produced
-
samsa
Rust-native Kafka/Redpanda protocol and client implementation
-
another-rxrust
A different implementation than
rxRustfor easier use ofReactiveXinRust -
executor-trait
A collection of traits to define a common interface across executors
-
scc2
High-performance containers and utilities for concurrent and asynchronous programming
-
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
-
gix-protocol
gitoxide project for implementing git protocols
-
async-bincode
Asynchronous access to a bincode-encoded item stream
-
mcp-attr
declaratively building Model Context Protocol servers
-
peace
zero stress automation
-
compio
Completion based async runtime
-
async-object-pool
object pool implementation that uses asynchronous synchronization primitives only
-
rl-core
Core logic for a token-bucket rate-limiter
-
tasklet
An asynchronous task scheduling library
-
round-based
Driver for MPC protocols
-
viz
Fast, robust, flexible, lightweight web framework for Rust
-
common-multipart-rfc7578
multipart/form-data (RFC7578)
-
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
-
kube-lease-manager
Ergonomic and reliable leader election using Kubernetes Lease API
-
slice_ops
A selection of useful slice operations
-
ya-gcp
APIs for using Google Cloud Platform services
-
fang
Background job processing library for Rust
-
busybody
Service Container and Dependency injector crate
-
tower-sessions-dynamodb-store
AWS DynamoDB session store. Not for direct use; see the
tower-sessionscrate for details. -
actix-web-flash-messages
Flash messages for actix-web applications
-
poster
MQTTv5 client library written in Rust
-
tiny_kafka
A tiny Kafka client library with producer and consumer functionalities
-
async-recursion
Recursion for async functions
-
ferrisgram
An elegent rust client for the Telegram Bot API
-
rex-sm
Hierarchical state machine
-
async-ringbuf
Async SPSC FIFO ring buffer
-
filebuffer
Fast and simple file reading
-
mobc
A generic connection pool with async/await support
-
tcp-stream
std::net::TcpStream on steroids
-
kameo_actors
actors for kameo
-
futures-channel
Channels for asynchronous communication using futures-rs
-
async-ssh2-lite
Asynchronous ssh2
-
daktronics-allsport-5000
decoders for the Daktronics All Sport 5000's serial output
-
gcra
A basic implementation of GCRA algorithm for rate limiting
-
futures-rx
Rx implementations for the futures crate
-
faktory
API bindings for the language-agnostic Faktory work server
-
sipper
A type-safe future that can notify progress
-
hypercore
Secure, distributed, append-only log
-
variable-len-reader
reading/writing variable length data. Support AsyncRead/AsyncWrite in tokio.
-
nuclei
Proactive IO & runtime system
-
blockstore
An IPLD blockstore capable of holding arbitrary data indexed by CID
-
ginepro
A client-side gRPC channel implementation for tonic
-
stopper
an async stream and future stopper mechanism
-
mutringbuf
A lock-free single-producer, single-consumer (SPSC) ring buffer with in-place mutability, asynchronous support, and virtual memory optimisation
-
clamav-client
ClamAV client library with optional Tokio and async-std support
-
rs-event-emitter
simulate promise implementation for rust
-
abscissa_tokio
Support for launching Tokio runtimes within Abscissa applications
-
deduplicate
caching, asynchronous, request deduplication
-
aqueue
fast speed thread safe async execute queue
-
ghost_actor
GhostActor makes it simple, ergonomic, and idiomatic to implement async / concurrent code using an Actor model
-
genawaiter2
Stackless generators on stable Rust
-
next-gen
Safe generators on stable Rust
-
stakker
A lightweight low-level single-threaded actor runtime
-
rxr
Reactive extensions for event-driven applications
-
acts
a fast, tiny, extensiable workflow engine
-
hypercore-protocol
Replication protocol for Hypercore feeds
-
async-graphql-actix-web
async-graphql for actix-web
-
get_chunk
File iterator or stream with auto or manual chunk size selection
-
tros
Your tros from tarantool TX thread to tokio(..and others!)
-
rh2
An HTTP/2 client and server
-
tokise
An asynchronous runtime compatible with WebAssembly and non-WebAssembly targets
-
rust-multipart-rfc7578_2
multipart/form-data (RFC7578)
-
google-places-api
Unofficial Google Places API for rust
-
futures-util
Common utilities and extension traits for the futures-rs library
-
ohkami_openapi
OpenAPI types for Ohkami - intuitive and declarative web framework
-
async_executors
Implements Spawn, SpawnLocal and SpawnHandle for commonly used executors
-
go-zoom-kinesis
A robust AWS Kinesis stream processor with checkpointing and retry capabilities
-
tokio-eventfd
Linux eventfd for tokio
-
swiftide-integrations
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
genawaiter
Stackless generators on stable Rust
-
acton-reactive
Acton Reactive is the main crate of the Acton framework, designed for building reactive, event-driven, and asynchronous systems. It provides intuitive abstractions to make working with…
-
shutdown
can be used to gracefully exit (part of) a running program
-
rocketmq-rust
Unofficial Rust implementation of Apache RocketMQ
-
tiny-tokio-actor
tiny actor library on top of tokio
-
rust-parallel
Fast command line app in rust/tokio to run commands in parallel. Similar interface to GNU parallel or xargs.
-
rabbitmq_http_client
RabbitMQ HTTP API client
-
command_timeout
A tokio friendly command exec with smart timeout
-
kompact
Kompics component model combined with the Actor model
-
mini_exercism
Minimalistic Rust library to interact with the Exercism.org APIs
-
apalis-sql
SQL Storage for apalis. Use sqlite, postgres and mysql for background job processing
-
dptree
An asynchronous event dispatch mechanism for Rust
-
tsuki-scheduler
light wight, composable and extensible scheduler for every runtime
-
pingora-timeout
Highly efficient async timer and timeout system for Tokio runtimes
-
reord
Run your tests multi-threaded, but in a reproducible way
-
call-agent
A multimodal chat API library with tool support, OpenAI API compatible
-
mangadex-desktop-api2
A Actix server for downloading manga, chapters, covers from Mangadex
-
queue_workers
A Redis-backed job queue system for Rust applications
-
hedwig
message bus for Rust
-
flourish
Convenient and full-featured signals for Rust
-
xan-actor
Akka actor
-
certsd
automated, asynchronous LE certificate issuer
-
scuffle-context
Go-like context utilities for Rust
-
ate
Distributed immutable data store with strong encryption and authentication
-
actify
An intutive actor model with minimal boilerplate
-
ya-etcd-rs
etcd client for rust
-
bounded_join_set
A Concurrency-Limited JoinSet for Tokio
-
async-dropper
The least-worst ad-hoc implementation of AsyncDrop as a Derive macro
-
hooch
A small async runtime that's been bootlegged for my projects
-
springtime-di
Dependency injection framework based on automatic component discovery and runtime autowiring
-
floxide-timer
Timer node abstractions for the floxide framework
-
io-tether
A small library for defining I/O types which reconnect on errors
-
drop-stream
A stream that wraps another stream with a closure that is called once it is dropped
-
b2_backblaze
basic async library to upload small files to backblaze b2 service
-
async_cache
Async refresh cache
-
tower-actor
A
towermiddleware that creates aServiceby passing messages to an actor -
tokio-stream
work with
Streamandtokio -
llm_client
easiest Rust interface for local LLMs
-
actor-core-client
Rust client for ActorCore - the Stateful Serverless Framework for building AI agents, realtime apps, and game servers
-
ractor-supervisor
Supervisor module for ractor framework
-
tokio-scheduler-rs
JobScheduler written with tokio runtime, automatic retry, hook and custom storage supported
-
cassette
single-future, non-blocking executor intended for building state machines
-
try-again
Retry synchronous and asynchronous operations
-
fundamentum-edge-daemon
The supported way to access Fundamentum's ecosystem from linux devices
-
jsoncall
asynchronous JSON-RPC 2.0 library leveraging Rust's type system
-
discro
DISCRete Observables for asynchronous Functional Reactive Programming (FRP)
-
apocalypse
actor framework for Rust
-
elegant-departure
simplify graceful shutdown
-
async_cell
A Cell<Option<T>> that you can await on
-
girlboss
async job manager with progress tracking
-
pi_async_buffer
Asynchronous Buffer for IO
-
async-event-emitter
Lightweight AsyncEventEmitter
-
tokio-par-util
running computations in parallel on top of Tokio
-
event-driven-library
Event Driven Message Handling
-
crossmist
Efficient and seamless cross-process communication, both synchronously and asynchronously
-
ntex-polling
Portable interface to epoll, kqueue, event ports, and IOCP
-
elfo
An asynchronous distributed actor framework with robust observability
-
postage
An async channel library
-
twilight-http-ratelimiting
Discord REST API ratelimiter implementations for the Twilight ecosystem
-
async-cuda
Async CUDA for Rust
-
page-turner
A generic abstraction of APIs with pagination
-
cancel-safe-futures
Alternative futures adapters that are more cancellation-aware
-
mail-message
A program for easy, quick, and fault tolerant sending of emails from the command line
-
os-checker-plugin-github-api
A plugin for os-checker to generate information based on github api to checked repositories
-
axum-extra
Extra utilities for axum
-
xio
providing common functionality for file system operations and asynchronous file processing
-
keyring-lib
High-level, asynchronous API for keyring-rs, a cross-platform Rust library to manage credentials
-
rio-rs
Distributed stateful service framework
-
rsdns
DNS Client Library
-
eventsourced
Event sourced entities in Rust
-
htmxtools
A lightweight Rust crate for working with HTMX headers, specifically designed to integrate seamlessly with axum
-
unkey
An asynchronous Rust SDK for the Unkey API
-
cap-async-std
Capability-based version of async-std
-
liner_broker
Redis based message serverless broker
-
mio_wasi
Lightweight non-blocking IO
-
quick-protobuf-codec
Asynchronous de-/encoding of Protobuf structs using asynchronous-codec, unsigned-varint and quick-protobuf
-
tor-rtmock
Testing mock support for tor-rtcomapt
-
wiremock_logical_matchers
Logical matchers for use with wiremock
-
iroh-io
async local io
-
vkapi2
vk api wrapper for rust
-
mountain-mqtt
A no_std compatible, async MQTT v5 client for tokio and embedded use
-
maybe-once
A singleton. Maybe.
-
rabbit-auto
Wrappers for lapin publishers and consumers
-
tokio_util_watchdog
A watchdog utility for tokio runtimes
-
async-openai-compat
OpenAI
-
async-sleep
Async Sleep
-
actix-rt
Tokio-based single-threaded async runtime for the Actix ecosystem
-
scoped-stream-sink
Easy way to make streams and sinks
-
reactio
Low-Latency Event Driven Nonblocking Reactor Pattern
-
axum-jrpc
A JSON-RPC extractor for Axum
-
mpi-sys
Message Passing Interface bindings for Rust
-
meltdown
A lightweight service manager to help with graceful shutdown of asynchronous applications
-
my-awesome-rabbitmq-lib
working with RabbitMQ and asynchronous operations
-
interthread
Auto implementation of the Actor Model
-
fama
Pipeline Manager
-
nebkor-maelstrom
synchronous client for creating Maelstrom distributed clients
-
fastimer
This crates implements runtime-agnostic timer traits and utilities
-
upc
USB packet channel (UPC): provides a reliable, packet-based transport over USB
-
robotxt
Robots.txt (or URL exclusion) protocol with the support of crawl-delay, sitemap and universal match extensions
-
tipsy
Cross-platform IPC for Tokio
-
flatline
ssh-2.0 client library
-
async-blocking-stdio
std::io::std{in(), out(), err()} but async
-
kwi-kraken-rest
Unofficial kraken trading platform REST API implementation
-
sprinter
Run parallel queued tasks
-
libmqm-default
IBM® MQ Interface (MQI) and MQ Administration Interface (MQAI) structure defaults
-
swait
Blocking on Futures
-
histlog
hdrhistogram crate, provides off-thread serialization of HdrHistogram interval logs to file
-
batch-channel
async channel that reduces overhead by reading and writing many values at once
-
telers
An asynchronous framework for Telegram Bot API written in Rust
-
coc-rs
wrapper around the Clash of Clans public API
-
monzo-lib
async Monzo client in pure rust
-
debounced
building delayed
Futures and debouncedStreams that wait a given duration before yielding the most recent item -
pin-utils
pinning
-
ractor_actors
actors built with Ractor
-
async-injector
Reactive dependency injection for Rust
-
wiremocket
Websocket mocking to test Rust applications
-
gasket
Staged Event-Driven Architecture (SEDA) framework
-
futures-io
The
AsyncRead,AsyncWrite,AsyncSeek, andAsyncBufReadtraits for the futures-rs library -
process-lib
Cross-platform, asynchronous Rust library to run commands in pipelines
-
fundamentum-sdk-api
HTTP client targeting Fundamentum IoT devices RestAPI
-
libmqm-constants
IBM® MQ Interface (MQI) and MQ Administration Interface (MQAI) constants
-
image_search
designed to search Google Images based on provided arguments
-
with-async-context
managing contextual data across async tasks
-
gem-rs
that serves as a wrapper around the Google Gemini API, providing support for streaming
-
warp-rate-limit
Rate-limiting middleware for the Warp web framework
-
openrouter_api
client library for the OpenRouter API
-
decrypt-cookies
A decrypt browser crate
-
libuv-sys-lite
Tiny, raw bindings to libuv without linking to it
-
messagebus
allows intercommunicate with messages between modules
-
async-io-bufpool
Efficient asynchronous I/O operations with minimal idle memory overhead
-
tokio-zookeeper
Asynchronous client library for interacting with Apache ZooKeeper
-
mikrotik-rs
Asynchronous Rust library for interfacing with MikroTik routers
-
owned-future
Turn borrowed futures into owned futures
-
async-transmit
Trait for transmitting data to peers asynchronously
-
tokio-process-tools
Interact with processes spawned by tokio
-
notifier_hub
cannal subscribtion system
-
linemux
providing asynchronous, multiplexed tailing for (namely log) files
-
eventuals
Eventually consistent values
-
streamunordered
An efficient async stream multiplexer
-
yield-progress
Combined progress reporting and cooperative task yielding
-
flarrow-url-default
flarrow (flow + arrow) is a rust runtime/framework for building dataflow applications
-
serio
providing traits and utilities for typed IO using format agnostic serialization built on serde
-
qbittorrent_rust
An asynchronous library to interface with the qbittorrent WeBUI API
-
tower-lsp-f
Language Server Protocol implementation based on Tower
-
reactor-trait
A collection of traits to define a common interface across reactors
-
tools_interface
Abstractions of serveral Wikipedia/Wikimedia/Wikidata-related tools
-
async-rt
A small library designed to utilize async executors through an common API while extending features
-
s3tui
TUI application for multiple s3 account operations
-
sacs
Async Cron Scheduler for Tokio
-
firecracker-rs-sdk
🧨🦀🚀 The Firecracker Rust SDK. A pure Rust crate for interacting with Firecracker.
-
transform-stream
Lightweight async stream wrapper
-
rdkafka-sys
Native bindings to the librdkafka library
-
actix-casbin
An Actix actor for casbin
-
irelia
wrapper around the native LoL APIs
-
tokio-io-mock-fork
Enhanced tokio_test::io::Mock
-
rasi-spec
The Official RASI Specification Test Suite
-
tokactor
A actor model framework wrapped around tokio
-
stackfuture
wrapper around futures that stores the wrapped future in space provided by the caller
-
glommio
thread-per-core crate that makes writing highly parallel asynchronous applications in a thread-per-core architecture easier for rustaceans
-
containerd-shim-protos
TTRPC bindings for containerd shim interfaces
-
async-lazy
A value which is initialized on the first access, with an async function
-
synchronized-writer
A tiny implement for synchronously writing data
-
tokio-shutdown
Wait for a stop signal across multiple threads
-
truba
The minimal tokio runtime based actors for Rust
-
flo_binding
Declarative binding library for Rust
-
tokio-tasks
Task managment for tokio
-
stream-find
Add a
findandfind_mapmethods to any stream -
stilgar
A lightweight, no-fuss, drop-in replacement for Rudderstack
-
biscuit-actix-middleware
Biscuit middleware for actix-web
-
corcovado
Non-blocking IO library
-
safina-net
Safe async network functions - ARCHIVED: Code moved to
safinacrate -
multishot
An async, lock-free, reusable channel for sending single values to asynchronous tasks
-
snapup
Abstractions for handling snapshots with streams of subsequent updates
-
agnostic-net
Agnostic abstraction layer of
std::netfor any async runtime -
ntex-neon
Async runtime for ntex
-
axum-standardwebhooks
Axum extractor that verifies signature for Standard Webhooks
-
fourche
task queue named after a lion with forked tail (queue fourché), works with Redis
-
async-io-map
mapping of async IO operations
-
madsim-tokio
The
tokiosimulator on madsim -
futures-retry
Retry your Futures and Streams!
-
rseip
Ethernet/IP (CIP) client in pure Rust
-
pgboss
job queueing service
-
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.)
-
hitomi_la
A hitomi.la API wrapper for Rust
-
aws-smithy-http-server-python
Python server runtime for Smithy Rust Server Framework
-
async_pub_sub
aiming at making async pub-sub easier in Rust
-
swimos_recon
SwimOS Recon
-
napi-calm-down
N-API bindings
-
okstd
The standard library that's ok
-
some_executor
A trait for libraries that abstract over any executor
-
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.
-
gql_client
Minimal GraphQL client for Rust
-
pgp-lib
High-level, asynchronous API for rPGP, a pure Rust implementation of OpenPGP
-
v_exchanges
Implementations of HTTP/HTTPS/WebSocket API methods for some crypto exchanges, using crypto-botters framework
-
daemon-base
A flexible and configurable Rust daemon library with lifecycle management, logging, callbacks, and optional async support. Works on Linux, macOS, and Windows.
-
async-change-tracker
reactive change notifications using futures
-
est
Extensions for the rust Standard library and Tokio
-
cgp-async
Async-generic primitives to support both sync/async in context-generic programming
-
rspc
A blazing fast and easy to use TRPC server for Rust
-
fastcgi-client
Fastcgi client implemented for Rust
-
whisk
fast lockless async channels
-
peace_items
Collection of items the peace framework
-
translators
Free Google Translator without API key and limits
-
ruloom
A thin wrapper around 'corosensei' that provides support for stackful coroutines in Rust (like Loom in Java or goroutines in golang)
-
effectum
An embeddable task queue based on SQLite
-
ffi_rpc
Use FFI with RPC
-
futures-scopes
Runtime agnostic, nestable, scopes for spawning non-static futures
-
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
-
asteroid-mq
An embeddable message queue system
-
mapped_futures
A collection of futures based on FuturesUnordered that supports insertion, removal and mutation of futures by key
-
wgpu-async
Converts some WGPU callback methods to async methods
-
kafru
Python Celery-inspired queuing library for Rust, using cron for scheduling and SurrealDB for storing queues, metrics, and schedules
-
async_io_stream
IntoAsyncRead on steriods
-
tokio-hrtime
Hires timers for tokio
-
prk_eventbus
A lightweight, WebSocket-based event bus for Rust with SQLite persistence
-
constellation-rs
Constellation is a framework for Rust (nightly) that aides in the writing, debugging and deployment of distributed programs
-
odem-rs
Object-based Discrete-Event Modelling in Rust using async/await
-
rio
GPL-3.0 nice bindings for io_uring. MIT/Apache-2.0 license is available for spacejam's github sponsors.
-
pubsub-bus
Thread-safe one-to-many publish-subscribe event system. Simple and easy to use. It just works (hopefully).
-
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
-
hooch-http
HTTP addition to the hooch runtime
-
trale
minimalistic Rust async executor using io_uring for efficient, correct task execution
-
rs_ctx
Context propagation for rs framework
-
waitgroup
Async waitgroup for a collection of task to finish
-
monoio-codec
Codec for Monoio
-
retry-if
A tokio-compatible attribute-macro for decorating methods and functions with an exponential backoff
-
pinky-swear
Futures and async/await-ready Promises
-
read_until_slice
AsyncBufRead::read_until extension to take a slice as a delimiter instead of a single u8
-
qonduit
CQRS pattern
-
async_zmq
Async version for ZeroMQ bindings
-
kuska-handshake
Secure Scuttlebutt handshake + boxstream library
-
fluxor_cli
Fluxor CLI: a command-line tool that allows developers to quickly and efficiently create project starters for the Fluxor web framework
-
pacifica-rs
PacificA: Replication in Log-Based Distributed Storage Systems
-
wait
Syntactic sugar for calling async functions outside of an async context
-
vmcircbuffer
Double Mapped Circular Buffer
-
async-executor
Async executor
-
stdin-nonblocking
Dependency-less non-blocking stdin reader using background threads. Supports streaming and immediate fallback defaults.
-
miow
A zero overhead I/O library for Windows, focusing on IOCP and async I/O abstractions
-
async-reciprocals
asynchronous fallible conversion and reciprocals in Rust
-
busstop
A command and query bus
-
ctrlgen
Generate enums for message-passing services
-
airbyte_client
Airbyte Client is an unofficial client library for the Airbyte API
-
tokio-rayon
Mix async code with CPU-heavy thread pools using Tokio + Rayon
-
async-dashscope
client for DashScope API
-
task-local
storage for asynchronous tasks
-
log-tracing-layer
Build your own custom tracing layer
-
async-codec
creating async codecs
-
ora
Part of the Ora scheduler framework
-
flarrow-builtins
flarrow (flow + arrow) is a rust runtime/framework for building dataflow applications
-
async-borrow
Async compatible ownership semantics using futures instead of lifetimes
-
mal-api
An asynchronous MyAnimeList (MAL) API library for Rust
-
hass-rs
An async websocket client for Home Assistant
-
spider_chromiumoxide_types
Contains the essential types necessary for using chromiumoxide
-
async-timeouts
An instrument to start async tasks after timeouts
-
forensic-adb
Tokio based client library for the Android Debug Bridge (adb) based on mozdevice
-
crb-download
CRB | Composable Runtime Blocks | Downloader
-
retry_macro
A set of declarative macros which retries executing a function upon failure
-
futuresdr
An Experimental Async SDR Runtime for Heterogeneous Architectures
-
whirlwind
Collection of thread-safe, asynchronous data structures
-
spotify-rs
wrapper for the Spotify API
-
async-ffi
FFI-compatible
Futures -
facebookexperimental/async_limiter
A Scalable, User-Friendly Source Control System
-
pierport
Urbit pier import protocol 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
-
merge-streams
Merge multiple streams into one
-
cyclic_pipe
providing fixed-size, buffer pre-allocated cyclic pipe which support multi-producer and multi-consumer concurrent access
-
async-rdma
async wrapper for RDMA ibvers lib
-
notify-future
Support asynchronous notification completion future
-
ics-watcher
A lightweight crate for monitoring ICS files or links and detecting changes, additions, and removals
-
pi_async_file
A async file tools library
-
task-supervisor
Tokio tasks Supervisor
-
patharg
Treat "-" (hyphen/dash) arguments as stdin/stdout
-
pupactor
actor model library built with tokio
-
vents
Events system
-
mq
Message Queue
-
rustygram
minimal and blazing fast telegram notification framework for Rust
-
futures-timeout
that provides timeouts for futures and streams
-
ptask
Spawning parasitic tasks
-
lighthouse-client
Client SDK for Project Lighthouse
-
bb-downloader
async downloader for applications
-
aws-multipart-upload
AWS S3 multipart upload sinks
-
keen-retry
-- yet powerful -- zero-cost-abstractions & zero-copy lib for error handling & recovery
-
array__ops
A selection of useful array operations
-
async_async_io
AsyncRead,AsyncWritetraits but withasync fnmethods -
flawless
Toolkit for writing durable execution workflows in Rust
-
ssec-core
streaming implementation of the SSEC file format
-
basu
Eventbus crate with sync and async features
-
tokio-muxt
Timer for a limited set of events that multiplexes over a single tokio Sleep instance
-
thin_main_loop
Thin, cross-platform, main event loop. A building block for native GUI applications, among other use cases.
-
tc_nominatim
Bindings to the reverse geocoding API powered by openstreetmap
-
makepad-futures-legacy
Makepad futures legacy
-
actix-multipart-rfc7578
multipart/form-data (RFC7578) for Actix
-
super-visor
ordered startup and shutdown for long-running tokio processes
-
cbsk_socket_tokio
socket callback tool by tokio
-
retrier
A wasm-compatible retry library for futures
-
leptos_async_signal
Async signal for leptos Rust web framework
-
mio-pidfd
mio support for Linux's pidfd
-
async-openai-alt
OpenAI
-
netgauze-rdkafka
Rust wrapper for librdkafka
-
ads_client
An asynchronous, non-blocking ADS client
-
madsim-rdkafka
The rdkafka simulator on madsim
-
callback-result
Assists in converting the callback function's method of obtaining results into the await method
-
futures-signals-ext
Extension to futures-signals: MutableOption with combinators, spawning, predicate driven selections from SignalVec
-
ahrimq
A high-performance message queue service supporting pub/sub, normal messages, ordered messages, delayed messages and dead letter queues
-
kuri
An SDK for building MCP servers, focused on elegant developer experience, where tools and prompts are just plain old Rust functions
-
nominatim
Bindings to the reverse geocoding API powered by openstreetmap
-
serial-thread
Asynchronous, multithreaded serial port communication library using mpsc::cjhannels or async-channels for efficient data handling
-
co_managed
Create managed sub coroutines. Managed sub coroutines will be cancelled when the parent exit
-
tasc
A minimnal, asynchronous threadpool
-
jni-utils
Extra Utilities for JNI in Rust
-
tokio_gen_server
Elixir/Erlang-GenServer-like actor on the Tokio runtime
-
libublk
building linux block device in userspace
-
scylla-rs
An async ScyllaDB driver built on an actor-model framework
-
bisync
write async-generic code
-
ordered-stream
Streams that are ordered relative to external events
-
kube-coordinate
Kubernetes leader election using the coordination.k8s.io API
-
async-tensorrt
Async TensorRT for Rust
-
architect-tonic
A gRPC over HTTP/2 implementation focused on high performance, interoperability, and flexibility
-
jarust_plugins
A janus client SDK in Rust
-
swiftide-agents
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
eventastic_postgres
An example postgres event store for eventastic
-
futures-stream-ext
Asynchronous stream extensions for the futures(-core) crate
-
async-shared-timeout
Async timeout that can be reset and shared
-
actix-mqtt-client
A MQTT client based on the actix framework
-
pingora-openssl
OpenSSL async APIs for Pingora
-
stressed
Universal CLI stress tester for competitive programming
-
woddle
An async, synchronized, database-backed Rust job scheduler
-
containerd-client
GRPC bindings to containerd APIs
-
madruga
Retry resiliente com backoff
-
php-tokio
Use any async Rust library from PHP!
-
taskline
distributed task queue for Rust
-
swansong
Graceful Shutdown
-
mod-cli
A fully customizable, feature-rich CLI framework for Rust. Define commands, prefixes, styled output, and more—built for flexibility and speed.
-
cache_loader_async
A thread safe loading cache with async loader functions based on tokio
-
toni
Fast and modular web framework for scalable applications
-
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)…
-
pollable-map
Utilites for storing futures and streams in as a pollable map
-
async_tasks_recorder
A struct for recording execution status of async tasks with async methods
-
tempo-rs
& minimal client to connect and interact with RTE's 'Tempo Like Supply Contract' API
-
pubnub
SDK for Rust
-
futures-executor
Executors for asynchronous tasks based on the futures-rs library
-
tokio_wasi
An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications
-
async-duplex-channel
An asynchronous duplex communication channel between multiple clients and a single responder in different asynchronous blocks
-
didcomm-rs
DIDComm messaging v2 specifications implementation: https://identity.foundation/didcomm-messaging/spec/
-
rendezvous
Easier rendezvous channels for thread synchronization
-
wtx-ui
Different user interfaces for WTX
-
webex
Interface to Webex Teams REST and WebSocket APIs
-
awaitgroup
Wait for a collection of async tasks to finish
-
apis
Reactive, session-oriented, asynchronous process-calculus framework
-
must_future
A wrapper future marked must_use - mainly to wrap BoxFutures
-
quickwit-actors
Actor framework used in quickwit
-
zephyrus
A slash-command framework meant to be used with twilight
-
async-mcp
Async Implementation of Model Context Protocol (MCP)
-
steady_state_aeron
Aeron client library - fast messaging over UDP on Rust (fork for immediate patches)
-
heph
actor framework based on asynchronous functions
-
rasi-mio
a rasi drivers implementation base on mio
-
gprs
A set of filtered and optimized Rust libraries creates a foundation for building modern web frameworks
-
tcp-channel-client
Asynchronous tcpclient based on aqueue actor
-
actix-interop
Use async/await syntax with actix actors
-
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) -
async-os-pipe
Cross platform implementation of a bidirectional async pipe
-
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.
-
rust_generator
generator base on async rust! No experimental needed!
-
miniloop
The simpliest async executor without heap memory allocation
-
hyperbee
Peer to Peer B-tree
-
fizyr-rpc
Native Rust implementation of the Fizyr RPC protocol
-
smolscale
A high-performance async-task scheduler
-
xtra
A tiny actor framework
-
smol-potat
Proc macro for smol runtime
-
bongonet-runtime
Multithreaded Tokio runtime with the option of disabling work stealing
-
flurx
Create reactive asynchronous data flow
-
passivized_docker_engine_client
Docker Engine Client - manage and run containers, images, and volumes
-
eyeball-im
Observable collections based on the
imcrate -
waaaa
WebAssembly, Abstracted Away
-
act-locally
single-threaded async actors with ordinary functions as handlers and plainly typed messages
-
async-fuse
Helpers for fusing asynchronous computations
-
secret-lib
Cross-platform, asynchronous Rust library to retrieve secrets from different sources
-
prin
reverse proxy terminal utility
-
nosy
Change notification / observation / broadcast channels, with filtering and coalescing. no_std compatible.
-
async-fs
Async filesystem primitives
-
app-task
tokio task manager
-
mm1-proto-system
M/M/1! Queueing, do you speak it?!
-
tub
Async Pool
-
elevatorpro
TTK4145 Real-time Programming elevator project, Group 25, spring 2025
-
arta-tokio
Async abstractions implementation for Tokio
-
async-compatibility-layer
an abstraction layer for using both async-std and tokio
-
letslogic
providing interaction with the Let's Logic API
-
tokio-nats
Async-await ready NATS library
-
act_rs
Act.rs is an actor library built to be used with the standard library and Tokio
-
tokio-send-fd
A wrapper for tokio::net::UnixStream to send file descriptors
-
libaosc
AOSC Rust useful library
-
mbp2
A common-utility library for federated projects
-
rxqlite-lite-common
A distributed sqlite database built upon
openraft,sqlxandsqlite -
napi_ext
Extends napi-rs with the ability to run local futures
-
streamline
Reversible futures::Stream-based state machines
-
bp3d-net
Network utilities
-
stream-download-opendal
OpenDAL adapter for stream-download
-
async-sema
Async semaphore library
-
deepseek_rs
client library for the DeepSeek API
-
reducer
A predictable reactive framework for Rust apps
-
tokio-serde-cbor
Integration of serde_cbor into tokio-io, to allow sending CBOR encoded frames across network (and possibly through other transports)
-
baton
channel for receiving updates per field
-
clia-async-openai
OpenAI (with rustls)
-
starbase_events
Async and mutable event system
-
pochta
Addressable channel registry
-
async-interval
Async Interval
-
recurring-tasks
Define tasks and run them in an app forever, ala cronjobs. And don't run already/still running tasks.
-
taskmanager
Manage groups of background tasks
-
resident-utils
Resident program library
-
syndicus
Publish/Subscribe with types for topics and subscriber (re)synchronisation
-
async_logger
Asyncronous logger allows writing arbitrary slices to a memory buffer, which then processed by a writer in it's own thread
-
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) -
voiceflousion
that provides toolkit for Voiceflow AI bots integrations and pre-built functionality for quick integration with popular messengers
-
deferred-future
模仿 jQuery.Deferred()，允许从 Future 实现类实例的外部对正在 pending 的 Future 对象进行 resolve 或 reject 处理。
-
lazyserial
serial
-
fundamentum-sdk-mqtt
MQTT client targeting Fundamentum IoT's MQTT broker
-
handle
Trait for asynchronous context pipeline
-
watchfile
An async utility trait to subscribe to file changes of a serializable file
-
rocketmq-runtime
Unofficial Rust implementation of Apache RocketMQ
-
retainer
Minimal async cache in Rust with support for key expirations
-
async-select
select!multiplex asynchronous futures simultaneously -
ractor_cluster
Distributed cluster environment of Ractor actors
-
async-observable
Async & reactive synchronization model to keep multiple async tasks / threads partially synchronized
-
tower-batch-control
Tower middleware for batch request processing
-
deluge
A highly concurrent stream library driving the underlying futures either concurrently or in parallel to process streaming operations as quickly as possible
-
wasmcloud-interface-factorial
Interface library for the wasmcloud factorial capability, wasmcloud:example:factorial
-
crossbus
A Platform-Less Runtime-Less Actor Computing Model
-
spin_on
inefficient Future executor
-
async-rate-limit
Common traits for rate limiting and implementations in async contexts
-
tor-log-ratelim
Facility for rate-limiting log messages in Arti
-
py_mcai_worker_sdk
AMQP Worker to listen and provide trait to process message
-
moro
Experimental structured concurrency support for async Rust (similar to trio's nurseries)
-
noosphere-into
Transformations of Noosphere content into various target formats
-
hobo
frontend framework
-
compio-fs
Filesystem IO for compio
-
mio-extras
Extra components for use with Mio
-
persway
Sway IPC daemon
-
solr_post
command line tool and library to post files in a directory to a Solr server
-
nonblock
Read available data from file descriptors without blocking (e.g. sockets, streams, child stdout, named pipes)
-
slim-futures
Asynchronous tools that intends for smaller binary size
-
winctx
A minimal window context for Rust on Windows
-
synch
A basic asynchronous timer implementation that uses the cortex-m SysTick peripheral
-
lua_actor
Lua Actor for Rust(sync/async)
-
gcp_access_token
pure rust implimentation to get google cloud access token for servers with service account credentials
-
eventbuzz
A safe, fast, concurrent event publish/subscribe system based on tokio(async), inspired by Spring events
-
par-stream
Asynchronous parallel streams analogous to rayon
-
volo-http
HTTP framework implementation of volo
-
redis-work-queue
A work queue, on top of a redis database, with implementations in Python, Rust, Go, Node.js (TypeScript) and Dotnet (C#)
-
spawns
Async runtime agnostic thread context task spawner for Rust
-
stop-token
Experimental cooperative cancellation for async Rust
-
seccomp-stream
tokio adapter for seccomp_unotify
-
event_iterator
Asynchronous lending iterator
-
palombe
lets you send and receive messages synchronously through different processes using named pipes
-
medea-reactive
Reactive mutable data containers
-
knien
Typed RabbitMQ interfacing for async Rust
-
tokio-io-rewind
rewind tokio::io::AsyncRead and tokio::io::AsyncWrite streams
-
tokio-fastcgi
FastCGI handler (responder, authorizer, filter) library for Tokio
-
tarpc-copy
An RPC framework for Rust with a focus on ease of use
-
bicoro
Bidirectional co-routine data structures
-
recall_fendermint_actor_blobs_shared
Shared resources for blobs
-
ipstack-geph
Asynchronous lightweight userspace implementation of TCP/IP stack for transparent proxies
-
yosemite
Asynchronous SAMv3 library
-
okkoi
-
hydra-websockets
A websocket server for the hydra framework
-
overclock
A framework for building data-driven distributed systems
-
tbot
Make cool Telegram bots with Rust easily
-
brig
mar here, Briganteen—General Sir A. I. Magnus, the flapper-
-
job-pool
Thread Pool
-
orsomafo
Event dispatcher crate
-
crb-agent
CRB | Composable Runtime Blocks | Agent
-
aoc_leaderboard
Strongly-typed wrapper for Advent of Code leaderboard data
-
orengine
Optimized ring engine for Rust. It is a lighter and faster asynchronous library than tokio-rs, async-std, may, and even smol
-
async-graphql-tide
async-graphql for tide
-
readr
File reader
-
debouncer
A simple debouncer for Rust
-
termusix
A terminal-based music player with a user-friendly terminal UI, built with Rust
-
moxie
Incremental runtime for interactive software
-
tokio-cron
cron scheduler for tokio
-
lendpool
lock-free library for allowing safe and concurrent access to a group of objects
-
readwrite
Combine Read and Write into a single Read+Write object
-
rust-paper
Rust Wallpaper manager from ( https://wallhaven.cc/ ) for Linux/UNIX only
-
tower-async
Tower Async is a library of modular and reusable components for building robust clients and servers. An "Async Trait" fork from the original Tower Library.
-
task_forge
A flexible and simple task pool for asynchronous execution
-
singleflight-async
Singleflight in async style
-
ruchei
working with many streams
-
procsem
Semaphore used to lock thread/task-spanning sequence of operations
-
l337
connection pooler
-
futures-jsonrpcv2
Futures-based jsonrpc v2.0 crate
-
streamcatcher
A thread-safe, shared (asynchronous), almost-lockless stream buffer
-
easy-schedule
A flexible task scheduler built on Tokio with multiple scheduling options and skip conditions
-
mfio
Flexible completion I/O primitives
-
tokio-bin-process
run your application under a separate process with tokio tracing assertions when integration testing
-
actix-limitation
Rate limiter using a fixed window counter for arbitrary keys, backed by Redis for Actix Web
-
etcdv3client
etcdv3 client
-
circulate
Lightweight PubSub framework that supports both sync and async
-
peace_cli
Command line interface for the peace automation framework
-
multi-readers
Combining multiple readers
-
dbus-async
Asynchronous DBus library
-
libmqm-sys
IBM® MQ Interface (MQI) and MQ Administration Interface (MQAI) bindings
-
agnostik
Executor Agnostic Runtime that can run your futures with your favourite Executor
-
capp
Common things i use to build Rust CLI tools for web crawlers
-
legend-saga
working with RabbitMQ and asynchronous operations
-
daku
Interface to the Daku API
-
gcal_rs
A blazingly fast, hand written Google calendar API in Rust
-
tokio-lxi
LXI protocol abstractions for Tokio
-
pcap-async
Async/Stream Extensions for libpcap
-
callbag
spec for reactive/iterable programming
-
tokio-smoltcp
An asynchronous wrapper for smoltcp
-
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.
-
async-dropper-simple
struct-wrapper (i.e. AsyncDropper<T>) based implementation of AsyncDrop
-
algoroutine
Light-weight algebraic effect(algebraic goroutine) in Rust
-
oneshot-handshake
providing a symmetric one time use channel type
-
async-pipes
building concurrent data processing pipelines
-
async-rate-limiter
Implements a token bucket algorithm that can be used to limit API access frequency. Written in pure Rust.
-
actix-daemon-utils
Daemon Utilities by actix
-
tokio-task-tracker
graceful shutdown solution for tokio
-
typed-emitter
Typed Async event emitter
-
tasky
fluent async task experiments
-
tactix
Actor Model based on Tokio
-
suika_utils
A small utility library for the suika web stack
-
interlink
Framework for writing async code
-
upstox-rust-sdk
SDK to access Upstox's Uplink v2 APIs programmatically
-
prokio
An asynchronous runtime compatible with WebAssembly and non-WebAssembly targets
-
rspl
A stream processor language
-
odem-rs-sync
Model-time synchronization facilities of the ODEM-rs simulation framework
-
xext-tokio
Extended utilities for tokio runtime
-
async-named-locker
Lock implemented using future
-
queen
message queue
-
proxy-scraper
command-line tool for scraping proxy information
-
test_executors
async executors for testing
-
async-actor
actor framework for Rust
-
realhydroper-lsp
Language Server Protocol implementation based on Tower
-
thread-waker
Waker implementation using current thread token
-
taski
async task DAG execution
-
stream_assert
Macros to simplify testing of
Streambased APIs -
rspc-axum
Axum adapter for rspc
-
smelling_salts
Abstraction over OS APIs to handle asynchronous device waking
-
nitinol-process
Pseudo-actor type process library for Nitinol using green thread of tokio
-
crashdump_viewer_cli
A CLI tool to parse Erlang crashdumps
-
stund
An SSH tunnel maintenance daemon
-
async_zip_futures
An asynchronous ZIP archive reading/writing crate using futures-rs
-
rx_rust_mp
A protoype implementation of the ReactiveX API in Rust using a message passing approach
-
eureka-mmanager
An Actix actor collection for downloading manga, chapters, covers from Mangadex
-
pikav
that help you send event to client with topic subscription
-
baildon
B+Tree library
-
roux-stream
A streaming API for the roux Reddit client
-
async-raft
An async implementation of the Raft distributed consensus protocol
-
booru-dl
A command line tool to download images and tags txt from booru
-
fluvio-async-tls
Asynchronous TLS/SSL streams using Rustls
-
foreback
Future adapters for running aditional work in the background
-
goods
Async assets system
-
flarrow-runtime
flarrow (flow + arrow) is a rust runtime/framework for building dataflow applications
-
swimos_downlink
SwimOS Downlink Runtime
-
tokio-nsq
NSQ client built on Tokio. Tokio NSQ aims to be a feature complete NSQ client implementation.
-
async_timing_util
tokio async functions for waiting until even intervals (on 1 min, 5 min, 30 min, etc), or waiting until a specified timestamp
-
compio-driver
Low-level driver for compio
-
krsk
very cool tool for crates.io integration
-
stackful
Bridge between sync and async
-
async_dag
An async task scheduling utilitiy
-
any-mpsc
An mpsc that allows arbitrary types to be passed through
-
iap
async google/apple receipt validation using hyper
-
xtor
Async Actor framework for Rust which is blazing fast and rock solid
-
tower-sessions-rusqlite-store
(tokio-)rusqlite session store for
tower-sessions -
extend_mut
extending exclusive references
-
coroutine-state
Inspect the state of a Future created by an async function
-
register-count
Counting
Registers created by aCounter -
split-stream-by
Stream extension crate for splitting a Stream into two per a predicate
-
gneiss-mqtt-aws
AWS IoT Core specific builders for asynchronous and threaded MQTT clients
-
async-cron-scheduler
Runtime-agnostic async task scheduler with cron expression support
-
lichess-api
client for Lichess API v2.0.0
-
local-runtime
Thread-local async runtime
-
monoio-rustls
Asynchronous TLS streams wrapper for Monoio based on Rustls
-
async-tty
An asynchronous TTY library for Rust
-
kafcat
cat but with kafka
-
sonor
controlling sonos speakers
-
par-dfs
Parallel, serial, and async dfs and bfs traversal
-
agnostic
abstraction layer for any async runtime
-
lunatic-messaging-api
Lunatic host functions for message sending
-
aoc_leaderbot_lib
Support library for aoc_leaderbot, an Advent of Code leaderboard-watching bot
-
cbsk_socket_rayon
socket callback tool by rayon
-
fb_futures_01_ext
Extensions for future 0.1 crate
-
soph-runtime
Framework for Web Rustceans
-
charred
char checking
-
deadqueue
Dead simple async queue
-
miku-h2
An HTTP/2 client and server
-
what-the-async
runtime
-
yamaha-rcp
Remote control of Yamaha mixing consoles using TCP/IP networking
-
tokio-util
Additional utilities for working with Tokio
-
lwactors
Lightweight actors for Rust using futures-rs
-
tokio-splice2
splice(2) in tokio
-
side-futures
Send future for execution on the runtime that may be in a different thread
-
cbsk_run
async pool tool
-
async-defer
Asynchronous Deferred Calls
-
navactor
A cli tool for creating and updating actors from piped input
-
bing_client
Async reverse client for Bing copilot
-
linkd
actor model framework that takes inspiration from OTP in the erlang ecosystem
-
sparkle-convenience
A wrapper over Twilight designed to make it more convenient to use
-
hollywood
actor framework
-
qcow2-rs
read/write qcow2 image in async/await
-
kapacitor-udf
creating Kapacitor User Defined Functions (UDFs)
-
aj
Background Job based on Actix
-
lookit
Asynchronously connect to devices
-
wgroup
Part of the Ora scheduler framework
-
asynk-strim
Lightweight stream generator library
-
async-dispatcher
async runtime based on a pluggable dispatcher
-
elfo-test
Test utils for the elfo system
-
aiven_rs
sdk to interact with aiven-cloud apis
-
vss
A dead simple library to allow for easily reused shutdown signal handling
-
error_handling
Macro used to clean and centralize error handling within async processes
-
lictool
that will help you quickly add a spdx license to your project right from the command line
-
simple-delay-queue
delay queue for Tokio
-
makepad-futures
Makepad futures
-
minimal-executor
A minimal executor for asynchronous tasks based on the futures-rs library
-
bp3d-threads
threading library intended to simplify concurrency in BP3D
-
rust-freely
An asynchronous wrapper for the WriteFreely/Write.as API
-
stream-rate-limiter
A rate limiter for Tokio streams
-
viz-router
The router for Viz
-
esrc
Primitives for implementing event sourcing and CQRS systems
-
io_uring_actor
Near-zero overhead pipelined io_uring api via actor model so you don't have to use Arc<Mutex<IOUring>>
-
compio-net
Networking IO for compio
-
riker
Easily build fast, highly concurrent and resilient applications. An Actor Framework for Rust.
-
requiem
Actor framework for Rust
-
dd-tracing-layer
Send your logs to Datadog
-
torznab-toolkit
A safe, multi-threaded, async toolkit for adding Torznab APIs to programs
-
unsync
Unsynchronized synchronization primitives for async Rust
-
flue
An efficient and secure actor runtime library
-
borrow_mutex
Async Rust Mutex which does not require wrapping the target structure
-
akinator-rs
wrapper around the undocumented Akinator API
-
tokio-wireguard
In-process WireGuard for Tokio
-
black-box
A minimal actor framework
-
luis_sys
FFI bindings for Microsoft LUIS API
-
msft-runtime
Windows async helpers
-
crius
hystrix-like circuit breaker
-
joyent-tokio-zookeeper
Asynchronous client library for interacting with Apache ZooKeeper
-
actix_async_handler
Support for async syntax for Actix
-
eventsourced-nats
NATS implementation for EventSourced EventLog and SnapshotStore
-
fure
Retrying futures using different policies
-
rants
An async NATS client library
-
tokio-graceful-shutdown-without-anyhow
perform a graceful shutdown on a Tokio based service
-
edfsm-machine
Tasks and Channels for Event Driven Finite State Machines
-
async-task-tracker
A task tracker used for waiting until tasks exit
-
izihawa-common-multipart
multipart/form-data
-
cancellation-token
C#'s CancellationToken API
-
cb_fut
Call function that return value via callback without a callback
-
tokio-file
Asynchronous file I/O for Tokio
-
dynalock
A lease based distributed locking algorithm with support for DynamoDB
-
passivized_vault_client
Vault Client - initialize and monitor Hashicorp Vault nodes
-
iceyee_logger
Logger
-
tower-sesh
A Tower middleware for strongly typed, efficient sessions
-
mini-io-queue
Fixed-length, allocation and lock-free, async I/O oriented single-producer single-consumer queues
-
tokio-executor-trait
executor-trait implementation for tokio
-
teloxide-core
Core part of the
teloxidelibrary - telegram bot API client -
rumqttlog
kafka inspired rumqtt's mqtt commitlog
-
xilinx-dma
Userspace Xilinx AXI DMA Interface
-
extreme
Extremely boring async function runner. MIT/Apache-2.0 license is available for spacejam's github sponsors.
-
pingora-runtime
Multithreaded Tokio runtime with the option of disabling work stealing
-
pistones
An wrapper for the Piston code execution engine
-
releez
run application release-checklist safely
-
ng-repo
Repository library of NextGraph, a decentralized, secure and local-first web 3.0 ecosystem based on Semantic Web and CRDTs
-
tokio-interruptible-future
Easily interrupt async code in given check points. It's useful to interrupt threads/fibers.
-
scuffle-future-ext
working with futures
-
tonic-server-dispatch
A request-dispatch level for tonic-Server
-
tarpc-plugins
Proc macros for tarpc
-
anchor-chain
A statically typed async framework for building LLM-based applications
-
genawaiter2-macro
Convenience macros for generators (genawaiter2)
-
sfio-tokio-ffi
An oo-bindgen model for using Tokio in an FFI environment
-
tokio-tower
Bridging the protocol gap between Tokio and Tower
-
noosphere-storage
Pluggable backing storage for the Rust Noosphere implementation
-
intrepid-model
Manage complex async business logic with ease
-
futures-test-preview
Common utilities for testing components built off futures-rs
-
service-io
Build your service-server fast, easy (and without hosting!)
-
async_msp_cli
Async msp cli for iNav and BetaFlight
-
openraft-sledstore
A sled based implementation of the
openraft::RaftStoragetrait -
libaio-futures
Straightforward Linux AIO using Futures/async/await
-
git-next-server-actor
Server actor for git-next, the trunk-based development manager
-
flo-state
Lightweight actor library
-
ultra-batch
Tokio-based library to batch and cache database queries or other data lookups
-
async-unsync
asynchronous, unsynchronized (thread-local) channels and semaphores
-
fork_stream
Clone any stream
Swhere<S as Stream>::Item: Clone -
prost-codec
Asynchronous de-/encoding of Protobuf structs using asynchronous-codec, unsigned-varint and prost
-
trillium-tokio
tokio runtime adapter for trillium.rs
-
shutdown-handler
A shutdown handler that allows all parts of an application to trigger a shutdown
-
mqtt_actor
An mqtt adapters (from port and adapters) to be used with actix actors
-
tk-listen
A set of helper futures allowing to listen TCP (or unix) socket with resource limits and proper error handling
-
futures_codec
encoding and decoding frames using
async/await -
tigerbeetle-unofficial-core
Safe low level callback-based async bindings to tigerbeetle client library
-
heph-inbox
Bounded capacity channel designed to be used as inbox for actors. Also supports one shot channels.
-
zino-orm
ORM for zino
-
tokio-shared-rt
Allow
#[tokio::test]to use a shared runtime -
reusable-box-future
A reusable
Pin<Box<dyn Future<Output = T> + Send>> -
reconciler
composable async event listener
-
selectme
A fast and fair select! macro for asynchronous Rust
-
forked-tarpc
An RPC framework for Rust with a focus on ease of use
-
tokio-context
Contexts for cancelling asynchronous tasks using tokio
-
ticque
Take a queue for a resource
-
hypixel_api
Generic wrapper around the hypixel api (automatic rate-limiting on client-side)
-
quick_crawler
QuickCrawler is a Rust crate that provides a completely async, declarative web crawler with domain-specific request rate-limiting built-in
-
metatrait
RPITIT Monads
-
ipc-rpc
A wrapper over servo/ipc-channel which provides many high level features
-
async_singleflight
Async singleflight
-
rust-vector-logger
logger for Rust that logs to a vector
-
simple-middleware
General purpose middleware crate
-
mio-uds
Unix domain socket bindings for mio
-
bipe
asynchronous I/O pipe
-
zeebe
client for defining, orchestrating, and monitoring business processes across microservices using Zeebe
-
laststage
fast, durable, high concurrent HashMap
-
sender-sink
classes for working with tokio UnboundedSender and the Sink trait
-
topic-stream
Multi-topic publish-subscribe system in Rust with async support
-
swimos_future
SwimOS Future Utilities
-
hl7-mllp-codec
A Tokio codec for HL7 Minimal Lower Layer Message Transport protocol (MLLP)
-
obeli-sk-executor
Internal package of obeli-sk
-
background-jobs-tokio
in-process jobs processor based on Tokio
-
stream-reconnect
Stream-wrapping traits/structs that automatically recover from potential disconnections/interruptions
-
nolocal-block-on
futures_lite::future::block_on that can run without using thread-locals
-
futures-map
Futures-based and hashmap-based alogrithms
-
plumbing
An async abstraction to pipeline requests through a channel
-
affair
A Tokio-based worker abstraction layer
-
axiom
Implements a highly-scalable and ergonomic actor system for Rust based on the best of Erlang / Elixir and Akka
-
async-minecraft-ping
An async Rust client for the Minecraft ServerListPing protocol
-
streambed-patterns
Patterns for working with streambed
-
blocking-permit
Permits and a thread pool for blocking operations
-
tower-sessions-file-based-store
File-based session store for
tower-sessions -
promising-future
Promise/Future pairs
-
bin-rs
Binary Reader from multi source
-
recall_fendermint_actor_machine
Shared types for ADM machine actors
-
libevent
Rust bindings to the libevent async I/O framework
-
floxide-event
Event-driven node abstractions for the floxide framework
-
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
-
mqtt-async-client
An MQTT 3.1.1 client written in Rust, using async functions and tokio
-
mini-c-ares-resolver
An asynchronous DNS resolver, backed by mini-c-ares
-
msq
legacy Master Server Query Protocol
-
async_io_utilities
An asynchronous IO utilities crate powered by
tokio -
flynn-openai
OpenAI
-
syndicate
Syndicated Actor model for Rust, including network communication and Dataspaces
-
qbit-api-rs
A asynchronous Rust wrapper for qBittorrent Web API
-
feventbus
eventbus is implemented using nats,kafaka and rabbitmq client
-
curseforge
A straightforward asynchronous wrapper around the CurseForge Core API. Public API is subject to change before 1.0.0.
-
peace_item_model
Data types for resource interactions for the Peace framework
-
tokio-duplex
Combine seperate
AsyncReadandAsyncWritetypes into a singleAsyncRead + AsyncWritetype -
rt-local
Thread local asynchronous runtime working with platform-specific event loops
-
lending-stream
A lending version of Stream
-
pw-telegram-bot-fork
creating Telegram bots
-
cassandra-protocol
Cassandra protocol implementation
-
prevayler-rs
System prevalence in rust
-
ethercat-device-control
A command line utility to control Ethercat devices
-
claude-client
client for the Anthropic Claude API
-
tokio_delayed_queue
Asynchronous delayed queue for Tokio runtime
-
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.
-
crb-superagent
CRB | Composable Runtime Blocks | Agent Extensions
-
mediator
pattern in Rust
-
tenorite
A concurrency abstraction library. Provides a client-server model for asynchronous workers
-
parserc
Rust parser combinator framework for small languages
-
tezaursapi
api wrapper for tezaurs.lv
-
rocketmq-remoting
Apache rocketmq remoting
-
pwner
Process Owner crate that allows ergonomic access to child processes
-
deadpool-fantoccini
Dead simple async session pool for fantoccini
-
slock
An async mutex that never deadlocks
-
async_object
Async Object wrapper
-
kumoko
asynchronous server/client crate built on tokio for easy two-way streaming
-
untokio
Automatically create tokio runtimes
-
fates
creating reactive declarations
-
airlock
no_std async communication
-
tokio-snappy
Wrap rust-snappy as a async stream in tokio
-
proxycurl-linkedin-rs
client for the Proxycurl LinkedIn API
-
safina-timer
Safe async timers - ARCHIVED: Code moved to
safinacrate -
stakker_mio
Mio I/O polling integration for the Stakker crate
-
voyager
Web crawler and scraper
-
bonsaimq
Message/job queue based on bonsaidb, similar to sqlxmq
-
bader-db
Key-value cache RESP server with support for key expirations
-
futures-test
Common utilities for testing components built off futures-rs
-
fbinit-tokio
detail of fbinit crate
-
borrow-count
Memory that can be shared with a smart pointer and then reaquired with a future
-
killswitch
used to broadcast a shutdown request
-
async-read-progress
Extension traits for inspecting
AsyncReadprogress -
proq
Idiomatic Async Prometheus Query (PromQL) Client for Rust
-
viaduct
A duplex communication channel between a parent and child process, using unnamed pipes
-
futures_cbor_codec
A codec for framing an AsyncRead/AsyncWrite with cbor for all types that are serializable with serde
-
terminusdm
Terminus Download Manager. Download files, resume interrupted downloads, and keep a history of your downloads - within terminal UI.
-
zippyst
Resolve zippyshare.com download links
-
linked-futures
Link futures into a block, which stops all of the included futures when any of the futures complete
-
rusty_tarantool
Tarantul async client based on tokio framework
-
async-signals
easier and safe Unix signal handling with async Stream
-
libblobd-direct
blobd, direct variant
-
piston_rs
An async wrapper for the Piston code execution engine
-
oricalchum
A lightweight actor model
-
bubbles
Bubble integration server for powder diffraction
-
aggligator-transport-websocket
Aggligator transport: WebSocket
-
alan-runtime
A runtime in Rust to run AGC or Alan Graphcode, alan's bytecode format
-
reception
creating TCP listeners that spawns clients providing model abstraction layer
-
wasmflow-packet
encapsulating the message packets sent across Wasmflow components
-
qp
Quick Pool: High Performance Async Generic Pool
-
yrs
High performance implementation of the Yjs CRDT
-
lifeline
dependency injection library for asynchronous message-based applications
-
emitter_runtime
Runtime support for rs-event-emitter
-
kay
Experimental high-performance actor system framework for Rust
-
forked_stream
Convert any Stream with cloneable items into a cloneable stream
-
kvarn_async
Async utilities used in the Kvarn web server
-
async-weighted-semaphore
An async weighted semaphore
-
plumb
A functional, async pipeline framework
-
mofo
Multiple Ongoing Futures Object - an abstraction for easily managing ongoing child tasks with futures
-
visiting_ref
Container types that asynchronously return ownership of a value to another context upon exiting scope
-
foxhole-api
wrapper for the Foxhole War API
-
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…
-
futures-ticker
An asynchronous recurring time event
-
random-access-storage
Abstract interface to implement random-access instances
-
swiftide-docker-executor
A docker executor for swiftide agent tools
-
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. -
amqprs
AMQP 0-9-1 client implementation for RabbitMQ
-
timer-lib
A feature-rich Rust library for creating and managing timers
-
tokio_based
BASED Async Single-threaded Execution Dispatcher
-
monoio-compat
A compat wrapper for monoio
-
tokio-socks
Asynchronous SOCKS proxy support for Rust
-
coachman
rust asynchronous task manager built on top of tokio framework
-
sched-callback
async callback scheduling
-
agnostic-process
Agnostic abstraction layer of
std::processfor any async runtime -
async-copy-progress
Asynchronous copying with progress callbacks
-
arti-rpcserver
Backend functionality for Arti's RPC service
-
tokio-process-stream
that wraps a tokio::process into a tokio::stream
-
streammap-ext
StreamMap of Tokio with altered
nextthat returns when stream is dropped -
futures-time
async time combinators
-
tonic-side-effect
Tower service that can monitor if a Tonic request frame was produced prior to error
-
hans
Task orchestrator
-
aggligator-transport-usb
Aggligator transport: USB
-
supertrees
Supervision trees for Tokio-based services inspired by Erlang/OTP
-
chunnel
Async mpmc(multi producer multi consumer) channel
-
pinned
Synchronisation primitives for !Send tasks
-
futures-diagnose
Wraps around a Spawn and provides lots of diagnostics
-
streamtools
Additional stream combinators
-
clia_deepseek_rs
client library for the DeepSeek API (use rustls)
-
futures-core
The core traits and types in for the
futureslibrary -
test-with-tokio
attribute macro for tests using tokio with cases and async guards
-
lunatic-common-api
Common functionality for building lunatic host function APIs
-
inngest
Rusk SDK
-
async-watcher
Trigger events when files or directories change
-
ilgda-ipc
IPC standard used for ilgda
-
eyeball-im-util
eyeball-im -
lib3h_zombie_actor
lib3h actor request tracking module
-
async-signal
Async signal handling
-
bevy_impulse
Reactive programming and workflow execution for bevy
-
gandi-v5-livedns-api
Gandi LiveDNS Api
-
tokio-stream_wasi
work with
Streamandtokio -
zino-connector
Unified connector to data sources for zino
-
tokio-stdin-stdout
Thread- and future::sync::mpsc-based AsyncRead/AsyncWrite stdin/stdout with little buffering
-
gentian
proc macro that transforms generators to state machines
-
team
toolbox lib for fun
-
async-graphql-warp
async-graphql for warp
-
podo-core-driver
Podo Driver FFI
-
zookeeper-async
An async ZooKeeper client
-
pirates
async RPC lib
-
xactor
actors framework based on async-std
-
rio_rt
A minimal async runtime with an experimental ambition to be an portable and interoperable async runtime for Rust
-
async-hofs
Various extention traits for providing asynchronous higher-order functions
-
dyn-future
Convenient and fast dynamic Futures for Rust
-
saas-zmq
ZeroMQ tools by using Publish-Federation
-
smol
A small and fast async runtime
-
rl-tokio
In-process token-bucket rate limiter for async tokio runtimes
-
tokio-task-scheduler
A non-blocking task scheduler for Rust with fluent API, supporting interval-based and cron-like scheduling
-
brazier
A mediator implementation in Rust, heavily inspired by the .NET MediatR package (https://github.com/jbogard/MediatR)
-
lsp-codec
Tokio-compatible codec implementation for Language Server Protocol
-
auto-future
For quickly making a struct into a future via an async fn
-
kafka-threadpool
An async rust threadpool for publishing messages to kafka using SSL (mTLS) or PLAINTEXT protocols
-
eventful
event sourcing in Rust
-
epoxy_streams
Base streams implementation for the
epoxy_frplibrary. Please use epoxy_frp instead. -
blec
cross-platform ble client library based on btleplug
-
somen-language
somen parser combinator for languages
-
tija_tools
tija_toolsis a Rust library providing a set of utilities designed to perform common tasks in Rust programming. This library is open for use and can be utilized in various applications… -
async_closure
utilizes the nightly-only feature async_fn_in_trait to imitate async_closures
-
tokio-curl
asynchronous HTTP client using futures backed by libcurl
-
async-ops
Use std::ops traits with Futures
-
zebra-state
State contextual verification and storage code for Zebra
-
uringy
single-threaded concurrency runtime for Rust based on io_uring
-
patoka
Try this if you can decompose your problem into actors
-
smoltimeout
A way to poll a future until it or a timer completes
-
paperless-rs
An asynchronous Rust library for the Paperless-ngx document manager
-
tokio-io-compat
Compatibility wrapper around std io traits that implements tokio io traits
-
tokio_smux
Smux protocol in Rust. Provide multiplexing for reliable streams.
-
kafka-rs
Native Rust Kafka client, built upon kafka-protocol-rs and Tokio
-
monoio-thrift
Thrift for Monoio
-
async-mavlink
An async adapter for mavlink conections
-
agner-utils
An actor toolkit inspired by Erlang/OTP (utils)
-
dstream
DelayedStream - delays items and drops same items coming within given interval
-
hooks-core
Compile-time, async hooks
-
ticker
Rate limited Iterators
-
waker-waiter
async runtimes interoperate with arbitrary futures
-
virta
tbd
-
acu
building asynchronous actors
-
raccoon_broker
A message broker implementation
-
verypoll
Very polling library
-
mcprs
Model Context Protocol para Rust - Uma biblioteca unificada para comunicação com diferentes LLMs e APIs de IA
-
ora-timer
Part of the Ora scheduler framework
-
futures-async-stream
Async stream for Rust and the futures crate
-
aral
Async Runtime Aggregation Layer
-
vesper
A slash-command framework meant to be used with twilight
-
tokiactor
tokio based Actor framework
-
poison_pill
A tiny wrapper for managing children in async environment
-
f289ctrl
Communication library for Fluke 289 digital multimeter
-
tokio-tls-api
TLS/SSL streams for Tokio giving an implementation of TLS for nonblocking I/O streams
-
absinthe
Are you an Actor & Async junkie? Then your app needs some Absinthe!
-
axum-core
Core types and traits for axum
-
discern
implementing the Command Query Responsibility Segregation (CQRS) pattern
-
futures-yamux
The yamux protocol implementation, rewritten from the ground up
-
suppaftp-cli
FTP command line client, based on suppaftp
-
tokio-vsock
Asynchronous Virtio socket support for Rust
-
deferred
help perform deferred execution of code logic
-
luring
io-uring abstraction using tokio's AsyncFd
-
safina-threadpool
Safe thread pool - ARCHIVED: Code moved to
safinacrate -
desaturate
This package aims to makes it easier to maintain a single code base for both regular and async functions
-
async_dataloader
Powerful tool for avoiding N+1 queries using async/await, based on the DataLoader pattern
-
tokio-uring
io-uring support for the Tokio asynchronous runtime
-
elfo-configurer
Loads and distributes configs across the elfo system
-
puteketeke
An asynchronous runtime built on smol
-
futures-ratelimit
Bounded flavors of futures' FuturesUnordered and FuturesOrdered
-
tokio-prepend-io
Wrapper types that prepends data when reading or writing with AsyncRead or AsyncWrite
-
rumpsteak
Session types for asynchronous communication between multiple parties
-
elf_loader
A pure-rust library for loading all ELF format files from both memory and files
-
happyeyeballs
Happy Eyeballs implementation in Tokio (not RFC compliant atm)
-
hackdose-server
A server to control smart plugs using data from smart meters
-
asynk
Multithread asynchronous runtime and reactor
-
tokio-stream-multiplexor
Stream Multiplexor for tokio with a tcp like interface
-
conva_ai
Rust SDK for using CONVA AI Copilots
-
epicenter
synchronous and asynchronous event dispatcher for Rust
-
asyncs
async runtime agnostic facilities
-
actors-rs
Easily build fast, highly concurrent and resilient applications. An Actor Framework for Rust.
-
b2sum-rs
Computing The Blake2b Hash of Files with any given Digest Size
-
lune-std-process
Lune standard library - Process
-
multipart-rfc7578
multipart/form-data (RFC7578)
-
async_chanx
Implement
Sinkfor some channel implementations -
ftools
Functional utilities for Rust
-
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
-
rust-rock-rover
Concert web crawler in Rust
-
pi_futures
feature select
-
simple-actor
Helper to write actor-based async code
-
futures-sink
The asynchronous
Sinktrait for the futures-rs library -
event-listener-strategy
Block or poll on event_listener easily
-
stream-guard
RAII wrapper around Stream that invokes a custom action on drop
-
yield-now
Wakes current task and returns Poll::Pending once
-
napmap
Async HashMap that halts requester tasks until the requested data is accessible
-
xtra-addons
Add-on functionality (Broker, Registry) for crate xtra
-
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
-
alith-client
The Easiest Rust Interface for Local LLMs, and an Interface for Deterministic Signals from Probabilistic LLM Vibes
-
mamenoki
Complete implementation of a Beanstalkd client based on the Tokio runtime
-
handy_async
A handy library for describing asynchronous code declaratively
-
rivulet
Asynchronous contiguous-memory streams
-
async-psec
Asynchronous PSEC implementation
-
async-tick
tick clock
-
noosphere-collections
Collection data types that are needed by an efficient implementation of Noosphere's IPLD data structures
-
graceful-shutdown
Graceful Shutdown for async code
-
raftlog
distributed replicated log based on the Raft algorithm
-
stow
Cloud storage abstraction package for Rust
-
tokio-lk
Futures-aware lock-by-id primitives
-
tokio-par-stream
parallel streams powered by tokio
-
swimos_introspection
SwimOS Agent Introspection
-
lune-std-stdio
Lune standard library - Stdio
-
synevi_network
A leaderless, consensus library based on Apache Cassandra's Accord algorithm
-
mycelium_lib
Mycelium DDM
-
moeval
a toy interpreter
-
async-ctrlc
Async wrapper of
ctrlc -
waterark
Watermark for implementing optimistic SSI (Serializable Snapshot Isolation) transactions
-
bytes-stream
functions to work with stream of bytes
-
tabs
A collection of asynchronous task abstractions, based on tokio
-
maily
easy, quick, and fault tolerant sending of emails
-
futures-io-preview
The
AsyncReadandAsyncWritetraits for the futures-rs library -
lol-async
async html-rewriter
-
tokio-reactor-trait
reactor-trait implementation for tokio
-
rfm69-async
async driver for the rfm69 radio transceiver
-
freestuffapi
Freestuffbot API
-
recall_fendermint_actor_bucket
Actor for bucket object storage
-
tokio-switching-sleep
A tokio Sleep with a switchable state
-
mlua_actor
Lua Actor for Rust(sync/async)
-
mlua-luau-scheduler
Luau-based async scheduler, using mlua and async-executor
-
evdev-shortcut
Global shortcuts using evdev
-
scoped_tasks_prototype
A quick-and-dirty attempt to get scoped tasks in Rust
-
tokio-easy-timer
A tokio-based task scheduler, with a user-friendly API
-
maelstrom-node
Maelstrom Rust node framework
-
awaitable
type with input and output that can be stored in container
-
future-bool
A bool one can await the changes
-
tokio-xmpp
Asynchronous XMPP for Rust with tokio
-
alopecosa
Pure rust async Tarantool 1.6+ connector built on tokio
-
tokio-util_wasi
Additional utilities for working with Tokio
-
bloodbath
event scheduling library
-
peace_resource_rt
Runtime resources for the peace automation framework
-
tokio-stomp-rs-rs
Asynchronous streaming STOMP client fork
-
bb8-bolt
A bolt-client adaptor for the bb8 connection pool
-
async_t
zero-cost async-traits
-
thread-executor
Lightweight futures executor using std::thread::park
-
task-exec-queue
A asynchronous task execution queue
-
backstage
A framework for building data-driven distributed systems
-
spaad
Zero boilerplate actor systems with xtra
-
cold-io
Event driven network io
-
pyo3-anyio
PyO3 utility bindings for Anyio's event loop
-
bean_factory
bean factory,support inject reference bean
-
kioto-serial
Provide serial port I/O using tokio
-
hypixel
Rust wrapper for the Hypixel public API
-
key-lock
mutual exclusion by keys
-
stream-operators
a collection of selected rxjs operators for rust standard Stream
-
flv-future-aio
I/O futures for Fluvio project
-
lib-wc
Will's Programming Toolbox
-
future-utils
Extensions to Rust's Future and Stream traits
-
simple_futures
futures for use in async operations
-
tracing-actix
Allow tracing actor futures in actix
-
nyantrack-common
Common data types and functionality for NyanTrack
-
sinais
signal event library
-
swarm-commander
Manage tons of commands asynchronously
-
gabelung
Branch an asynchronous stream of cloneable items into two
-
sntpc
making SNTP requests
-
pinarcmutex
PinArcMutextype, for shared mutable access to pinned data -
cmdwrap
Command for run shell script
-
abcperf-minbft
Integration of MinBFT into ABCperf
-
nsq-client
Rust client for the NSQ realtime message processing system
-
tokio-tasker
Lets you stop and join groups of Tokio tasks
-
sodium
FRP (Functional Reactive Programming)
-
pingora-boringssl
BoringSSL async APIs for Pingora
-
PRUEBA
Colas tarea
-
tokio-shared
Share tokio Runtime bwtween dylibs
-
terminal-wait-exit
wait user exit terminal, like Ctrl+C
-
bisky
Bluesky API library
-
partial-io
Helpers to test partial, interrupted and would-block I/O operations, with support for property-based testing through proptest and quickcheck
-
eventbus-tiny
A small, dependency-free crate that provides a multi-producer broadcast-consumer event bus
-
async-file-lock
Asynchronous file lock that can auto lock and auto seek
-
aector
Dynamic implementation of the actor model with a smart built-in testing framework
-
rstreams
Async Stream-Processing toolkit with actor model flavor
-
catalyzer
HTTP server framework
-
suspend
A common mechanism for suspending a thread or a Future until notified
-
dabus
Dynamic Aplication Controll Bus - an asynchronous, event based module system for thoes who want to move fast and *not* break things
-
oni
Later on, there will be a framework for mmo games
-
tokio-beanstalkd
Asynchronous client library for interacting with Beanstalkd work queue
-
ctp-futures
A short description of your crate
-
tracing-orchestra
Give me more instruments!
-
streamies
More features for your streams
-
futures-delay-queue
Async delay queue backed by async-std and futures-timer
-
async-send-fd
A wrapper for async UnixStream's to send file descriptors
-
textmode
terminal interaction library backed by a real terminal parser
-
actix-signal
Manage the lifecycle of an actix actor with its address
-
taurus
A WIP roguelike game being developed in Rust
-
pausable_future
Pausable and resumable future, useful in background tasks
-
ticked_async_executor
Local executor that runs woken async tasks when it is ticked
-
ianaio-dialogs
Convenience crate for working with dialogs in browser
-
async-log
Async tracing capabilities for the log crate
-
countio
Byte counting for std::io::{Read, Write, Seek} and its async variants from futures and tokio
-
strawpoll
A wrapper to avoid spurious polling
-
tractor
Actor system modelled after Pony's actors
-
async_progress
Create sync points across async tasks
-
crown
jewel of rust libraries
-
futures-jsonrpc
Futures implementation for JSON-RPC
-
ticks
ergonomic Rust wrapper for the TickTick Open API
-
blockz-futures
working with futures for the tokio stack
-
mio-signals
handling signals with Mio
-
safina-sync
Safe structs for sharing or sending data between async tasks - ARCHIVED: Code moved to
safinacrate -
srmw
Asynchronous single-reader, multi-writer
-
rosey-actors
Actor framework
-
stream-broadcast
Runtime independent broadcast, which only polls it's underlying stream if no pending data is available
-
axum-serveplus
High level server designed to be used with axum framework
-
termcandy
terminal GUI library
-
space-traders
Async SpaceTraders API client for Rust
-
tokio-stream-multiplexor-fork
Stream Multiplexor for tokio with a tcp like interface
-
its_ok_to_be_block_on
A minimal implementation of block_on, to execute futures in a syncronous context
-
wait-for-me
Async CountDownLatch
-
idb
A futures based crate for interacting with IndexedDB on browsers using webassembly
-
newsblur_api
NewsBlur-API
-
tokio-named-pipes
Windows named pipe bindings for tokio
-
async-hid
A async library for interacting with HID devices
-
digtask
Dig is a YAML-defined, OS-level task orchestrator. It can 'dig into' a specifed task, or 'dig out' a desired output file
-
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 -
async_io_crypto
handling AsyncRead with ciphering / deciphering
-
async-tempfile
Automatically deleted async I/O temporary files
-
git-event
Customizable event handler for updates in remote git repositories
-
tokio-task-manager
Allow an async Tokio application to gracefully shutdown, waiting for all tasks to finish
-
encrypted-dns
A modern encrypted DNS server (DNSCrypt v2, Anonymized DNSCrypt, DoH)
-
task_yield
Executor-independent task yielding
-
kioto-uring-executor
multi-threaded wrapper around tokio-uring
-
slings
A small async runtime based on io-uring for Rust
-
yacme-schema
ACME request and response schemas
-
heim-common
Common stuff shared across heim project crates
-
broadcaster
Broadcasting futures mpmc channel
-
futures-finally
that executes a future after the completion of a future or stream regardless of the value or outcome
-
aa-sms
Send messages from with Andrews & Arnold’s SMS API
-
shs_async
Secret-handshake protocol (async)
-
veilid-async-tls
Asynchronous TLS/SSL streams using Rustls
-
async-tun
Asynchronous allocation of TUN/TAP devices using async-std
-
aggligator-transport-bluer
Aggligator transport: Bluetooth on Linux
-
online
📶 Library to check your Internet connectivity
-
ohos-nj-core
high level wrapper for Node N-API
-
rustpub
Activitypub types
-
witty-actors
Fork of quickwit-actors, Actor framework used in quickwit
-
kvarn-quinn-udp
Temporary Kvarn fork: UDP sockets with ECN information for the QUIC transport protocol
-
salvia
Incremental computing brought to async Rust
-
eventador
lock-free pub/sub event-bus with sync and async APIs
-
modular-native
Native bindings to modular-rs
-
waitlist
Keep track of an ordered list of Wakers to wake
-
tokio-netstring-trait
A trait for tokios AsyncRead to easily read netstrings from streams
-
rudux
A Redux-like state management library for Rust
-
tokio-dio
Direct IO supporting crates for bypassing Operating system pages loads
-
django-query
Tools for mocking Django-style endpoints
-
agency
A small async actor framework
-
my-info
In this project you will see some information about yourself through the GitHub user
-
vkteams-bot-cli
VK Teams Bot API CLI
-
async_monad
Asynchronous monad for rust
-
fut_rwlock
A read-write lock that is read and written via Futures
-
async-jobs
Asynchronous job orchestration for Rust
-
deadline
A one-macro crate to ensure assertions meet their deadlines
-
futures-glib
Spawn futures on the glib event loop
-
id_list_txt_reader
read a txt
-
spawns-compat
Async runtime detections for thread context task spawner
-
queen-io
I/O library for Rust
-
completion
writing completion-based asynchronous code
-
rexecutor
A robust job processing library
-
join
Macros which provide useful shortcut combinators, combine sync/async chains, support single and multi thread (sync/async) step by step execution of branches, transform tuple of results in result of tuple
-
susync
An util crate to complete futures through a handle. Its main purpose is to bridge async Rust and callback-based APIs.
-
crb-runtime
CRB | Composable Runtime Blocks | Runtime
-
m3u8_downloader
Application m3u8_downloader allows to download m3u8 HLS streams by master playlist link
-
ws-gonzale
Naive websocket server implemented using async / await
-
bongonet-timeout
Highly efficient async timer and timeout system for Tokio runtimes
-
mrwei
that implements the common promise primitive for rust based on std future
-
set_timeout
allows efficiently executing futures after some delay has passed
-
bucket_dl
A multithreaded downloader with the purpose of faster downloads by splitting it into several requests, rebuilding the data client-side
-
rad
A type-safe, high-level interface to librados using the low-level C bindings from ceph-rust
-
italo-api
Rust binding for Italo API
-
stix
working with STIX 2.0 threat intelligence
-
bleak-rs
High-level BLE communication library
-
simple-async-pipe
Aims to provide a simple pipe-like functionality for async code
-
limitation
A rate limiter using a fixed window counter for arbitrary keys, backed by Redis
-
tokio-libtls
Tokio bindings for LibreSSL's libtls
-
nr-tracing-layer
Send your logs to New Relic
-
select-next-any
Alternative to futures::StreamExt::select_next_some that returns the None variant
-
loading-bytes
Load bytes from paths on native and WASM
-
bleasy
High-level BLE communication library
-
rseip-cip
common industry protocol for rseip
-
aiur
Single threaded async executor with structured concurrency
-
bongonet-boringssl
BoringSSL async APIs for Bongonet
-
cf-turnstile
client for Cloudflare Turnstile
-
jelastic-rs
Rust wrapper for the Jelastic API
-
axum-router-plugin
Shared library-based plugins for Axum
-
yaaf
Actor Framework
-
gritlab
Gitlab rust API sdk
-
celery-rs-core
Core utilities for a celery client and worker in rust
-
pingp
ping lib that pings websites easy and fast
-
nextgraph
client library. Nextgraph is a decentralized, secure and local-first web 3.0 ecosystem based on Semantic Web and CRDTs
-
io_uring_buf_ring
Help user create and manage io-uring buffer-ring
-
csv-async
CSV parsing for async
-
situwaition
Run a closure continuously, until is succeeds or times out
-
messagebird-async
Wrapper around the message bird SMS API
-
framed_aio
allows performing async io operations in a framed manner
-
rusty_falcon
Rust bindings for CrowdStrike Falcon API
-
intercomm
Asynchronous inter-component communication library
-
dslib
A simulation-based framework for teaching distributed systems
-
ncu-rs
A stupid simple and fast cli for updating your package.json dependencies
-
tokio-inherit-task-local
Task local variables for tokio that can be inherited across a spawn
-
tag_nominatim
Bindings to the reverse geocoding API powered by openstreetmap
-
agent_rt
agent scheduling
-
tobytcp
A little library for sending messages over a tcp stream
-
blocking_pool
A thread pool for running synchronous I/O in asynchronous applications
-
tlfs-crdt
tlfs crdt implementation
-
async_zip
An asynchronous ZIP archive reading/writing crate
-
buffer-unordered-weighted
Stream::buffer_unordered where each future can have a different weight
-
actor-interfaces
I only uploaded this to crates.io because I was having some issues cross compiling with local dependencies. If anyone wants to use the name for something actually useful, DM me on github
-
yaanhyy_rust
cargo mod example
-
uller
Generate/Donwload your links
-
alligator
getting the output value from a future
-
futures-utils-lite
futures about utils in lite
-
atomic-waker
A synchronization primitive for task wakeup
-
chikatetsu
An(other) actor framework for Tokio
-
xevent
event types for xloop
-
pantry
Temporary storage for reusing values that may decay
-
agner-helm
An actor toolkit inspired by Erlang/OTP (control panel)
-
jittr
A binary heap based jitter buffer implementation for zero latency udp/rtp streams
-
deno_core
A modern JavaScript/TypeScript runtime built with V8, Rust, and Tokio
-
nats-handling
async NATS client library
-
ianaio-timers
IanaIO crate for working with JavaScript timers
-
otdb
An open trivia database API wrapper
-
async_tasks_state_map
A struct for recording execution status of async tasks with async methods
-
ksoft
KSoft.SI api wrapper written in pure Rust
-
tokio_interval
基于Tokio实现了 setInterval(callback, ms) 和 setTimeout(callback, ms) 类似于Javascript的API
-
wai
Windowing And Input
-
async-rayon
Mix async code with CPU-heavy thread pools using Futures + Rayon
-
anotify
Async iNotify Filesystem Watcher
-
count-write
An io::Write wrapper counting the number of bytes written
-
await-group
Golang like WaitGroup implementation
-
init_system
Framework to wrap application init
-
apread
An activity pub feed reader for the command line
-
strife
A lightweight library for the Discord API
-
rip-starttls
Sans I/O implementation of https://duesee.dev/p/avoid-implementing-starttls/
-
lapin-pool
A RabbitMQ connection pool which manages connections based on the amount of channels used per connection
-
mio-wakeq
mio support for custom event queue via Waker
-
async_msp_lib
Async msp library for iNav and BetaFlight
-
tokio_dual_stack
Dual-stack TCP listener based on tokio
-
remote_config
Flexible crate for asynchronously loading configuration from remote source with caching and automatic revalidation
-
swimos_rtree
SwimOS R-Tree
-
spin_future
Convert synchronous functions into valid but inefficient futures
-
compio-runtime
High-level runtime for compio
-
telegram-bot-ars
creating Telegram bots
-
shinyframework_jobs
Shiny Jobs
-
threader
A performant multithreaded future executor and event loop
-
scipio
A set of utilities to allow one to write thread per core applications
-
ardop_interface
Interface to the Amateur Radio Digital Open Protocol (ARDOP)
-
gcp_auth
Google cloud platform (GCP) authentication using default and custom service accounts
-
atcoder
A template for Rust project
-
serenity_ctrlc
Ctrl+C handler for serenity
-
ruchei-route
Sinks with routes
-
futures-task
Tools for working with tasks
-
agixt-sdk
Rust SDK for AGiXT - A powerful AI agent framework
-
openrazer
Asynchronous bindings to the OpenRazer daemon
-
poolparty
Added functionality for the
futures::executor::ThreadPoolfutures executor -
sidekiq-rs
Sidekiq compatible server in Rust
-
f1-api
F1 API is a client library for the telemetry API of the F1 video games by Codemasters. It uses asynchronous networking to decode the incoming UDP packets, and turns them into strongly typed Rust structs.
-
aws-parameters-and-secrets-lambda
Cache AWS Secrets Manager secrets in your AWS Lambda function
-
svix-webhook-with-clone
Svix webhooks API client with derive Clone added to Webhook struct
-
actix-postgres
PostgreSQL integration for Actix framework
-
futures-state-stream
A version of the futures crate's Stream which returns state on completion
-
future_handles
complete futures via handles
-
scoped_spawn
Full structured concurrency for asynchronous programming
-
zookeeper-cache
ZooKeeper client cache
-
safina-executor
Safe async runtime executor - ARCHIVED: Code moved to
safinacrate -
asyncfd
Send and receive file descriptors over Unix domain sockets while maintaining Tokio AsyncRead and AsyncWrite
-
tokio-scoped
Scoped Runtime for tokio
-
coerce-rt
Async actor runtime
-
akt
An actors library for Rust and Tokio designed to work with async / await message handlers out of the box
-
mobc-forked
A generic connection pool with async/await support
-
sse-stream
Convert a http body into sse stream
-
dwbhk
dwbhk-rs is a library for working with Discord Webhooks
-
dialectic-compiler
Session type macro compiler for the Dialectic crate
-
zino-http
HTTP requests and responses for zino
-
simple-process-stats
Get memory usage and CPU time on Linux and Windows
-
bevy_flurx
Allows you to use coroutine in Bevy
-
decoyssh
A compact and portable SSH tarpit server
-
async-mq
Zero-cost async-await abstraction of lapin AMQP client crate
-
shared_cell
Interior mutability between concurrent tasks on the same thread
-
exit-future
Future that signals exit to many receivers
-
rust_howto
A documentation summary and a compendium of snippets and recipes for the Rust language and ecosystem. Everything you need for day-to-day Rust coding, all in one place.
-
rtx
zero-cost runtime-abstraction intended for use by Rust libraries to enable the Freedom of Choice between asynchronous runtimes
-
async-socks5
An async/.await SOCKS5 implementation
-
ringio
A fully async, io_uring based std alternative which doesn't exist yet
-
tokio-transports
used for communication between processes
-
webrocket
A closure focused WebSocket server implementation
-
async-notify
A general version async Notify, like
tokioNotify but can work with any async runtime -
future-by-example
Examples of common patterns using Future
-
tower-sessions-mongodb-store
MongoDB session store for
tower-sessions -
fb-api
Facebook Api abstraction for async rust
-
cu
Low level bindings to cuda apis
-
isoprenoid
signals runtime framework backing flourish
-
rmp-futures
Async Rust MessagePack and MessagePack-RPC
-
async-waitgroup
Golang like WaitGroup implementation that supports both sync and async Rust
-
amqp-manager
Lapin wrapper that encapsulates the use of connections/channels and creation of amqp objects
-
futures-test-sink
Test utilities for futures::sink
-
rdma
Low-level RDMA API
-
google-cloud-ai
A gRPC-based crate designed to interact with Google Cloud AI API
-
parail
Easily switch between sequential and parallel
-
twitchchat
interface to the irc-side of twitch's chat system
-
rlua-async
Async support for rlua, via coroutines
-
synapps
event dispatcher for Rust applications. It allows senders to send messages to topics. Subscribers will then receive the message based on their subscription policy.
-
async-cuda-npp
Async NVIDIA Performance Primitives for Rust
-
odem-rs-util
Model elements and statistical tooling for the ODEM-rs simulation framework
-
mioco
Scalable, asynchronous IO coroutine-based handling (aka MIO COroutines)
-
wd_event
event system
-
settimeout
Creates a std::future::Future implementation to be ready at some point
-
async-timers
asynchronous timer primitives
-
c-ares
wrapper for the c-ares library, for asynchronous DNS requests
-
aranya-runtime
The Aranya core runtime
-
compio-io
IO traits for completion based async IO
-
tokio-async-drop
macro to enable async drop in a tokio multithreaded runtime
-
medina
An asynchronous web crawling engine
-
cloudflare_dyndns
DynDNS client for Cloudflare
-
wasmflow-streams
encapsulating the message packets sent across Wasmflow components
-
dmds-tokio-fs
Dmds I/O handler interacts with the filesystem using Tokio
-
tokio_telegraf
Minimal async rust wrapper for the telegraf/influxdb protocol, based on Tokio
-
tokio-global
Global tokio runtime
-
fixed-buffer-tokio
NOT MAINTAINED. This crate was replaced by the
fixed-buffercrate withtokiofeature. -
gen-stream
Generator-based streams for Rust and futures 0.3
-
indexed_db_futures
Future bindings for IndexedDB via web_sys
-
task_scope
asynchronous runtime extension for supporting Structured Concurrency with task spawning
-
agzip
Async compatible gzip (de)compressor
-
iou
io_uring bindings
-
cerebrust
working with NeuroSky devices under Rust
-
async_buf_reader_utils
Adds additional functionality to the async-std crate for BufReader
-
pseudoterminal
A cross-platform pseudoterminal implementation with async support
-
tokio-rusqlite
Asynchronous handle for rusqlite library
-
promise_out
promiseOut version for rust
-
fs
A Futures implementation for File System operations
-
enjoin
Powerful syntax-level async join macro
-
async-ucx
Asynchronous Rust bindings to UCX
-
change_stream
A Stream that only emits if the value is different
-
signalr_rs
SignalR client based on actix web client and async await
-
volo-macros
Volo's proc macros
-
smartpoll
A 'Task' abstraction that simplifies polling futures
-
sparkle-impostor
A third party crate for Twilight to execute Discord webhooks that clone an existing message
-
izihawa-hyper-multipart
multipart/form-data for Hyper
-
tourniquet-tonic
Async native round-robin manager for remote services. Tonic integration.
-
socks5-impl
Fundamental abstractions and async read / write functions for SOCKS5 protocol and Relatively low-level asynchronized SOCKS5 server implementation based on tokio
-
north-config
North config is a multi source configuration crate designed as part of the North Microservice Framework
-
riker-cqrs
Command Query Responsibility Separation for Riker applications
-
blacksmith
Building-block functions for async systems
-
hydrolink
Lavalink client made with tokio independent of the Discord library, used in production by Hydrogen
-
dbus-tokio
Makes it possible to use Tokio with D-Bus, which is a bus commonly used on Linux for inter-process communication
-
bevy-tokio-tasks
integration of a Tokio runtime into a Bevy app for background processing
-
juggle
Async task switching for cooperative multitasking in single thread environments with no_std support
-
some_local_executor
local executor
-
futures-dagtask
DAG-based Task Queue
-
swimos_route
SwimOS Routing Utilities
-
tokio-rustls-acme
Automatic TLS certificate management using rustls
-
stateful_async_worker
Asynchronous stateful worker threads utilizable as futures
-
fundamentum-edge-pfwd
The port forwarding tool for edge daemon
-
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
-
vexide-async
The async executor at the core of vexide
-
openai-api
OpenAI API library for rust
-
async-refresh
Create values that refresh automatically and asynchronously after a given duration
-
derive-tokio-io
Derive AsyncRead and AsyncWrite
-
pipebuf_mio
PipeBuf support for
miobyte-streams -
swiftide-query
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
pick_action_from_image
Pick an action from an image
-
holly
A simplistic actor model library using futures
-
futures-cache
Futures-aware cache backed by sled
-
bridge_updater_lib
A helper library to get Tor bridges with ease
-
wasm-ticker
Non-block tick executor for WebAssembly Rust
-
awaken
Coalescing cross-thread wakers for mio and io_uring
-
peace_webi_model
Web interface data types for the peace automation framework
-
thespis
The interface of the thespis actor model (contains only traits)
-
ferris_chats_data
data structures for ferris_chat
-
samotop
SMTP server and library built on async-std
-
interruptible_polling
General purpose polling tasks with RAII-driven fast clean exits
-
bon
Next-gen compile-time-checked builder generator, named function's arguments, and more!
-
lunatic-stdout-capture
Helper library for holding stdout streams of lunatic processes
-
async-stdio
Adapter for using async read/write streams in std::io contexts
-
heim-cpu
Cross-platform CPU information
-
embassy-executor
async/await executor designed for embedded usage
-
miau
Async aware and extensible layered configuration system
-
yt-dlp
🎬️ A Rust library (with auto dependencies installation) for Youtube downloading
-
local-spawn-pool
Spawn
!Sendfutures in a pool and await for all of them to finish. Standalone alternative totokio::task::LocalSet. -
sync_stream
Aggregate multiple streams by polling stream items in order, keeping the consumption of multiple streams in sync
-
scan2
Some helpers to get the next items from an underlying stream
-
streams
A collection of stream-extensions that are missing in the
futurescrate -
wgp
waitgroup implementation
-
asyncio-utils
Support limit,skip on AsyncRead traits
-
async-trait-ext
a procedural macro for async traits
-
recall_fendermint_actor_eam
Builtin Ethereum address manager actor for IPC
-
medusa-zip
A command-line interface to high-performance parallelized implementations of common zip file operations
-
bluest
A cross-platform Bluetooth Low Energy (BLE) library
-
adventure
your great adventure for the various type of requests
-
epoxy_frp
The Reactive Glue for Frontend Applications
-
reactors
Performance-focused cross-platform asynchronous IO implementation
-
nasu
Command-line utility which poll on remote addresses in order to perform status checks periodically
-
aspartam
Minimalistic actor framework based on tokio, inspired by actix
-
attempt
do something over and over and over and over and
-
futures-cputask
Turn synchronous CPU-bound tasks into futures
-
puddle
object pool implementation that uses asynchronous synchronization primitives only
-
elk-mq
A Message Queue implementation in rust, using Redis as a communication medium
-
fs4
No libc, pure Rust cross-platform file locks. Original fs2, now supports async and replace libc by rustix.
-
sigio
signal-based async io
-
makiko
Asynchronous SSH client library in pure Rust
-
submap
B-Tree map for pub/sub services
-
ns-env-config
An env_logger-inspired one-stop configuration for name resolution based on abstract-ns. Reduces boilerplate and provides standard way to configure DNS for applications via
RUST_NSenvironment variable. -
async-xml
deserializing XML data asynchronously
-
windmark
An elegant and highly performant async Gemini server framework
-
rusty-penguin
A fast TCP/UDP tunnel, transported over HTTP WebSocket
-
browser-window
optionally async, optionally threadsafe, electron-like browser toolkit for Rust
-
dndx-fork-tokio-tun
Asynchronous allocation of TUN/TAP devices using tokio
-
supplicant
Bindings for wpa_supplicant
-
xdg-portal
implement for xdg-desktop-portal
-
amqp-client-rust
An asynchronous AMQP client library for Rust, designed for high-performance communication with RabbitMQ. Features include automatic queue and exchange management, message publishing, subscribing, and RPC support.
-
tbon
TinyChain Binary Object Notation is a compact and versatile stream-friendly binary serialization format
-
mini-telnet
Asynchronous minimal telnet library
-
name-it
Give a name to async fn return types
-
safe-vk
create your own vk bot for conversations
-
infect
Intent/effect/task - A variation on the Model View Intent (MVI) and State Action Model (SAM) paradigms
-
f189ctrl
Communication library for Fluke 189 digital multimeter
-
lunchbox
An async virtual filesystem interface
-
nanopore
A minimalist async runtime based on io_uring (Linux) and I/O rings (Windows)
-
futurify
Convert your sync functions into non-blocking thread futures
-
minactor
Minimal actor framework for Rust with tokio
-
gpiocdev
Access GPIO lines on Linux using the GPIO character device
-
tor-general-addr
Generalized socket address type used by Tor
-
shared-tokio-runtime
Shared tokio runtime
-
aggligator
Aggregates multiple links (TCP or similar) into one connection having their combined bandwidth and provides resiliency against failure of individual links
-
rexa
GraphQL MongoDB API builder
-
streem
creating and consuming streams
-
causality
Event Driven Architecture Traits
-
alicemq
Wapper for the amqprs rabbitMQ library
-
florescence
An experimental library exposing hybrid Raft and CRDT primitives
-
channels-io
Async agnostic/Sync IO & buffer management abstractions
-
zipit
Create and stream zip archives on the fly
-
projections
Macro-free pin projections because why not?
-
agreed
Fork of async-raft, the Tokio-based Rust implementation of the Raft protocol
-
pending_unwind
converting unwindings into
pending -
itla
ITLA (micro laser) non-blocking control library using embedded-hal
-
eventually-postgres
Event Store implementation using PostgreSQL for the Eventually crate
-
hyper-serve
High level server designed to be used with axum framework
-
tokio-async-write-utility
Some helper functions for types impl AsyncWrite
-
aws-smithy-http-server
Server runtime for Smithy Rust Server Framework
-
gain-lep
Support for exposing Gain APIs via Lep
-
openraft-rocksstore
A rocksdb based implementation of the
openraft::RaftStoragetrait -
async-entry
extended Tokio's proc macros
-
futures-promises
Promises and Watched Variables for Futures
-
futures-zmq
Futures abstractions for ZeroMQ on any futures executor
-
actix-broker
Message broker for the Actix actor framework
-
neo-email
The modern way to build emails services with Rust
-
x-bow
Precise State Management Library
-
process-stream
Thin wrapper around [
tokio::process] to make it streamable -
tasker_service
a service for executing time based commands
-
mueue
message queues
-
nbd-async
Block device drivers in userspace
-
git-cinnabar
git remote helper to interact with mercurial repositories
-
eventsourcing
Event Sourcing for Rust
-
eventific
that gives you the needed building blocks for event sourcing
-
tokiocli
An Unix CLI based on Tokio
-
compio-buf
Buffer trait for completion based async IO
-
tidy-browser
Tidy up browser information
-
tokio-task-pool
Task pool for Tokio Runtime
-
lagoinha
package that uses public APIs to fetch addresses using the Brazilian Postal Code (CEP). This package cuncurrenlty calls all the supported APIs and returns the first result.
-
nostd_async
An asyncronous runtime for a single-threaded no_std environment
-
rs-copier
Copy and move files asynchronously
-
puppet
actor framework which uses no dynamic dispatch or boxing
-
pipebuf_websocket
PipeBuf support for websockets
-
async-transport
Asynchronous transports with ECN information
-
srad
Sparkplug development framework
-
relm-core
Core streams and event loop primitives for asynchronous GUI in Rust. Foundation for the relm crate.
-
wag
Go like sync.WaitGroup implementation in Rust. (sync/async)
-
mml-lib
Emacs MIME message Meta Language (MML)
-
schedule_recv
Create delayed and periodic Receivers
-
streamdeck-oxide
A high-level framework for creating Stream Deck applications in Rust
-
gm-quic
An IETF quic transport protocol implemented natively using async Rust
-
kvarn-quinn-proto
Temporary Kvarn fork: State machine for the QUIC transport protocol
-
async-fd-lock
Advisory cross-platform file locks using file descriptors with async support by spawning blocking tasks
-
hentai
API wrapper for nhentai.net
-
diath
light-weight library for communication between tokio async tasks
-
zeroconf-tokio
Tokio-based wrapper around the zeroconf crate, which provides mDNS service discovery and registration capabilities
-
elfo-utils
Some utils for the elfo system
-
hls_client
generate a single stream from HLS segments
-
actix-raft
Raft distributed consensus protocol using the Actix actor framework
-
chokepoint
Generic stream transformer to simulate traffic / network congestion
-
tokio-pty-process
Interact with a child process through a pseudo-TTY, asynchronously using Tokio
-
polaris-specification
Service Governance Specification
-
rust-cli-commands
-
negahban
🧐 A simple file watcher, based on
notify, designed to be fast, easy-to-use and async friendly -
d3
A framework for server development
-
rust-concurrent
Fast command line app in rust/tokio to run commands in parallel. Similar interface to GNU parallel or xargs.
-
dynamodb-mutex
Use Dymanodb mutex library
-
wta-reactor
Reactor for the what-the-async runtime
-
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.
-
bongonet-rustls
RusTLS async APIs for Bongonet
-
contained-actors
contained is a research project implementing the proposed harmonic runtime for orchestrating cloud-native systems
-
signald-rust
interface with Signald
-
catty
Send and await a value asynchronously
-
viz-utils
Viz utils
-
conquer-struct
macros to perform concurrent future resolution, while populating struct fields
-
vino-packet
encapsulating the message packets sent across Vino components
-
taos
Driver for TDengine - a timeseries database and analysis platform
-
cancellable
providing a generic cancellable utility
-
tokio-udev
Non-blocking/Asynchronous Tokio support for udev device events
-
fluke-io-uring-async
An abstraction on top of io-uring
-
akinator-py
Python bindings for akinator-rs
-
deadpool-bolt
A bolt-client manager for the deadpool connection pool
-
yozefu
CLI tool for Apache kafka. It allows you to navigate topics and search Kafka records.
-
state_machine_future
Easily create type-safe
Futures from state machines — without the boilerplate -
pegy
A derive based parser generator
-
kythera-actors
Kythera FVM WASM actor builder
-
back-to-the-future
Conversions between std::future::Future and futures::Future
-
async-openai-wasi
Async bindings for OpenAI REST API based on OpenAPI spec
-
tokio-resource-pool
A generic resource pool for the Tokio ecosystem
-
parabuild
A parallel build utility for template heavy projects
-
tokio-icmp-echo
Asynchronous ICMP pinging library
-
futures-util-either
futures_util::future::Either Ext
-
async-result
wrapper providing a convenient way to await a result, built on futures-channel's oneshot channel
-
fut-compat
Offers compatibility between the tokio and async_std runtimes
-
real-async-trait
A proc macro that uses experimental features to work around type erasure for async traits
-
tokio-rustls-fork-shadow-tls
Asynchronous TLS streams wrapper for Tokio based on Rustls
-
agnostic-lite
agnostic-liteis an agnostic abstraction layer for any async runtime -
arta
Async runtime abstractions library
-
lunatic-distributed-api
control server implementation
-
axum-typed-websockets
axum::extract::ws with type safe messages
-
tokio-anon-pipe
Asynchronous anonymous pipe for Windows
-
reactive-messaging
Reactive client/server communications, focused on high performance
-
retry_fn
retry function with versions for blocking or non-blocking, tokio or async-std
-
async-await
Just some macros to emulate the Async and Await :)
-
asygnal
[WIP] Async-first signal handling, such as ctrl-c
-
tokio-rusqlite-new
Asynchronous handle for rusqlite library
-
shared_stream
easily cloneable streams
-
drop-awaiter
that allows you to asynchronously wait for something to be dropped
-
async-lease
Essentially a futures-oriented Arc<Mutex<Option<T>>>
-
wookie
Async test/bench toolkit including single stepping executors. No-std compatible.
-
c_mcai_worker_sdk
AMQP Worker to listen and provide trait to process message
-
crb-routine
CRB | Composable Runtime Blocks | Routine
-
agner-reg
An actor toolkit inspired by Erlang/OTP (reg)
-
manual_future
A future that must be manually completed, similar to Java's CompletableFuture
-
relock
Distributed async locking using Redis
-
svix
Svix webhooks API client and webhook verification library
-
archflow
Create a streamable Zip archive
-
async-stream-packed
Asynchronous stream packed
-
hash_cons
A type-safe hash-cons library
-
mysql_async
Tokio based asynchronous MySql client library
-
tower-async-bridge
Bridges a
tower-asyncServiceto be used within atower(classic) environment, and also the other way around -
async-button
Async button handling crate for no_std environments
-
kvarn-tokio-uring
Temporary Kvarn fork: io-uring support for the Tokio asynchronous runtime
-
felixs-tower-lsp
Language Server Protocol implementation based on Tower
-
async-throttle
Asynchronous Rate Limiting
-
ruyi
An event-driven framework for non-blocking, asynchronous I/O in Rust
-
txn
A generic optimistic transaction manger, which is ACID, concurrent with SSI (Serializable Snapshot Isolation)
-
limitation-actix-middleware
An Actix web middleware for rate limiting requests using a fixed window counter keyed on a header
-
tk-easyloop
A thread local loop and other loop helpers
-
ratio-reactor
Setup WebWorkers as queueing job shop reactors in Yew WASM applications with different strategies
-
serial-io
A serial port implementation
-
islabtech-upw-sensor-v1
Rust client library for remote control of the ISLabTech UPW Sensor v1
-
async-safe-defer
Minimal async- and sync-capable
defercrate -
joz-logger
logger
-
hyper-server
High level server for hyper and tower
-
specta
Easily export your Rust types to other languages
-
ianaio-file
Convenience crate for working with JavaScript files and blobs
-
limitr
offering various rate-limiting algorithms such as Token Bucket, Leaky Bucket, and more
-
actix-codec
Codec utilities for working with framed protocols
-
ffi_helpers
help make working with FFI easier
-
signalfut
A future similar to tokio::signal::unix::Signal, but can be used with all the runtimes
-
gwyh
sweet gossip library
-
libsync
containing channels and other synchronisation object implementations
-
tokio-jsonrpc
JSON RPC 2.0 for tokio
-
sn_sdkg
Safe Network Synchronous Distributed Key Generation: enables dealerless section key generation
-
net-queue
A framework to abstract network queues
-
uid-mux
Async multiplexing library with user provided stream ids
-
todc-net
Algorithms for message-passing (HTTP) distributed systems
-
mqi
Idiomatic IBM® MQ Interface (MQI) and MQ Administration Interface (MQAI) APIs
-
containerd-snapshots
Remote snapshotter extension for containerd
-
wakerpool
lightweight object pool for lists of Wakers
-
bacon-ls
Bacon Language Server
-
crud_hyper
CRUD (Create, Read, Update, Delete) web application built using Rust’s
hyperlibrary. This project demonstrates how to implement basic CRUD operations with an in-memory database and… -
mailfred
Process emails as an HTTP server
-
uds
A unix domain socket crate that supports abstract addresses, fd-passing and seqpacket sockets
-
dbus-async-derive
Handler trait derive macro for dbus-async
-
async-native-tls-2
Native TLS using futures
-
sendgrid-async
An async-std based client for sending emails with SendGrid
-
async_job
async cron job crate for Rust
-
background-jobs-core
Core types for implementing an asynchronous jobs processor
-
rusher-pubsub
Pusher compatible pubsub service
-
acril-rt
A lightweight single-threaded runtime for Acril actors
-
cucumber-codegen
Code generation for
cucumbercrate -
async-component-components
async-component components
-
kayrx
Framework
-
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
-
openai-api-fork
OpenAI API library for rust
-
gnostr-core
Replication protocol for Hypercore feeds
-
tokio-utun
Utun bindings for Tokio
-
tarpc-example-service
An example server built on tarpc
-
bbb_api_wrapper
A wrapper for BuiltByBit's Ultimate REST API
-
gearbox
Excessive tooling for Rust, boosting productivity and operations
-
bevy-async-ecs
Asynchronous interface for Bevy ECS
-
unsend
A thread unsafe runtime for thread unsafe people
-
crb-core-std
CRB | Composable Runtime Blocks | STD
-
vru-cancel
Cancel tokio stream
-
tunein
client to fetch radio stations from TuneIn
-
baildon-store
B+Tree CLI
-
gdext_coroutines
Run Rust Async functions and Coroutines in Godot 4.2+ (through GDExtension), inspired on Unity's Coroutines design
-
ruspiro-channel
Bare Metal Channel implementations for
no-stdenvironments, only requiring an allocator to be provided -
icanhazdadjoke-sdk
An SDK to interact with the icanhazdadjoke Dad Jokes API
-
activitystreams-traits
Traits for ActivityStreams 2.0 objects
-
jobby
Job queue for rocket applications
-
async-read-length-limit
limit the size of an async read
-
async-rx
functions for async reactive programming
-
cnctd_shell
Run simple shell commands
-
delay
A collection of trait and classes to make your thread wait (and timeout)
-
futures-util-io-peek
AsyncPeek trait
-
salvo-serde-util
serde util for salvo
-
atticus
A mimimal API to create asynchronous actors
-
async-anyhow-logger
An easy crate for catching anyhow errors from an asynchronous function, and passing them to your logger
-
there
planning and executing commands on local and remote hosts
-
named-retry
retrying fallible asynchronous operations
-
hreq-h2
An HTTP/2.0 client and server
-
completion-io
Core traits and types for asynchronous completion-based I/O
-
multiparty
zero copy streaming multipart decoder implementation
-
tokio-socketcan
Asynchronous Linux SocketCAN sockets with tokio
-
handy_io
A handy pattern and futures based asynchronous I/O library
-
waker-set
waker set
-
peace_webi_components
Web interface components for the peace automation framework
-
async-barrier
An async barrier
-
libpool
threadpool from The Rust Programming Language
-
hakuban
Data-object sharing library
-
discv5
p2p discv5 discovery protocol
-
component-future
implements the inner future protocol documented in the tokio docs
-
atomic-actor
An
Actorwithasync fnhandlers -
mfio-netfs
mfio based network filesystem
-
selecting
Cross-platform wrapper over select
-
doh-proxy
A DNS-over-HTTPS (DoH) and ODoH (Oblivious DoH) proxy
-
file_watcher_tokio
File watcher using tokio
-
safe-async-scoped
A minimal, safe library for scoped async tasks
-
tracing-actix-web2
Rust tracing adapter for Actix Web
-
monoio-io-wrapper
A read/write wrapper to bridge sync and async io
-
async-fetcher
Asynchronous multi-connection multi-download resumable HTTP file fetching state machine
-
wasmcloud-example-httpserver
wasmcloud HttpServer interface
-
async-component-winit
winit async-component wrapper
-
mm1-core
M/M/1! Queueing, do you speak it?!
-
async-reactor-trait
reactor-trait implementation for async-io
-
yap2p
Experimental yet another peer-to-peer library
-
uring-fs
Truly asynchronous file operations using io-uring. Supports any async runtime. Linux only.
-
blocksr
Drew's Rust library for (clang/objc) blocks
-
sendblue
that provides an API client for interacting with the SendBlue REST API, enabling businesses to integrate iMessage and SMS services into their applications
-
cortex-sources
Ready-made source implementations for various data inputs in the Cortex ecosystem
-
hobo_css
hobo is a Rust frontend framework
-
troupe
modelling Rust applications with actors
-
thread_timer
cancelable timer with no external dependencies
-
async-spawner
executor independent task spawner
-
quix
Distribution layer for actix
-
futures-websocket
A futures-based websocket implementation
-
email-lib
Cross-platform, asynchronous Rust library to manage emails
-
paggo
A small, fast, and safe in-memory database
-
dencode
decoding and encoding frames from readers and writers
-
fd-queue
support fd passing on Unix sockets
-
mikrotik_api
& minimal client to connect and interact with Mikrotik RouterOS API, usually exposed on port 8728
-
improv
Actor microframework
-
rustdtp
Cross-platform networking interfaces for Rust
-
stream-ext
An extension trait for Streams that provides a variety of convenient combinator functions
-
iroh-quinn-proto
State machine for the QUIC transport protocol
-
axum-serde
multiple serde-based extractors / responses for the Axum web framework, also offers a macro to easily customize extractors / responses
-
postgres_rustls
TLS support for tokio-postgres via tokio-rustls
-
motore
modular and reusable components for building robust clients and servers. Motore is greatly inspired by Tower.
-
bb8-mongodb
bb8 connection pooling impmentation for the MongoDB database
-
archlinux-repo
Arch Linux repositories parser
-
hls_lfcd_lds_driver
Rust driver for ROBOTIS HLDS HLS-LFCD-LDS (LDS-01)
-
async-task-ffi
Task abstraction for building executors
-
viz-test
The core traits and types in for Viz
-
crdts
Practical, serializable, thoroughly tested CRDTs
-
mutex-extra
RefMutex<T>that is similar toMutex<T>but isSyncandSendeven ifTisn’tSend -
oauth-lib
Asynchronous Rust library to deal with OAuth flows
-
springtime
Dependency injection based application bootstrapping and execution crate
-
rxqlite-common
A distributed sqlite database built upon
openraft,sqlxandsqlite -
leaves
Distributed ID Allocator
-
kapacitor-multi-indicator-stream-udf
A multi-indicator stream UDF for Kapacitor
-
rotor
The mio-based framework for doing I/O in simple and composable way
-
nonblocking
stdin crate for Rust
-
tk-bufstream
A buffered stream backed by contiguous buffers (netbuf) for tokio
-
async-http1-lite
Asynchronous http1 stream
-
eventsys
dispatching and processing events. Events can be handled in a deferred and/or immediate way.
-
async-drop-guard
offers hash map and cache data structures where individual entries can be locked
-
fusio-parquet
Parquet reader and writer implementations for Fusio
-
oximod
MongoDB ODM for Rust inspired by Mongoose
-
smol-timeout2
A way to poll a future until it or a timer completes
-
inklings
A unified Rust API for various Large Language Model (LLM) providers
-
pub-sub-client
Google Cloud Pub/Sub client library
-
async-pipe
Creates an asynchronous piped reader and writer pair using tokio.rs
-
bawawa
Opinionated set of tools to manage and compose process executions
-
tower-fallthrough-filter
A Tower middleware that gives controll to a defined service if the filter matches and otherwise falls through to the inner service
-
async-global-executor-trait
executor-trait implementation for async-global-executor
-
streaming-platform
Data streaming platform and message broker with concurrent data transfer capabilities
-
repsheet_etl
ETL tools for repsheet
-
tor-rpc-connect
Common implementation logic for Arti RPC Connect points
-
multi_stream
Aggregate multiple streams of different types in a single stream with an item type that is a tuple of the incoming stream items
-
skrillax-stream
Combines skrillax-network crates to work nicely on top of a tokio tcp stream
-
yaaral
async runtime abstraction library
-
rskafka
A minimal Rust client for Apache Kafka
-
ex-futures
An extension of
futures -
xelf
A versatile Rust toolkit for self-use
-
riker-deadletter
A Dead Letters logger for Riker
-
jarust
A janus client SDK in Rust
-
seal_rs
Set of classic asynchronous primitives (Actors, Executors, Futures / Promises)
-
luarmor
API wrapper for luarmor.net
-
awaur
Asynchronous Web API Utilities for Rust
-
gritea
Gitea API sdk
-
diny
An asynchronous, alloc-free serialization framework
-
safina-select
Safe async select function, for awaiting multiple futures - ARCHIVED: Code moved to
safinacrate -
ector
open source async, no-alloc actor framework for embedded devices
-
tower-sessions-sqlx-store
SQLx session stores for
tower-sessions -
webhdfs
Hadoop WebHDFS client library
-
agner-test-actor
An actor toolkit inspired by Erlang/OTP (test-actor)
-
event_handlers
A unified library for handling events
-
abs_art
ABStraction of Asynchronous RunTime
-
signalwire
The unofficial SignalWire SDK for Rust
-
v_exchanges_adapters
Implementations of HTTP/HTTPS/WebSocket API methods for some crypto exchanges, using crypto-botters framework
-
nb
Minimal non-blocking I/O layer
-
cdns-rs
A native Sync/Async Rust implementation of client DNS resolver
-
lease
Object pool that leases values and automatically returns them with async support
-
koibumi-socks
A minimal SOCKS5 client library
-
runtime-loop
Runtime loop for Rust
-
feature-extension-for-async-std
Feature extension for async-std
-
scrappy_do
A concurrent asynchronous webscraping framework
-
arta-async-std
Async abstractions implementation for async-std
-
rocketmq-filter
A filter for RocketMQ messages
-
protwrap
Thin protocol wrapper for network applications
-
safina-async-test
Macro for running async tests - ARCHIVED: Code moved to
safinacrate -
wnf
Safe bindings for the Windows Notification Facility
-
retry_async
retrying, with specific support for the Azure SDK for Rust (cf. https://github.com/Azure/azure-sdk-for-rust).
-
herbert
actor management
-
implicit-await
Implicitly await calls returning Future impls
-
task_scheduler
easilty schedule an FnOnce to run in the future
-
stream_router
A Future aware router to dynamically route between Streams and Sinks
-
mio-utun
Utun bindings for mio
-
deadpool-amqprs
Dead simple async pool for amqprs
-
bastor
A wrapper helps implementing actor with Bastion more easier with self-implemented state
-
docker_engine_api
way to interact with the Docker Engine API
-
tokio-rustls-wasi
Asynchronous TLS/SSL streams for Tokio using Rustls
-
rabble
creating location transparent actor based systems
-
sampr
A message passing framework using actors
-
heim-sensors
Cross-platform sensors information
-
also_sync
Macros to automatically wrap async functions as sync
-
async-trait
Type erasure for async trait methods
-
tigerbeetle-unofficial
Safe high level async bindings to tigerbeetle client library
-
aktrs
An actor model framework for Rust
-
openssh-sftp-client
Highlevel API used to communicate with openssh sftp server
-
tonic
A gRPC over HTTP/2 implementation focused on high performance, interoperability, and flexibility
-
fluke-maybe-uring
Replicates some tokio-uring types to allow building code without it
-
queued-task
concurrent queue task processing
-
tokio-tls-gmssl
TLS/SSL streams for Tokio using native-tls giving an implementation of TLS for nonblocking I/O streams
-
nature
development support platform, it separates data definition from code, so it decouple the data from business system
-
async-attributes
Experimental language-level polyfills for Async Rust
-
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. -
signals
A functional-reactive-like library for Rust that allows asynchronous chaining
-
tower-util
working with
Service -
springtime-migrate-refinery
SQL migration framework based on dependency injection
-
igdb
Video Game Database Api
-
opencl-sys
OpenCL C FFI bindings for the Rust programming language
-
swiftide-indexing
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
async-io-mini
Async I/O fork for embedded systems
-
rt-local-core
Thread local asynchronous runtime working with platform-specific event loops
-
redis-asio
Asynchronous Redis driver based on tokio
-
destream_json
decoding & encoding a JSON stream
-
crb-system
CRB | Composable Runtime Blocks | System Integration
-
async-pidfd
Process file descriptors (pidfd) for Linux
-
compio-signal
Signal handling for compio
-
tonic-arcanyx-fork
A gRPC over HTTP/2 implementation focused on high performance, interoperability, and flexibility
-
hitbox-actix
Asynchronous caching framework for Actix
-
tempest
Realtime message handling framework inspired by Apache Storm and built with Actix
-
futures-async-combinators
toy futures combinators
-
futures-option
Extension traits for dealing with optional futures and streams
-
eventually-redis
Event Store implementation using Redis, for Eventually crate
-
rseip-eip
encapsulation protocol for rseip
-
tonic-middleware
Async middleware and interceptor for Tonic services
-
asteroid-mq-model
Basic models for asteroid-mq
-
fred
An async client for Redis and Valkey
-
async-dup
Duplicate an async I/O handle
-
async-slot
An asynchronous (futures-based) channel that only preserves last value sent
-
deschuler
An async, tokio based scheduling library for rust with a built-in cron builder
-
socks5-server
Fine-grained relatively low-level asynchronized SOCKS5 server library based on tokio
-
reqwest-retry-after
Retry-After header support for reqwest
-
tokio_tasks_shutdown
Easily manage and gracefully shutdown tokio tasks while monitoring their return results
-
async-openai-types
OpenAI
-
tracing-appender
file appenders and making non-blocking writers
-
mqttc
client for the MQTT protocol
-
woven
set of async combinators, usable in a no_std environment
-
app-queue
In-app persistent queue for asynchronous jobs
-
elfo-telemeter
Collects and exposes metrics of the elfo system
-
tower-http-client
Extra Tower middlewares and utilities for HTTP clients
-
cucumber
testing framework for Rust, with async support. Fully native, no external test runners or dependencies.
-
basteh-redb
basteh based on redb
-
reacher-fast-socks5
Fast SOCKS5 client/server implementation written in Rust async/.await (tokio)
-
zino-auth
Authentication and authorization for zino
-
futures-quic
quic protocol backed by Quiche
-
destream
async stream (de)serialization
-
merriam-webster-model
Models for the Merriam Webster's Dictionary API
-
motis-openapi-progenitor
API-wrapper around the motis api used for routing
-
logic-mesh
Control logic engine using event based and reactive blocks written in Rust
-
async-compat
Compatibility adapter between tokio and futures
-
whorl
was created to teach you how async executors work in Rust
-
async-core
A standard for async runtimes
-
hyper_lua_actor
Binding of lua_actor & hyper
-
shutdown-async
Asynchronous Shutdown
-
libctp-sys
Rust bindings to CTP API
-
futures-fs
A Futures implementation for File System operations
-
kcr_kafka_strimzi_io
Kubernetes Custom Resource Bindings
-
odem-rs-meta
Language extensions for the ODEM-rs simulation framework
-
rabbit_borough
Create a RabbitMQ consumer project with minimal effort, by bypassing templating, configuration and complicated resiliency logic
-
peace_webi_output
Web interface output for the peace automation framework
-
structured-spawn
Structured async spawn implementations for Tokio
-
zino-axum
Integrations with axum for zino
-
async-graphql-extension-apollo-tracing
An async_graphql extension to send traces & metrics to Apollo Studio
-
gix-packetline
gitoxide project implementing the pkt-line serialization format
-
paranoid-hash
A Hashing Library For Those Paranoid With Their Security
-
interprocess
communication toolkit
-
syncthing
controlling syncthing file synchronization through its REST interface
-
thetvdb
API async client
-
usb-disk-probe
stream type which can be used to probe for USB storage devices in the system
-
vanilla_tokio_actor
Vanilla Tokio Actor
-
libmedusa-zip
High-performance parallelized implementations of common zip file operations
-
futuresdr-pmt
Polymorphic Types for an Experimental Async SDR Runtime for Heterogeneous Architectures
-
openraft-memstore
A in-memory implementation of the
openraft::RaftStoragetrait -
valorant-assets-api
API Wrapper for valorant-api.com
-
pyo3io
I/O utilities bindings for PyO3
-
futures-loco-protocol
Asynchronous Loco protocol stream for futures
-
netidx-protocols
Protocols built on top of netidx
-
tokio-udp-framed
Based on UdpFramed from tokio-util but with some quality of life modifications to support shared ownership of
UdpSocketand to split Send/Recv into their own types -
madsim-real-tokio
An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications
-
unix-udp-sock
async & sync UDP sockets supporting sendmsg/recvmsg and src IP manipulation
-
dummy-waker
Get a
core::task::Wakerthat does absolutely nothing -
dioxus-query
Fully-typed, async, reusable cached state management for Dioxus 🧬
-
apub-ingest
building activitypub servers
-
rust-gpt
interaction with the Completion/Chat OpenAI API
-
nb-executor
Single-future, #![no_std] executor based on event bitmasks
-
bluer
official Rust interface to the Linux Bluetooth protocol stack (BlueZ)
-
simple-scheduler
Schedule periodic tasks to run asynchronously
-
ksqldb
A thin wrapper around the KSQL DB REST API to make it more ergonomic to work with
-
futures-enum
#[derive(Future, Stream, Sink, AsyncRead, AsyncWrite, AsyncSeek, AsyncBufRead)] for enums
-
serf
A decentralized solution for service discovery and orchestration that is lightweight, highly available, and fault tolerant
-
actix-async-await
Experimental async/await support for Actix
-
qcongestion
Congestion control in QUIC, a part of gm-quic
-
mio-timerfd
mio support for linux's timerfd
-
heim-virt
Cross-platform virtualization system detection
-
async-executor-trait
executor-trait implementation for async-std
-
rasio-mio
a RASIO drivers implementation base on mio
-
somen
An asynchronous parser combinator
-
actix-utils
Various utilities used in the Actix ecosystem
-
mediatrix
Strongly typed, extensible event mediator
-
unisock
Unified socket with different implementations
-
event-source
Zero cost async immediate event dispatching
-
async-trait-sync
Fork of async-trait with support to Sync future
-
ntex-grpc
GRPC Client/Server framework
-
actix-storage-sled
actix-storage based on sled
-
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.
-
async-gitlib
Asynchronous library with libgit2 artifacts
-
prefect
An embeddable task queue based on SQLite (renamed to effectum)
-
citadel_user
User backend library for the Citadel Protocol
-
cute-async
Cute async utilities
-
gneiss-mqtt
Asynchronous and threaded MQTT(5) clients
-
squinn
Versatile QUIC transport protocol implementation with SCION support
-
librdkafka-sys
Native bindings to the librdkafka library
-
miku-server-timing
An axum layer to inject the Server-Timing HTTP header into the response
-
tower-pipeline
A Tower Service combinator that "pipelines" two services
-
eventastic
opinionated fork of Eventually-rs. It enforces the use of transactions and handles idempotency.
-
ockam_transport_websocket
WebSocket Transport for the Ockam Routing Protocol
-
borer-core
network borer
-
deli
ergonomic way to define data models that are seamlessly converted into IndexedDB object stores, utilizing derive macros
-
tmpdir
Useful to create temp directories and copy their contents on completion of some action. Tmp dirs will be created using [
env::temp_dir] with some random characters prefixed to prevent a name clash -
brb
Byzantine Fault Tolerant (BFT) system for achieving network agreement over eventually consistent data-type algorithms such as CRDTs
-
roundabout
An message oriented concurrent runtime
-
xo-api-client
Unofficial crate for accessing Xen Orchestra through its API
-
intervalier
Interval events with handling notifications
-
keyz_rust_client
keyz client for Rust
-
rlg
that implements application-level logging with a simple, readable output format. Features include log rotation, network logging, and support for multiple structured formats like JSON, CEF, and more.
-
relm
Asynchronous, GTK+-based, GUI library, inspired by Elm, written in Rust
-
monoio-rustls-fork-shadow-tls
Asynchronous TLS streams wrapper for Monoio based on Rustls
-
tarpc-bincode-transport
A bincode-based transport for tarpc services
-
async-priority-queue
An async-aware priority queue
-
suspend-channel
Channel and stream implementations
-
async-scgi
Async SCGI Client & Server
-
ws-lite
Naive websocket server implemented using async / await
-
ctrlc2
Easy Ctrl-C handler version 2 for Rust projects
-
actor
Actors traits
-
bb8-ruarango
bb8 connection pooling impmentation for the ArangoDB database
-
patchable-async-sleep
An async sleep function, patchable to the preferred runtime
-
rusty-gql
Schema first GraphQL Library for Rust
-
throttled-reader
An io::Read proxy that limits calls to read()
-
hydra-macros
Macros for the hydra framework
-
futures-mockstream
Minimal mockstream which implements futures async traits
-
futures-stable-preview
futures which support internal references
-
simplex-chat
API for the SimpleX Chat CLI
-
fe2o3-amqp-management
An experimental impl of AMQP 1.0 management extension
-
catalyzer-utils
development easier
-
rustls-acme
TLS certificate management and serving using rustls
-
mobc-bolt
A bolt-client manager for the mobc connection pool
-
windows-async
async executor for windows application using windows crate
-
lutetium
tokio based simple actor library
-
nrf24radio
Asynchronous embedded driver for NRF24L01(+) devices
-
svc-nats-client
Async nats client
-
tokio-pty-process-stream
wraps tokio-pty-process in order to provide a simpler API as a single stream object
-
aldrin-gen
Aldrin code generator
-
hala-future
hala asynchronous programming primitive types
-
for_event_bus
a event bus
-
ockam_transport_ble
Bluetooth Low Energy (BLE) Transport for the Ockam Routing Protocol
-
rw-stream-sink
Adaptator between Stream/Sink and AsyncRead/AsyncWrite
-
mio-byte-fifo
Concurrent non-blocking byte SPSC FIFO buffer intended for use in Mio poll
-
oneshot-broadcast
channel that broadcasts a value once without cloning it
-
streamify
Conversions from values to Stream
-
wora
A framework for building applications (daemons, etc) that run in different environments (Linux, Kubernetes, etc)
-
rupnp
An asynchronous library for finding UPnP control points, performing actions on them and reading their service descriptions
-
ttl_cache_with_purging
A time-to-live (TTL) cache implementation with optional background purging for expired entries
-
srad-client-rumqtt
Sparkplug Client implementation using Rumqtt
-
compio-dispatcher
Multithreading dispatcher for compio
-
stream-future
Implement an async iterator with return value
-
mcprotocol-rs
Model Context Protocol (MCP)
-
swimos_utilities
SwimOS Time Utilities
-
tourniquet-celery
Async native round-robin manager for remote services. celery integration.
-
futures-waitmap
future-based concurrent event waiting hashmap
-
reqwest-eventsource
Helper to build an Eventsource using reqwest
-
openssh-sftp-protocol-error
Data format used to communicate with openssh mux server
-
tower-async-hyper
Bridges a
tower-asyncServiceto be used within ahyper(1.x) environment -
vmc
Virtual Motion Capture protocol for virtual avatar tracking
-
completeio
Completion based IO drivers and async runtime
-
accumulate-api
Lower-level API for interfacing with the Accumulate Protocol via JSON-RPC
-
async-option
Essentially an asynchronous Async<Mutex<Option<T>>>
-
ockam_node
Ockam [Ockam][main-ockam-crate-link] Node and is intended for use by crates that provide features and add-ons to the main [Ockam][main-ockam-crate-link] library. The main [Ockam][main-ockam-crate-link]…
-
stabilityai
stability.ai library based on OpenAPI spec
-
mogwai
The minimal, obvious, graphical, widget application interface
-
stream-flatten-iters
Flattens a stream of iterators into one continuous stream
-
waitfor
Retry a function until it succeeds, errors out, or a timeout/deadline is reached
-
mioqu
queuing and processing background tasks
-
wasmflow-traits
encapsulating the message packets sent across Wasmflow components
-
async-debug
Debug structs and enums containing values that require an async call to render
-
prodash
A dashboard for visualizing progress of asynchronous and possibly blocking tasks
-
and-then-concurrent
Concurrent and-then combinator for Rust streams
-
zino-openapi
OpenAPI support for zino
-
batch
Distributed task queue library based on RabbitMQ
-
eventbuzz_core
The core submodule of eventbuzz project
-
duplexify
Combine a reader + writer into a duplex of Read + Write
-
axum-messages
🛎️ One-time notification messages for Axum
-
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.
-
async-http-body
Agit init HttpBody Support Async Expressions
-
pipebuf_rustls
PipeBuf wrapper for Rustls
-
async-raft2
An async implementation of the Raft distributed consensus protocol
-
see-you-later
Delay and schedule async task
-
mio-misc
Miscellaneous components for use with Mio
-
timeware
timer used to schedule execution of closures at a given timestamp
-
axum-session-manager
Session manager crate for Rust web framework 'Axum'
-
bevy_async_system
ability to wait for game status asynchronously
-
vkteams-bot
VK Teams Bot API client
-
linux-io-uring
The
io_uringlibrary for Rust -
openssh-mux-client-error
openssh mux client
-
tokio-extra-macros
Extra proc macros for Tokio
-
noosphere-core
Core data types of the Rust Noosphere implementation
-
peace_params
Constraints and specifications for parameters for the peace automation framework
-
async-native-tls-alpn
Native TLS using futures
-
ruw
Read-Update-Write
-
tokio-non-async
Helpers for dealing with tokio channels in non-async code
-
cannyls_rpc
RPC library for operating cannyls's devices from remote nodes
-
launchpadlib
accessing Launchpad.net
-
compio-process
Processes for compio
-
tokio-timerfd
timerfd support for tokio
-
futuresdr-types
Polymorphic Types for an Experimental Async SDR Runtime for Heterogeneous Architectures
-
crdb-client
Concurrently Replicated DataBase
-
fundamentum-edge-mcu-http-client
An HTTP Client for provisioning EdgeMCU devices
-
async-component
Zero overhead reactive programming
-
st7735-async-low
Low-level async library for 4-wire serial ST7735
-
mpool
A generic connection pool
-
deadpool
Dead simple async pool
-
etcd-rs
etcd client for rust
-
gmf
An RPC library using Glommio and Tonic. Note: This package only works on Linux.
-
juniper
GraphQL server library
-
srad-types
Sparkplug types and utilities
-
underway
⏳ Durable step functions via Postgres
-
toy-async-runtime
Toy library to start to work with async rust, build for reckless person!
-
shuller
Lib to get links to images for your favourite tags on rule34 and any
-
calloop
A callback-based event loop
-
citadel_sdk
High-level library to build applications on the Citadel Protocol
-
anthropic-sdk
Anthropic Rust SDK
-
tower-sessions-deadpool-sqlite-store
deadpool-sqlite session store for
tower-sessions -
rexecutor-sqlx
A robust job processing library
-
stream-reduce
Fold a stream without an initial value
-
agreed-memstore
An in-memory implementation of the
agreed::RaftStoragetrait. Fork of async-raft’s memstore crate. -
tower-sessions-firestore-store
tower-sessions store using Cloud Firestore
-
tls-async
TLS support for AsyncRead/AsyncWrite using native-tls
-
connman
that abstracts the D-Bus layer
-
async-gigachat
Async bindings for Gigachat API
-
anansi-aux
Anansi's auxiliary library
-
rustun
implementing STUN server and client asynchronously
-
connect
message queue abstraction over async network streams
-
cache-compute
implements request/async computation coalescing
-
bottle
Actor model framework for Rust
-
delimiter-slice
Stream type for splitting a delimited stream
-
holidayapi_rust
A HolidayAPI library for Rust
-
awaitable-error
Awaitable type with input and output that can be stored in container
-
gitlab
API client
-
peermerge
Manage JSON-like documents with multiple writers, without a central authority, using a P2P protocol
-
stalk
sending serialized data with tokio
-
cyper-axum
axum adaptor based on cyper
-
stream-tungstenite
A streaming implementation of the Tungstenite WebSocket protocol
-
openssh-mux-client
openssh mux client
-
firebase-rtdb
Firebase client for the Citadel Protocol
-
erkpht-tower
Tower is a library of modular and reusable components for building robust clients and servers
-
sendfile
wrapper around the sendfile(2) system call
-
axum-tungstenite
WebSocket connections for axum directly using tungstenite
-
must-done
An experimental Future that is guaranteed to be done
-
remcached
Caching system designed for efficient storage and retrieval of entities from remote repositories (REST APIs, Database, ...etc)
-
tower-limit
Limit maximum request rate to a
Service -
haalka
ergonomic reactive Bevy UI library powered by FRP signals
-
async-stdin
Asynchronously read from stdin
-
fibers_transport
Transport layer abstraction built on top of [
fibers] crate -
fmmap
A flexible and convenient high-level mmap for zero-copy file I/O
-
elfo-network
Distributed actors for elfo
-
pin-macros
primarly used to simplify the proccess of working with self-referencial structures
-
ded
Dead Easy Deduplication
-
hexput-runtime
WebSocket runtime server for Hexput AST processing
-
cqrs-core
Core types and traits for cqrs
-
ockam_transport_udp
UDP Transport for the Ockam Routing Protocol
-
delete
Fast, easy deletion of files and folders with async and cross-platform support
-
awesome-operates
A reposity includs many common use code utils
-
mqtt-codec-kit
MQTT v3.1.1/v5.0 protocol async codec
-
anansi
full-stack web framework for Rust
-
kapacitor-multi-indicator-batch-udf
A multi-indicator batch UDF for Kapacitor
-
jarust_rt
A janus client SDK in Rust
-
simple-async-local-executor
A single-threaded polling-based executor suitable for use in games, embedded systems or WASM
-
garcon
A collection of trait and classes to make your thread or async function wait
-
async-subscription-map
Async bookkeeping datastructure for state subscriptions
-
crb-morph
CRB | Composable Runtime Blocks | Morph
-
dialectic-tokio-mpsc
A backend for the Dialectic crate using Tokio's MPSC channels
-
d3-components
A framework for server development -- the component layer
-
futures-shuttle
Futures-aware shuttle synchronization object
-
mega_etl
A cloud-native ETL (Extract, Transform, Load) application framework based on the WasmEdge WebAssembly runtime for developers to filter, map, and transform data pipelines going into cloud databases
-
specta-typescript
Export your Rust types to TypeScript
-
zino-storage
Files and storage services for zino
-
async-ioutils
A collection of async utilities for I/O
-
ctrlc-async
Easy asynchronous Ctrl-C handler for Rust projects
-
backdrop
Drop your large or complex objects in the background with Backdrop! (later, on another thread, or both! Fully customizable! Tokio supported!)
-
swimos_trigger
SwimOS Asynchronous Trigger
-
rusher-server
Pusher compatible pubsub service
-
zstd-framed
zstd seekable format compression and decompression. Supports sync and async I/O
-
hapic
HTTP API Client (hapic): A Rust crate for quickly creating nice-to-use client libraries for HTTP APIs, in particular, there's lots of tooling around HTTP JSON APIs
-
worst-executor
A spin-loop like executor for async
-
local-pool-with-id
A minor variation on a LocalPool executor which exposes unique IDs for tracking future completion
-
lunatic-control-axum
TBD
-
vertigo
Reactive Real-DOM library with SSR for Rust
-
smol-hyper
Integrations between smol and hyper
-
workflow-async-trait
Type erasure for async trait methods (customized, see README.md notes)
-
async_channel_io
AsyncReadandAsyncWriteimplementations forasync_channel -
aster-proxy
A light, fast and powerful cache proxy written in Rust
-
speed-rs-core
A core HTTP handling server library in Rust, providing low-level HTTP server implementation
-
heph-rt
speciailised runtime for Heph's actor
-
sigfinn
Lifecycle manager for spawning tasks
-
skipdb-core
The core for
skipdbandasync-skipdbcrates -
ipc-orchestrator
Orchestion of command line processes for local dev usage with IPC communication
-
poller
File I/O events library for Rust
-
fe2o3-amqp-cbs
An experimental impl of AMQP 1.0 CBS extension
-
channel-receiver
Channel Receiver
-
ant-libp2p-webtransport-websys
WebTransport for libp2p under WASM environment
-
tokio-shield
Prevent futures from being aborted by wrapping them in tasks
-
again
wasm-compatible retry util for std library futures
-
futures-to-stream
Turn heterogeneous Futures of same associated Output type to a stream
-
jonmo
Bevy-native reactive signals
-
v_exchanges_api_generics
A client for HTTP/HTTPS/WebSocket APIs
-
abstract-ns
Abstract name service traits for use with futures (and tokio)
-
stream-utils
Additional stream combinators
-
tarpc-lib
An RPC framework for Rust with a focus on ease of use
-
axum-flash
Web framework that focuses on ergonomics and modularity
-
tokio-macros
Tokio's proc macros
-
uasync
fast, safe, async executor
-
ferris_chats_server
This binary provides a server for ferris_chat
-
async-watch
Async watch channel
-
deepwell
Wikijump API provider and database manager
-
json-array-stream
Incrementally reads a JSON array through an async stream
-
heim-disk
Cross-platform disk information
-
servo-websocket
A WebSocket (RFC6455) library for Rust
-
chromiumoxide_types
Contains the essential types necessary for using chromiumoxide
-
event_store
deal with every aspect of an eventstore
-
signalr-client
calling SignalR hubs from a Rust cross-platform application, supporting WASM and non WASM targets
-
tokio-utils
Tools for asynchronous programming in Tokio applications
-
futures-executor-preview
Executors for asynchronous tasks based on the futures-rs library
-
async-utils
nothing to see here yet :)
-
tarpc-json-transport
A JSON-based transport for tarpc services
-
netsim
Run tests in network-isolated threads. Intercept and meddle with their packets.
-
winit-runtime
Async winit runtime
-
peace_cmd
Command structure for the Peace framework
-
zino-actix
Integrations with actix-web for zino
-
gidle_future
A future executor for the glib main loop idle time
-
intersession-layer-messaging
A metastable messenger that allows reliability between peers when peers go offline, are unreliable, and facing intermittent network conditions between sessions
-
minechat-protocol
The MineChat protocol, enabling you chat with people over on Minecraft
-
wasm-bindgen-futures
Bridging the gap between Rust Futures and JavaScript Promises
-
async-shell
Asynchronous process child wait
-
koit
asynchronous, pure-Rust, structured, embedded database
-
async-cuda-core
Async CUDA streams and buffers for Rust
-
ntex-io
encoding and decoding frames
-
routerify-multipart
A multipart/form-data parser for Routerify
-
async-llm
OpenAI-compatible APIs
-
eventum
Asynchronous I/O Event manager
-
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) -
asteroid-mq-sdk
Rust SDK for asteroid-mq
-
tower-worker
Tower layers focused on wrapping services with asynchronous worker tasks that may also make requests to the wrapped service
-
tentacle-secio
Secio encryption protocol for p2p
-
actix-server
General purpose TCP server built for the Actix ecosystem
-
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
-
gen-z
Macro-free stream construction through asynchronous generators via an awaitable sender
-
libp2p-upnp
UPnP support for libp2p transports
-
async-openai-wasm
OpenAI on WASM
-
kowalski
A Rust-based agent for interacting with Ollama models
-
anthropic
SDK
-
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.
-
stick
Platform-agnostic asynchronous gamepad, joystick and flighstick library
-
tokio-tungstenite-typed
tokio-tungstenite with type safe messages
-
compio-tls
TLS adaptor with compio
-
stream_multiplexer
Combines many streams into a few
-
koit-toml
asynchronous, pure-Rust, structured, embedded database
-
ohkami
Build web app in intuitive and declarative code
-
robust_downloader
A robust, concurrent file downloader with retry capabilities and progress tracking
-
batched-fn
Middleware for serving deep learning models with batched prediction
-
tower-async-test
writing client and server
Servicetests. An “Async Trait” spiritual fork from the original tower-test Library -
heim-process
Cross-platform processes information
-
eternal
Framework
-
libp2p-yamux
Yamux multiplexing protocol for libp2p
-
openssh-sftp-client-lowlevel
Lowlevel utilities to communicate with openssh sftp server
-
flysystem
A filesystem abstraction layer for Rust
-
rmw_ttlmap
Minimal async cache in Rust with support for key expirations
-
tower-sessions-surrealdb-store
SurrealDB session store. Not for direct use; see the
tower-sessionscrate for details. -
arti-bench
benchmarking utility for Arti
-
slack-morphism-hyper
Slack Morphism Hyper/Tokio support library
-
zephyrus-macros
Procedural macros used by Zephyrus
-
qrecovery
The reliable transport part of QUIC, a part of gm-quic
-
naumi
Lightweight and fast data transfer protocol. Fast de/serialization and tiny size!
-
june
ergonomic remote actors via actix and canary
-
tokio-fd
Non-blocking Read and Write a Linux File Descriptor
-
mlg
An asynchronous Log for Rust
-
boluo-core
boluo的核心类型和特征
-
tinyio
A tiny Rust concurrency runtime library
-
qudp
High-performance UDP encapsulation for QUIC
-
jackrabbit
Real-time Message Queue
-
dbq
Job queueing and processing library with queues stored in Postgres 9.5+
-
txrx
take on the C++ unified executors proposal
-
pulz-executor
Abstractions of some async runtimes
-
eventually
using Event Sourcing in Rust applications
-
tower-buffer
Buffer requests before dispatching to a
Service -
suspend_fn
macro for implicit await
-
async-graphql
A GraphQL server library implemented in Rust
-
async-nats-tokio-rustls-deps
Fork of Asynchronous TLS/SSL streams for Tokio using Rustls
-
prk_async_dataflow
An asynchronous dataflow processing library for Rust with SIMD-accelerated JSON parsing and AI agent capabilities
-
axum-limit
A rate limiting library using token buckets, centered around extractor-based limits for async web applications
-
aldrin
Message bus for service-oriented RPC and interprocess communication
-
async_main
Runtime-agnostic async main proc macro
-
elfo-dumper
Dumps messages of the elfo system on disk
-
npm-package
client for fetching metadata from the npm package
-
sockit
A UDP socket that can read and write serializable data
-
openraft-rocksstore-compat07
A example v07 compatible implementation of the
openraft::RaftStoragetrait -
channel-sender
Channel Sender
-
pagetop
Un entorno de desarrollo para crear soluciones web modulares, extensibles y configurables
-
aalo
aka bevy-inspector-haalka, a bevy_ui-native inspector for Bevy
-
lstngrp
Groups listeners and connections with common data/logic
-
tokio-dbus
Pure Rust D-Bus implementation for Tokio
-
peace_item_tar_x
Manages extracting a tar file for the peace framework
-
switchyard
Real-time compute focused async executor
-
thespis_impl
Reference implementation for the thespis actor model
-
wait-timeout
wait on a child process with a timeout specified across Unix and Windows platforms
-
waaa
WebAssembly, Abstracted Away
-
wtr-watcher
Filesystem watcher. Works anywhere. Simple, efficient and friendly.
-
async-graphql-parser
GraphQL query parser for async-graphql
-
volo
high-performance and strong-extensibility Rust RPC framework that helps developers build microservices
-
async-metronome
Unit testing framework for async Rust
-
async-stream-http-tunnel-grader
Asynchronous stream http tunnel grader
-
hitbox
Asynchronous caching framework in Rust
-
extern_executor
Async executor which delegates futures polling to external event-loop
-
barrage
An async broadcast channel
-
lrcall
procedure call framework that is compatible with local and remote procedure calls
-
num_stream
that provides a Stream that yields incrementing numbers at a specified interval
-
form-data
AsyncRead/AsyncWrite/Stream
multipart/form-data -
axum-macros
Macros for axum
-
peace_rt_model
Runtime data types for the peace automation framework
-
wtransport-proto
WebTransport (over HTTP3) protocol
-
smol-macros
Macros for setting up a smol runtime
-
ruchei-callback
Callback traits for ruchei
-
wayland-protocols-async
Wayland client protocols implemented in async as handlers using the Actor-model and tokio messaging
-
tokio-buf
Asynchronous stream of byte buffers
-
rama-tls-rustls
tls implementations for rama using rustls
-
ockam_transport_uds
Unix Domain Socket (UDS) Transport for the Ockam Routing Protocol
-
graus-db
A high-performance, thread-safe key-value embedded data store
-
v_rusty_tarantool
Tarantul async client based on tokio framework
-
rustmark
Extensible web application for serving Markdown-based content
-
ara
Async random access I/O traits
-
repeating_future
[RepeatingFuture] is a [Future] that can call an async function of an object over and over again
-
rama-http
rama http layers, services and other utilities
-
jarust_interface
A janus client SDK in Rust
-
noop-waker
A waker that does nothing
-
tokio-async-std
An async-std that can fit into tokio ecosystem straight ahead
-
architect-tonic-build
Codegen module of
tonicgRPC implementation -
futures-stream-reader
Convert an [AsyncRead] into a [Stream] of byte chunks
-
tauri-wasm
The tauri framework library for pure rust frontend
-
polaris-core
Lightweight Rust SDK used as Proxyless Service Governance
-
embedded-hal-async
An asynchronous Hardware Abstraction Layer (HAL) for embedded systems
-
vampirc-io
asynchronous, non-blocking, UCI protocol–based communication between chess UIs and chess engines
-
tower-reqwest
Adapter between reqwest and tower-http crates
-
gj
Event loop and promises
-
async-macros
Macros for async-std
-
comet-eventbus
strong-typed sync and asynchronous eventbus
-
posixmq
An idiomatic library for using posix message queues, with optional mio integration
-
spmc_buffer
An extension of triple buffering for multiple-consumer scenarios, useful for sharing frequently updated data between threads
-
viz-core
The core traits and types in for Viz
-
stage
An ergonomic, composable Actor Model, designed for painless concurrency
-
linux-io-uring-sys
The
io_uringbindings for Rust -
zino-extra
Extra utilities for zino
-
beul
It executes futures
-
actix-storage
General key value storage for actix-web
-
swimos_errors
SwimOS Error Utilties
-
memberlist
A highly customable, adaptable, async runtime agnostic gossip protocol which helps manage cluster membership and member failure detection
-
opentls
TLS connections with OpenSSL
-
pingora-proxy
Pingora HTTP proxy APIs and traits
-
phlow-runtime
Phlow is a fast, modular runtime for building backends with YAML flows, Rust modules, and native OpenTelemetry observability
-
clia-rcproxy
A lightweight, fast and powerful Redis Cluster Proxy written in Rust
-
apub-background-jobs
building activitypub servers
-
tokio-lock
Access an object from a single Tokio task
-
ianaio-events
Convenience crate for working with DOM event listeners
-
tokio-byteorder
Asynchronous library for reading/writing numbers in big-endian and little-endian
-
tokio-channel
Channels for asynchronous communication using Tokio
-
hyper-http-proxy
A proxy connector for Hyper-based applications
-
tokio-iocp
IOCP support for the Tokio asynchronous runtime
-
tokio-actor
Macro based Asynchronous Actor System
-
smol-executor-trait
executor-trait implementation for smol
-
kiteticker-async
Async version of the ticker module of the kiteconnect-rs crate
-
crb-pipeline
CRB | Composable Runtime Blocks | Pipeline
-
worterbuch
A message broker / database hybrid
-
aredis
Redis client implemented in Rust
-
mysql_async_uu
Tokio based asynchronous MySql client library
-
minirpc
A minimalist RPC framework
-
asyncore
-
motore-macros
Motore's proc macros
-
kayrx-ui
Framework
-
async-graphql-value
GraphQL value for async-graphql
-
carrot-cake
An a-peeling pub/sub framework
-
toni-macros
Macros for Toni
-
rqlite-ha421
An async implementation of a rqlite client
-
async-ioutil
A collection of Rust asynchronous I/O utilities
-
yash-executor
single-threaded concurrent task executor
-
gjio
Asynchronous input and output
-
rseip-core
core module for rseip
-
openssh-sftp-protocol
Data format used to communicate with openssh mux server
-
russh-agent
Asynchronous ssh-agent client
-
picoserve
An async no_std HTTP server suitable for bare-metal environments
-
scambio
Safe and efficient value exchanges between endpoint pairs
-
fsdr-blocks
Building blocks for FutureSDR signal processing library for SDR and real-time DSP
-
pexels-cli
client for the Pexels API
-
rexie
futures based wrapper around IndexedDB that compiles to webassembly
-
plctag
wrapper of libplctag, with rust style APIs and useful extensions
-
core-futures-tls
A libcore wrapper allowing async/await to be used from no_std crates
-
peace_flow_model
Flow data model for the peace automation framework
-
light-magic
A lightweight, fast and easy-to-use implementation of a optionally encrypted/persistent in-memory database
-
tower-sessions-sqlx-store-chrono
SQLx session stores for
tower-sessionsbut usingchronoinstead oftime -
ssdp-client
An asynchronous library for discovering, notifying and subscribing to devices and services on a network
-
epics-ca
Client library for EPICS Channel Access protocol
-
multhreadown
A multi-threaded download manager with resume capability
-
gloo-timers
Convenience crate for working with JavaScript timers
-
task-executor
A task executor
-
ntex-codec
encoding and decoding frames
-
stream_generator
Allows to easily generate streams with async/await
-
h2
An HTTP/2 client and server
-
hydro
cooperative green tasks
-
taskwait
Runtime agnostic way to wait for a group of async tasks
-
papaleguas
ACME client
-
crb-agent-ext
CRB | Composable Runtime Blocks | Agent Ext
-
bb8_surrealdb2
Surrealdb support for the async bb8 connection pool
-
salvo-oapi
OpenApi support for Salvo web framework
-
noosphere-fs
A high-level, FS-like view over Noosphere content
-
unisub
A Pub/Sub library for Rust backed by Postgres
-
associated-async-io
Async IO traits that use futures instead of poll
-
chtsh
Rust CLI for interacting with https://cht.sh
-
elfo-pinger
Pings groups of the elfo system
-
tubetti
Serve &[u8] data at a localhost url with minimal configuration
-
create-rspc-app
Get started with your next rspc app!
-
heim-net
Cross-platform network information
-
aral-runtime-tokio
Aral Runtime for tokio
-
peace_item_file_download
Manages downloading a file for the peace framework
-
simple-async
Very simple async runtime for Rust
-
async-timer-rs
Hashed timer wheel implementation compatible with asynchronous tasks, support async_std/tokio and other futures base framework
-
tower-balance
Balance load across a set of uniform services
-
ntex-service
ntex service
-
pangotls
TLS Reverse Proxy using Tokio and Rustls
-
wirebolt
Lightweight and performant TCP wrapper
-
yaar
asynchronous runtime optimized around configuration and no_std
-
stream-body
An HttpBody implementation with efficient streaming support for the Rust HTTP library hyper
-
pacifica-rs-rpc-impl-grpc
grpc support for pcifica-rs
-
futuristic
Extensions to the futures crate
-
async-gcode
An async gcode parser for no_std targets
-
hyper-proxy
A proxy connector for Hyper-based applications
-
futuredsp
A signal processing library for SDR and real-time DSP
-
logged-stream
Logging of all read/write operations, errors and drop of underlying IO object
-
tower-batch
batch-toweris a Tower middleware that allows you to buffer requests for batch processing until the buffer reaches a maximum size OR a maximum duration elapses -
crdb-test-utils
Concurrently Replicated DataBase
-
tower-http
Tower middleware and utilities for HTTP clients and servers
-
async-timer
Timers for Rust async story
-
async-stream-tls-upgrader
Asynchronous stream tls upgrader
-
madsim-macros
Madsim's proc-macro
-
spire
The flexible scraper framework powered by tokio and tower
-
booru-rs
An async Booru client for Rust
-
quinn
Versatile QUIC transport protocol implementation
-
indexed-db
Bindings to IndexedDB that default the transactions to aborting and can work multi-threaded
-
specta-serde
Serde support for Specta
-
crb-actor
CRB | Composable Runtime Blocks | Actor
-
tokio_safe_block_on
ability to execute async code from a sync context, without blocking a tokio core thread or busy looping the cpu
-
mwmr
A generic optimistic transaction manger, which is ACID, concurrent with SSI (Serializable Snapshot Isolation)
-
stream-cancel
interrupting asynchronous streams
-
rama-utils
rama
-
ironmq-client
IromMQ client library (AMQP 0.9)
-
holiday_event_api
The Official Holiday and Event API for Rust
-
gloo-file
Convenience crate for working with JavaScript files and blobs
-
rdbc-rs
Futures base Rust DataBase Connectivity (RDBC) library
-
tonic-async-interceptor
Async variant of Tonic's interceptor function
-
async-thread
Futures version of std::thread
-
thalo_runtime
A high-performance event sourcing runtime utilizing WebAssembly an embedded event store
-
tower-sessions-redis-store
Redis session store for
tower-sessions -
doip_rw_tokio
Diagnostic over IP asynchronous API to implement a DoIP tester or entity
-
param
Param-style trait
-
alzheimer
Async implementation of brainfuck interpreter
-
minehut
easy to use Rust wrapper for the Minehut API
-
tonic-health
Health Checking module of
tonicgRPC implementation -
zino-ntex
Integrations with ntex for zino
-
genawaiter-macro
Convenience macros for generators (genawaiter)
-
mqtt-proto
MQTT v3.1/v3.1.1/v5.0 protocol sync/async codec
-
message-io
Fast and easy-to-use event-driven network library
-
qconnection
Encapsulation of QUIC connections, a part of gm-quic
-
aggligator-monitor
Aggligator link monitor and speed test
-
rados_hi
Opinionated high-level wrapper for librados (Ceph)
-
tokio-compat-02
Tokio 0.2 compat utilities
-
lspower
A lightweight framework for implementing LSP servers
-
packet-ipc
Share packets between services using servo ipc
-
heim-runtime
Runtime shims for heim crate
-
aldrin-parser
Aldrin schema parser library
-
monolake
High Performance Proxy base on Monoio
-
mai
A higher-level mio interface
-
dialectic-null
A no-op backend for the Dialectic crate, intended for benchmarking and testing
-
rabbit_mqr
Extremely Simplified RabbitMQ Client
-
kvarn-quinn
Temporary Kvarn fork: Versatile QUIC transport protocol implementation
-
continue
Swift-style continuation API
-
tower-memlim
Tower based middleware layer to limit requests based on the host's computer memory usage
-
vesper-macros
Procedural macros used by Zephyrus
-
yahf
HTTP Framework focused on DX
-
tiny-jsonrpc
Json rpc lib based on reqwest
-
orengine-macros
Procedural macros for use with Orengine
-
openai_responses
Rust SDK for the OpenAI Responses API
-
recursive_scraper
Constant-frequency recursive CLI web scraper with frequency, filtering, file directory, and many other options for scraping HTML, images and other files
-
irc
usable, async IRC for Rust
-
async-events-emitter
providing an implementation of an event handling system
-
swimos_format
SwimOS Formatting Utilities
-
memstore
An in-memory implementation of the
async-raft::RaftStoragetrait -
nodium-events
event system for Rust
-
futures-macro-await
Definition of the
await!macro for thefuturescrate -
tower-sessions-libsql-store
A small library for using tower-sessions with libsql
-
yaar-reactor
Non-blocking IO abstractions for building executors
-
zino-channel
Cloud events and subscriptions for zino
-
future_pubsub
A tokio based publish-subscibe channel
-
genawaiter2-proc-macro
procedural macro for generators (genawaiter2)
-
peace_cli_model
Command line interface data types for the peace automation framework
-
cargo-daku
Daku API cargo plugin
-
libp2p-floodsub
Floodsub protocol for libp2p
-
build_async
Rust Macros to Unify Synchronous and Asynchronous Codebases
-
mycorrh
fast concurrent messaging system for Rust
-
async-tls
Asynchronous TLS/SSL streams using Rustls
-
jarust_core
A janus client SDK in Rust
-
async-graphql-relay
Relay support for async-graphql
-
tl-async-runtime
A bad runtime impl for educational purposes only
-
pingora
A framework to build fast, reliable and programmable networked systems at Internet scale
-
tacacs-plus
An asynchronous, runtime-independent RFC8907 TACACS+ client
-
specta-jsdoc
Export your Rust types to JSDoc
-
async-http-client-lite
Asynchronous http client
-
rusher-core
Pusher compatible pubsub service
-
rxqlite-sqlx-common
A distributed sqlite database built upon
openraft,sqlxandsqlite -
wasm-agnostic
users who want to write async runtime-agnostic crate for wasm target
-
poem-grpc-build
Codegen module of poem-grpc
-
swimos_time
SwimOS Time Utlities
-
iroh-quinn
Versatile QUIC transport protocol implementation
-
ant-libp2p-upnp
UPnP support for libp2p transports
-
bellande_mesh_sync
Advanced peer-to-peer data synchronization system for distributed applications
-
surrealdb-async-graphql-axum
async-graphql for axum
-
tonic-sysinfo
A gRPC service for monitoring system resources such as CPU, memory, and disk
-
fieldset
Struct to enum derivation
-
redeez
queueing system for Redis
-
ntex-tokio
tokio intergration for ntex framework
-
tokio-test-shutdown-timeout
Tokio test attribute with a shutdown timeout
-
salvo
powerful web framework that can make your work easier
-
memberlist-proto
Proto types and traits for the memberlist crate
-
tokio-dbus-macros
Pure Rust D-Bus implementation for Tokio
-
ockam_transport_core
Generic Transport primitives
-
ant-libp2p-yamux
Yamux multiplexing protocol for libp2p
-
tinywake
A minimal, no_std-compatible waker implementation for Cortex-M async executors
-
rusturn
TURN server and client
-
peace_webi_rt
Web interface runtime data types for the peace automation framework
-
msquic
Microsoft implementation of the IETF QUIC protocol
-
pea2pea
low-level, and customizable implementation of a TCP P2P node
-
futures-async-runtime-preview
Runtime for the async/await macros in the
futurescrate -
exo_task
A lightweight async task executor for bare metal (or any) systems
-
elfo-logger
Logs events of the elfo system
-
tower-sesh-core
Core components for
tower-seshand related crates -
mysql_async_wasi
Tokio based asynchronous MySql client library
-
generic-api-client
A client for HTTP/HTTPS/WebSocket APIs
-
turboscraper
A high-performance, concurrent web scraping framework for Rust with built-in support for retries, storage backends, and concurrent request handling
-
tower-sessions-moka-store
Moka session store for
tower-sessions -
gloo-worker
Convenience crate for working with Web Workers
-
openssh-sftp-error
Error type used when communicating with openssh sftp server
-
async-rustls-stream
An async tls stream library based on rustls and futures-io. Both for server/client.
-
citadel_logging
logging library for the Citadel Protocol
-
direct-executor
An executor that directly executes futures, suitable for embedded environments
-
compio-log
Log of compio
-
async-ready
Async readiness traits
-
ntex-server
Server for ntex framework
-
memphis-rust-community
Memphis Messaging Protocol
-
async-watch2
Async watch channel
-
psbus
Generic Publish / Subscribe model for application messaging
-
wtransport
WebTransport (over HTTP3) protocol
-
nervemq
Portable, SQS-compatible message queue backed by SQLite
-
futures_ringbuf
Mock Type implementing AsyncRead/AsyncWrite for testing and examples
-
aral-runtime-async-std
Aral Runtime for async-std
-
liburing
Rust liburing#24bd087 raw bindings with basic tests
-
acton_test
Testing utilities for Acton agents, providing tools to help in the testing and validation of agent behavior
-
ockam_node_no_std
Ockam library types that do not need
std -
cyper-core
Core adaptors and services for compio running on hyper
-
kcp-rs
KCP Stream Protocol
-
rama-haproxy
rama HaProxy support
-
completeq-rs
An alternative to passing messages between asynchronous tasks
-
netbeam
a pure-rust asynchronous network synchronization crate (using tokio) that recreates familiar asynchronous paradigms but in a network context
-
nidrs-diesel
Nidrs & Diesel integration
-
zookeeper-cache-rust
ZooKeeper client cache
-
monoio-native-tls
Asynchronous TLS streams wrapper for Monoio based on NativeTLS
-
greenthread-future
Convert closures to futures based on greenthread on bare-metal (no_std + no_alloc)
-
async-graphql-axum
async-graphql for axum
-
sse-codec
async Server-Sent Events protocol encoder/decoder
-
hyper-proxy2
A proxy connector for Hyper-based applications
-
tower-retry
Retry failed requests
-
swimos_runtime
SwimOS Agent & Downlink Runtime
-
tower-etag-cache
A tower middleware for implementing ETag-based HTTP caching
-
futures-rustls
Asynchronous TLS/SSL streams for futures using Rustls
-
pychan
A collection of channels for sending around items of type
pyo3::Py<T> -
woke
A minimalistic waker implementation for executors
-
swimos_fs
SwimOS Filesystem Utilities
-
turbocharger
Autogenerated async RPC bindings that instantly connect a JS frontend to a Rust backend service via WebSockets and WASM
-
tor-events
A typed event broadcasting framework for Arti
-
kuri_mcp_protocol
Core types for the MCP protocol
-
futuresdr-frontend
Web Frontend for an Experimental Async SDR Runtime for Heterogeneous Architectures
-
agnostic-dns
agnostic-dnsis an agnostic abstraction layer overhickory-dns -
async-graphql-rocket
async-graphql for Rocket.rs
-
rspc-tauri
Tauri adapter for rspc
-
volo-grpc
gRPC framework implementation of volo
-
ockam_executor
Ockam async executor crate
-
misanthropic
An async, ergonomic, client for Anthropic's Messages API
-
lunatic-control
TBD
-
ohkami_lib
internal library for Ohkami - intuitive and declarative web framework
-
zino-amis
UI generator for amis
-
async-tungstenite
Async binding for Tungstenite, the Lightweight stream-based WebSocket implementation
-
takyon
single threaded async runtime
-
tokio-serde
Send and receive Serde encodable types over the network using Tokio. This library is used as a building block for serialization format specific libraries
-
qevent
qlog implementation
-
async-imap-lite
Asynchronous imap
-
tower-sessions-file-store
Store sessions for Tower Session store on the file system
-
aggligator-transport-webusb
Aggligator transport: WebUSB for targeting WebAssembly
-
turmoil
Simulation testing framework for distributed systems
-
rust_transit
A broker-agnostic asynchronous event library
-
fetchy
Async HTTPS fetch API built on pasts
-
peace_rt
Runtime logic for the peace automation library
-
volo-thrift
Thrift RPC framework implementation of volo
-
libp2p-wasm-ext
Allows passing in an external transport in a WASM environment
-
actix-storage-hashmap
actix-storage based on hashmap
-
shadocal
A blazingly fast, Google calendar (more in future) event formatter webserver tool
-
rama-tcp
TCP support for rama
-
actix-tls
TLS acceptor and connector services for Actix ecosystem
-
idb-sys
A callback based crate for interacting with IndexedDB on browsers using webassembly
-
async-backtrace
Efficient, logical 'backtraces' of async tasks
-
crb-supervisor
CRB | Composable Runtime Blocks | Supervisor
-
moosicbox_task
MoosicBox task utilities package
-
dialectic-tokio-serde
A backend builder for the Dialectic crate using Serde serialization over Tokio transport
-
tracing-forest
Preserving contextual coherence among trace data from concurrent tasks
-
nostr-bot
Nostr bot library
-
acmer
ACME TLS certificates management library
-
rawst_dl
Snag your files efficiently with Rawst downloader
-
madsim-tonic-build
Codegen module of
madsim-tonicsimulation implementation -
noosphere-ipfs
An interface for an IPFS client
-
multitask
An executor for running async tasks
-
mirai
A Futures layer over Mio
-
mfio-rt
mfio based async runtime
-
async-anthropic
Anthropic Rust Client
-
toy-rpc
An async RPC that mimics golang net/rpc's usage and supports both async-std and tokio
-
basteh
Generic kv storage with replaceable backend
-
logimesh
RPC Microservice 2.0 framework
-
actix-storage-dashmap
actix-storage based on dashmap
-
msgtrans
Support for a variety of communication protocols such as TCP / QUIC / WebSocket, easy to create server and client network library
-
ntex-async-std
async-std intergration for ntex framework
-
async-std-test
Alternate implementation of the #[async_std::test] macro
-
swimos_msgpack
SwimOS MessagePack
-
boluo
简单易用的异步网络框架
-
ntex-grpc-codegen
GRPC Client/Server framework (codegen)
-
pingora-rustls
RusTLS async APIs for Pingora
-
libp2p-ratelimit
Transfer rate limiting transport adapter for libp2p
-
aggligator-transport-tcp
Aggligator transport: TCP
-
plctag-async
async wrapper for libplctag
-
bongonet-openssl
OpenSSL async APIs for Bongonet
-
rxqlite-tests-common
A distributed sqlite database built upon
openraft,sqlxandsqlite -
crab-kafka
Forward <TCP|UDP> + TLS traffic to kafka
-
aldrin-codegen
Aldrin code generator library
-
poem-mcpserver
MCP Server implementation for Poem
-
ruchei-extra
Stream/Sink wrapper with extra data, as used by ruchei
-
ntex-files
Static files support for ntex web
-
reqwest-streams
HTTP body streaming support for reqwest: JSON/CSV/Protobuf and others
-
rillrate-system
RillRate agent for system monitoring
-
lelet
golang like task executor
-
memberlist-types
Types used in the memberlist crate
-
just-watch
Async watch channel
-
mercury
The official Rust client for the Mercury Parser
-
zino-chatbot
Unified access to chatbot services for zino
-
iroh-quinn-udp
UDP sockets with ECN information for the QUIC transport protocol
-
async-compression
Adaptors between compression crates and Rust's modern asynchronous IO types
-
poem-openapi
OpenAPI support for Poem
-
aggligator-wrapper-tls
Aggligator transport wrapper: TLS
-
http-lib
High-level, asynchronous API for ureq, a safe HTTP client
-
fast_websocket_client
A fast asynchronous websocket client built on top of fastwebsockets library
-
multipart-rs
zero-allocation, streaming, async multipart reader & writer for Rust
-
yacme-service
ACME high-level client library
-
winio
Single-threaded async GUI runtime based on compio
-
libp2p-websocket-websys
WebSocket for libp2p under WASM environment
-
actix-taskqueue
A generic task queue service for Actix
-
peace_webi
Web interface for the peace automation framework
-
socketioxide
Socket IO server implementation in rust as a Tower Service
-
agnostic_async_executor
Agnostic Rust Async Executor
-
marzban_api
async client which abstracts/simplifies the interactions with the Marzban panel API (https://github.com/Gozargah/Marzban)
-
salvo-jwt-auth
Jwt auth support for salvo web server framework
-
actix-service
Service trait and combinators for representing asynchronous request/response operations
-
swiftide-core
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
axum-handle-error-extract
Error handling layer for axum that supports extractors and async functions
-
ntex-rt
ntex runtime
-
tower-async-layer
Decorates a
Serviceto allow easy composition betweenServices. An “Async Trait” fork from the original Tower Library -
tokio-dbus-xml
Pure Rust D-Bus implementation for Tokio
-
dipper
An out-of-the-box modular dependency injection web application framework
-
crdb-server
Concurrently Replicated DataBase
-
mews
Minimal and Efficient, Multi-Environment WebSocket implementation for async Rust
-
jarust_transport
A janus client SDK in Rust
-
tauri-plugin-rspc
Tauri adapter for rspc
-
libp2p-dcutr
Direct connection upgrade through relay
-
libp2p-uds
Unix domain sockets transport for libp2p
-
ant-libp2p-plaintext
Plaintext encryption dummy protocol for libp2p
-
edge-raw
Async +
no_std+ no-alloc implementation of IP and UDP packet creation and parsing -
pollster-macro
Proc-macro crate for pollster
-
crdb-cache
Concurrently Replicated DataBase
-
axum-server2
High level server designed to be used with axum framework
-
json-job-dispatch
Dispatch jobs described by JSON files and sort them according to their status
-
tower-timeout
Apply a timeout to requests, ensuring completion within a fixed time duration
-
peace_fmt
Presentation and formatting support for the peace automation framework
-
kanagawa
Web framework based on Tide with Proactive IO
-
openraft-macros
Advanced Raft consensus
-
madsim-tonic
The
tonicsimulator on madsim -
async-retry
Async Retry
-
ntex-glommio
glommio intergration for ntex framework
-
futures-mpsc
A futures aware, bounded, MPSC channel with back pressure support
-
pingora-cache
HTTP caching APIs for Pingora proxy
-
async-h1
Asynchronous HTTP 1.1 parser
-
toy-rpc-ha421
An async RPC that mimics golang net/rpc's usage and supports both async-std and tokio
-
qbase
Core structure of the QUIC protocol, a part of gm-quic
-
async-graphql-poem
async-graphql for poem
-
nodecraft
Crafting seamless node operations for distributed systems, which provides foundational traits for node identification and address resolution
-
gloo-events
Convenience crate for working with DOM event listeners
-
stream-consumer-task
Start asynchronous task in background to consume stream
-
async-mongodb-session
An async-session implementation for MongoDB
-
libhoney-rust
sending data to Honeycomb
-
crb-core
CRB | Composable Runtime Blocks | Core
-
futuresdr-remote
Remote interaction library for FutureSDR
-
microsleep
high performance async sleep for massive numbers of timers
-
tokio-tungstenite
Tokio binding for Tungstenite, the Lightweight stream-based WebSocket implementation
-
citadel_io
Underlying runtime for interfacing with I/O for std/wasm targets
-
bastion-executor-trait
executor-trait implementation for bastion
-
leap_client_rs
Rust client library for the Leap Edge socket service
-
tokio01-test
Testing utilities for Tokio and futures-based code
-
elfo-core
The core of the elfo system
-
actix-web-async-await
preview of Actix with async/await support
-
poem-grpc
GRPC support for Poem
-
echannel
Async channel for mixed events
-
rusher
Pusher compatible pubsub service
-
kayrx-timer
The Kayrx Framework
-
edge-mqtt
Implements the embedded-svc MQTT traits on top of the rumqttc crate
-
qinterface
gm-quic's packet routing and definition of the underlying IO interface
-
tonic-reflection
Server Reflection module of
tonicgRPC implementation -
compio-macros
Proc macro of compio
-
salvo-cors
CORS support for salvo web server framework
-
aldrin-broker
Broker library of Aldrin, a message bus for service-oriented RPC and interprocess communication
-
specta-util
High-level utilities for working with Specta
-
axum-sessions
🥠 Cookie-based sessions for Axum via async-session
-
tokio-net
Event loop that drives Tokio I/O resources
-
swiftide-macros
Fast, streaming indexing, query, and agentic LLM applications in Rust
-
tower-load
Strategies for measuring the load of a service
-
tower-make
Trait aliases for Services that produce specific types of Responses
-
peace_item_sh_cmd
Manages running a shell command for the peace framework
-
peace_rt_model_native
Runtime data types for the peace automation framework
-
ant-libp2p-gossipsub
Gossipsub protocol for libp2p
-
srad-client
Types and traits for implementing Sparkplug Clients
-
peace_item_blank
Copies a number from one resource to another
-
zino-salvo
Integrations with salvo for zino
-
postel
High level server for hyper and tower
-
wtx-macros
Procedural macros for wtx
-
salvo-session
Session support for salvo web server framework
-
peace_cmd_rt
Runtime types for commands for the Peace framework
-
ws_stream_wasm
A convenience library for using websockets in WASM
-
bolt-client
A client that sends messages using the Bolt protocol
-
emitter-rs
📢 Emitter RS is a lightweight EventEmitter implementation for Rust and Wasm
-
async-process
Async interface for working with processes
-
ant-libp2p-swarm-test
Test framework for code building on top of libp2p-swarm
-
nb-connect
Non-blocking TCP or Unix connect
-
rxqlite-notification
A distributed sqlite database built upon
openraft,sqlxandsqlite -
rama-tls
tls implementations for rama
-
nidrs
web framework based on axum and tokio
-
async-graphql-derive
Macros for async-graphql
-
aldrin-core
Shared core components of Aldrin, a message bus for service-oriented RPC and interprocess communication
-
peace_rt_model_web
Web support for the peace automation framework
-
mendes
Rust web toolkit for impatient perfectionists
-
pasts
Minimal and simpler alternative to the futures crate
-
citadel_wire
NAT traversal and wire support for the Citadel Protocol
-
monoio-macros
Monoio proc macros
-
rama-udp
UDP support for rama
-
socketioxide-redis
Redis adapter for the socket.io protocol
-
peace_item_spec_tar_x
Manages extracting a tar file for the peace framework
-
pingora-core
Pingora's APIs and traits for the core network protocols
-
libp2p-mplex
Mplex multiplexing protocol for libp2p
-
cyper
HTTP client library based on compio and hyper
-
libp2p-request-response
Generic Request/Response Protocols
-
actix-threadpool
Actix thread pool for sync code
-
mio-more
Extra components for use with Mio
-
futures-async-stream-macro
detail of the
futures-async-streamcrate -
serf-core
A decentralized solution for service discovery and orchestration that is lightweight, highly available, and fault tolerant
-
ant-libp2p-dcutr
Direct connection upgrade through relay
-
peace_item_spec_file_download
Manages downloading a file for the peace framework
-
tower-service
Trait representing an asynchronous, request / response based, client or server
-
crdb-indexed-db
Concurrently Replicated DataBase
-
salvo-serve-static
Serve static assets for salvo web server framework
-
libp2p-autonat
NAT and firewall detection for libp2p
-
futures-boring
SSL streams for Futures built on top of the BoringSSL
-
wamp_async
An asynchronous WAMP implementation
-
client-util
Help you to build requests and handle responses by several extension trait!
-
task-stream
a global task executor, run in
no_std -
h3-shim
Shim libray between gm-quic and h3
-
global-executor
Configure a global executor you can reuse everywhere
-
peace_cmd_model
Data types for commands for the Peace framework
-
tower-async-http
Tower Async middleware and utilities for HTTP clients and servers. An "Async Trait" fork from the original Tower Library
-
ntex-util
ntex framework
-
tower-spawn-ready
Drives service readiness via a spawned task
-
tower-test
writing client and server
Servicetests -
rama-dns
DNS support for rama
-
actix-testing
Various helpers for Actix applications to use during testing
-
async-std
Deprecated in favor of
smol- Async version of the Rust standard library -
actix-files
Static file serving for Actix Web
-
tonic-web
grpc-web protocol translation for tonic services
-
peace_value_traits
Trait bounds for value types for the Peace framework
-
crdb
Concurrently Replicated DataBase