-
mio
Lightweight non-blocking I/O
-
tokio
An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications
-
tokio-rustls
Asynchronous TLS/SSL streams for Tokio using Rustls
-
deadpool
Dead simple async pool
-
rdkafka
Rust wrapper for librdkafka
-
futures
streams featuring zero allocations, composability, and iterator-like interfaces
-
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
-
blocking
A thread pool for isolating blocking I/O in async programs
-
async-broadcast
Async broadcast channels
-
futures-timer
Timeouts for futures
-
async-process
Async interface for working with processes
-
pollster
Synchronously block the thread until a future completes
-
polling
Portable interface to epoll, kqueue, event ports, and IOCP
-
async-std
Async version of the Rust standard library
-
bb8
Full-featured async (tokio-based) connection pool (like r2d2)
-
multer
An async parser for
multipart/form-datacontent-type in Rust -
tokio-serial
A serial port implementation for tokio
-
suppaftp
A super FTP/FTPS client library for Rust
-
paho-mqtt
The Official Eclipse Paho MQTT Rust Client Library. This is a wrapper around the Paho C library
-
interprocess
communication toolkit
-
event-listener
Notify async tasks or threads
-
minus
An asynchronous data feedable terminal paging library for Rust
-
async_zip
An asynchronous ZIP archive reading/writing crate
-
ractor
A actor framework for Rust
-
async-trait
Type erasure for async trait methods
-
futures-concurrency
Structured concurrency operations for async Rust
-
amqprs
AMQP 0-9-1 client implementation for RabbitMQ
-
keycloak
Admin REST API
-
want
Detect when another Future wants a result
-
openraft
Advanced Raft consensus
-
tower-sessions
🥠 Sessions as a
towerandaxummiddleware -
cucumber
testing framework for Rust, with async support. Fully native, no external test runners or dependencies.
-
redis-async
An asynchronous futures based Redis client for Rust using Tokio
-
calloop
A callback-based event loop
-
async-scoped
Spawn scoped (non 'static) asynchronous futures for async_std and tokio runtimes
-
async-io
Async I/O and timers
-
failsafe
A circuit breaker implementation
-
futures-locks
Futures-aware lock primitives
-
tokio-metrics
Runtime and task level metrics for Tokio applications
-
monoio
A thread per core runtime based on iouring
-
tor-rtcompat
Compatibility layer for asynchronous runtimes, used by Tor
-
ws_stream_tungstenite
Provide AsyncRead/AsyncWrite over Tungstenite WebSockets
-
local-channel
A non-threadsafe multi-producer, single-consumer, futures-aware, FIFO queue
-
unicycle
A scheduler for driving a large number of futures
-
madsim
Deterministic Simulator for distributed systems
-
stream-cancel
interrupting asynchronous streams
-
nb
Minimal non-blocking I/O layer
-
apalis
extensible multithreaded background job processing for Rust
-
tokio-graceful
util for graceful shutdown of tokio applications
-
rxrust
Reactive Extensions
-
futures-signals
Zero cost FRP signals using the futures crate
-
async-native-tls
Native TLS using futures
-
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
-
tokio-native-tls
TLS/SSL streams for Tokio using native-tls giving an implementation of TLS for nonblocking I/O streams
-
containerd-shim
containerd shim extension
-
futures-buffered
future concurrency primitives with emphasis on performance and low memory usage
-
eyeball
Add observability to your Rust types!
-
asynchronous-codec
encoding and decoding frames using
async/await -
motore
modular and reusable components for building robust clients and servers. Motore is greatly inspired by Tower.
-
esrs
A Prima.it-opinionated library to achieve cqrs/es
-
futures-lite
Futures, streams, and async I/O combinators
-
async-recursion
Recursion for async functions
-
io-uring
The low-level
io_uringuserspace interface for Rust -
tokio-retry
Extensible, asynchronous retry behaviours for futures/tokio
-
async-shutdown
one-stop solution for async graceful shutdown
-
reactive-mutiny
async Event-Driven Reactive Library with advanced & optimized containers (channels) and Stream executors
-
fang
Background job processing library for Rust
-
service-async
A Service like tower in async style
-
exponential-backoff
An exponential backoff generator with jitter
-
actix-web-flash-messages
Flash messages for actix-web applications
-
tokio-zookeeper
Asynchronous client library for interacting with Apache ZooKeeper
-
rusty_falcon
Rust bindings for CrowdStrike Falcon API
-
pharos
Observer pattern which generates a futures 0.3 stream of events
-
tmq
ZeroMQ bindings for Tokio
-
c-ares-resolver
An asynchronous DNS resolver, backed by c-ares
-
lamellar
asynchronous tasking runtime for HPC systems developed in RUST
-
kdbplus
Dual q/kdb+ interface for API to build a shared library and an IPC client
-
fluvio-future
I/O futures for Fluvio project
-
genawaiter
Stackless generators on stable Rust
-
tor-rpcbase
Low level functionality for Arti's RPC service
-
hirun
A concurrent framework for asynchronous programming based on event-driven, non-blocking I/O mechanism
-
mml-lib
Emacs MIME message Meta Language (MML)
-
async-speed-limit
Asynchronously speed-limiting multiple byte streams
-
wasm-bindgen-futures
Bridging the gap between Rust Futures and JavaScript Promises
-
fvm_shared
Filecoin Virtual Machine shared types and functions
-
tokio-graceful-shutdown
perform a graceful shutdown on a Tokio based service
-
hydra
A framework for writing fault tolerant, highly scalable applications with the Rust programming language
-
scoped-futures
imposing upper bounds on Future lifetimes
-
celery
Rust implementation of Celery
-
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
-
async-fn-stream
Lightweight implementation of
async-streamwithout macros -
fn_graph
Dynamically managed function graph execution
-
async-ssh2-lite
Asynchronous ssh2
-
futures-bounded
bounding futures in size and time
-
hypercore
Secure, distributed, append-only log
-
kafka
Rust client for Apache Kafka
-
stilgar
A lightweight, no-fuss, drop-in replacement for Rudderstack
-
gix-actor
A way to identify git actors
-
cxx-async
interoperability between C++ coroutines and asynchronous Rust
-
yt-dlp
⚙️ A Rust library (with auto dependencies downloading) for yt-dlp 🎬️
-
kameo
Fault-tolerant Async Actors Built on Tokio
-
apis
Reactive, session-oriented, asynchronous process-calculus framework
-
futures-rustls
Asynchronous TLS/SSL streams for futures using Rustls
-
swiftide-query
Blazing fast, streaming pipeline library for AI applications
-
lazy-pool
Experimental lazy object pool
-
triggered
Triggers for one time events between tasks and threads
-
swiftide
Blazing fast, streaming pipeline library for AI applications
-
lcode
An application of terminal write leetcode.一个终端刷力扣的应用
-
tokio_schedule
schedule tasks in tokio runtime
-
dataloader
Facebook's DataLoader using async-await
-
actix
Actor framework for Rust
-
peace_rt_model_native
Runtime data types for the peace automation framework
-
safina
Safe async runtime
-
async-walkdir
Asynchronous directory traversal for Rust
-
faktory
API bindings for the language-agnostic Faktory work server
-
filebuffer
Fast and simple file reading
-
mangadex-desktop-api2
A Actix server for downloading manga, chapters, covers from Mangadex
-
poem-openapi
OpenAPI support for Poem
-
napi-calm-down
N-API bindings
-
rocketmq-rust
Unofficial Rust implementation of Apache RocketMQ
-
dark-std
asynchronous containers build on tokio. It uses a read-write separation design borrowed from Golang
-
crosstown_bus
Event Bus with RabbitMQ for Rust
-
cancel-safe-futures
Alternative futures adapters that are more cancellation-aware
-
stakker
A lightweight low-level single-threaded actor runtime
-
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
-
wg
Golang like WaitGroup implementation for sync/async Rust
-
trait-variant
working with impl traits in Rust
-
async-tempfile
Automatically deleted async I/O temporary files
-
rs-event-emitter
simulate promise implementation for rust
-
tokio-io-utility
Some helper functions for tokio::io
-
partial-io
Helpers to test partial, interrupted and would-block I/O operations, with support for property-based testing through proptest and quickcheck
-
multishot
An async, lock-free, reusable channel for sending single values to asynchronous tasks
-
a10
io_uring library
-
poster
MQTTv5 client library written in Rust
-
poll-promise
Poll the result of an async operation in a game or immediate mode GUI
-
flourish
Convenient and full-featured signals for Rust
-
conogram
An async wrapper for Telegram Bot API
-
mobc
A generic connection pool with async/await support
-
interruptible
Stops a future producer or stream from producing values when interrupted
-
async-lsp
Asynchronous Language Server Protocol (LSP) framework based on tower
-
executor-trait
A collection of traits to define a common interface across executors
-
pijul
A distributed version control system
-
krecik
Asynchronous, parallel external service checker (and reporter), using industry standard libraries: Curl, ngHTTP2 and OpenSSL
-
aqueue
fast speed thread safe async execute queue
-
async-socks5
An async/.await SOCKS5 implementation
-
tiny-tokio-actor
tiny actor library on top of tokio
-
async-graphql-actix-web
async-graphql for actix-web
-
debounced
building delayed
Futures and debouncedStreams that wait a given duration before yielding the most recent item -
glommio
thread-per-core crate that makes writing highly parallel asynchronous applications in a thread-per-core architecture easier for rustaceans
-
mio-serial
A serial port implementation for mio
-
deno_unsync
A collection of adapters to make working with Tokio single-threaded runtimes easier
-
countio
Byte counting for std::io::{Read, Write, Seek} and its async variants from futures and tokio
-
rust-parallel
Fast command line app in rust/tokio to run commands in parallel. Similar interface to GNU parallel or xargs.
-
async-dropper
The least-worst ad-hoc implementation of AsyncDrop as a Derive macro
-
syslog-rs
A native Rust implementation of the glibc/libc syslog
-
compio
Completion based async runtime
-
pi-async-rt
Based on future (MVP), a universal asynchronous runtime and tool used to provide a foundation for the outside world
-
decrypt-cookies
A decrypt browser crate
-
round-based
Driver for MPC protocols
-
ipc-queue
FIFO queue described in fortanix-sgx-abi used for asynchronous usercalls
-
tokio_wasi
An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications
-
ferrisgram
An elegent rust client for the Telegram Bot API
-
etcdv3client
etcdv3 client
-
get_chunk
File iterator or stream with auto or manual chunk size selection
-
tros
Your tros from tarantool TX thread to tokio(..and others!)
-
delay_timer
Time-manager of delayed tasks. Like crontab, but synchronous asynchronous tasks are possible, and dynamic add/cancel/remove is supported.
-
async-ringbuf
Async SPSC FIFO ring buffer
-
irelia
wrapper around the native LoL APIs
-
ghost_actor
GhostActor makes it simple, ergonomic, and idiomatic to implement async / concurrent code using an Actor model
-
another-rxrust
A different implementation than
rxRustfor easier use ofReactiveXinRust -
ya-gcp
APIs for using Google Cloud Platform services
-
hypercore-protocol
Replication protocol for Hypercore feeds
-
springtime-di
Dependency injection framework based on automatic component discovery and runtime autowiring
-
lazy_async_promise
Primitives for lazily getting data from futures with tokio for immediate mode guis
-
lemmy_db_views_actor
A link aggregator for the fediverse
-
llm_client
The Easiest Rust Interface for Local LLMs, and an Interface for Deterministic Signals from Probabilistic LLM Vibes
-
speare
actor-like thin abstraction over tokio::task and flume channels
-
kube-coordinate
Kubernetes leader election using the coordination.k8s.io API
-
kafru
Python Celery-inspired queuing library for Rust, using cron for scheduling and SurrealDB for storing queues, metrics, and schedules
-
monzo-lib
async Monzo client in pure rust
-
tokio-test
Testing utilities for Tokio- and futures-based code
-
blockstore
An IPLD blockstore capable of holding arbitrary data indexed by CID
-
tokio-pipe
Asynchronous pipe(2) library using tokio
-
messagebus
allows intercommunicate with messages between modules
-
futuresdr
An Experimental Async SDR Runtime for Heterogeneous Architectures
-
daktronics-allsport-5000
decoders for the Daktronics All Sport 5000's serial output
-
twilight-http-ratelimiting
Discord REST API ratelimiter implementations for the Twilight ecosystem
-
fvm_actor_utils
Utils for authoring native actors for the Filecoin Virtual Machine
-
rxr
Reactive extensions for event-driven applications
-
tokio-scheduler-rs
JobScheduler written with tokio runtime, automatic retry, hook and custom storage supported
-
keen-retry
-- yet powerful -- zero-cost-abstractions & zero-copy lib for error handling & recovery
-
mail-message
A program for easy, quick, and fault tolerant sending of emails from the command line
-
nuclei
Proactive IO & runtime system
-
containerd-client
GRPC bindings to containerd APIs
-
ate
Distributed immutable data store with strong encryption and authentication
-
stream_throttle
Stream combinator, to limit the rate at which items are produced
-
hannibal
a small actor library
-
reactio
Low-Latency Event Driven Nonblocking Reactor Pattern
-
tor-rtmock
Testing mock support for tor-rtcomapt
-
pty-process
spawn commands attached to a pty
-
wgpu-async
Converts some WGPU callback methods to async methods
-
b2_backblaze
basic async library to upload small files to backblaze b2 service
-
freedom-api
Freedom API for Rustaceans
-
kube-lease-manager
Ergonomic and reliable leader election using Kubernetes Lease API
-
futures-util
Common utilities and extension traits for the futures-rs library
-
local-waker
A synchronization primitive for thread-local task wakeup
-
mini_exercism
Minimalistic Rust library to interact with the Exercism.org APIs
-
async-object-pool
object pool implementation that uses asynchronous synchronization primitives only
-
drop-stream
A stream that wraps another stream with a closure that is called once it is dropped
-
rocketmq-common
Apache rocketmq common
-
async_cache
Async refresh cache
-
postage
An async channel library
-
async_smux
Asynchronous smux multiplexing library
-
c-ares
wrapper for the c-ares library, for asynchronous DNS requests
-
actix-casbin
An Actix actor for casbin
-
tokio-stream
work with
Streamandtokio -
async-cuda
Async CUDA for Rust
-
netidx-protocols
Protocols built on top of netidx
-
duplicate-checker
A duplicate file checker
-
rabbit-auto
Wrappers for lapin publishers and consumers
-
keyring-lib
High-level, asynchronous API for keyring-rs, a cross-platform Rust library to manage credentials
-
gprs
A set of filtered and optimized Rust libraries creates a foundation for building modern web frameworks
-
shadocal
A blazingly fast, Google calendar (more in future) event formatter webserver tool
-
sn_sdkg
Safe Network Synchronous Distributed Key Generation: enables dealerless section key generation
-
dynosaur
Dynamic dispatch for return position impl traits and async in Rust
-
whirlwind
Collection of thread-safe, asynchronous data structures
-
tokio-io-timeout
Tokio wrappers which apply timeouts to IO operations
-
effectum
An embeddable task queue based on SQLite
-
ractor_actors
actors built with Ractor
-
miow
A zero overhead I/O library for Windows, focusing on IOCP and async I/O abstractions
-
async-change-tracker
reactive change notifications using futures
-
aggligator
Aggregates multiple links (TCP or similar) into one connection having their combined bandwidth and provides resiliency against failure of individual links
-
distributed-scheduler
A distributed cronjob library
-
quick-protobuf-codec
Asynchronous de-/encoding of Protobuf structs using asynchronous-codec, unsigned-varint and quick-protobuf
-
ntex-grpc
GRPC Client/Server framework
-
sacs
Async Cron Scheduler for Tokio
-
futures-scopes
Runtime agnostic, nestable, scopes for spawning non-static futures
-
some_executor
A trait for libraries that abstract over any executor
-
synchronized-writer
A tiny implement for synchronously writing data
-
resident-utils
Resident program library
-
certsd
automated, asynchronous LE certificate issuer
-
asteroid-mq
An embeddable message queue system
-
decoyssh
A compact and portable SSH tarpit server
-
apalis-sql
SQL Storage for apalis. Use sqlite, postgres and mysql for background job processing
-
mio_wasi
Lightweight non-blocking IO
-
scoped-stream-sink
Easy way to make streams and sinks
-
async_executors
Implements Spawn, SpawnLocal and SpawnHandle for commonly used executors
-
stopper
an async stream and future stopper mechanism
-
unkey
An asynchronous Rust SDK for the Unkey API
-
tokio-retry2
Extensible, asynchronous retry behaviours for futures/tokio
-
nebkor-maelstrom
synchronous client for creating Maelstrom distributed clients
-
tower-batch-control
Tower middleware for batch request processing
-
hedwig
message bus for Rust
-
madsim-rdkafka
The rdkafka simulator on madsim
-
z_osmf
z/OSMF Client
-
aj
Background Job based on Actix
-
pgp-lib
High-level, asynchronous API for rPGP, a pure Rust implementation of OpenPGP
-
rdkafka-sys
Native bindings to the librdkafka library
-
async_cell
A Cell<Option<T>> that you can await on
-
next-gen
Safe generators on stable Rust
-
cassette
single-future, non-blocking executor intended for building state machines
-
splaycast
Stream-specific broadcast channel
-
async-event-emitter
Lightweight AsyncEventEmitter
-
async-shared-timeout
Async timeout that can be reset and shared
-
s3tui
TUI application for multiple s3 account operations
-
mikrotik-rs
Asynchronous Rust library for interfacing with MikroTik routers
-
monoio-codec
Codec for Monoio
-
mqi
Idiomatic IBM® MQ Interface (MQI) and MQ Administration Interface (MQAI) APIs
-
fundamentum-edge-daemon
The supported way to access Fundamentum's ecosystem from linux devices
-
ads_client
An asynchronous, non-blocking ADS client
-
coc-rs
wrapper around the Clash of Clans public API
-
flatline
ssh-2.0 client library
-
zookeeper-async
An async ZooKeeper client
-
delouse
will expose opinionated debugging stubs most useful for tokio based async programs
-
pin-utils
pinning
-
pinky-swear
Futures and async/await-ready Promises
-
minior
Ergonomic Minio Client
-
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…
-
eventuals
Eventually consistent values
-
tcpclient
Asynchronous tcpclient based on aqueue actor
-
embedded-runtime
A tiny async runtime for embedded devices
-
lighthouse-client
Client SDK for Project Lighthouse
-
orsomafo
Event dispatcher crate
-
mulligan
A flexible retry library for Rust async operations with configurable backoff strategies and jitter
-
actix-mqtt-client
A MQTT client based on the actix framework
-
tokio-io-rewind
rewind tokio::io::AsyncRead and tokio::io::AsyncWrite streams
-
my-awesome-rabbitmq-lib
working with RabbitMQ and asynchronous operations
-
rust-utils
Various utility routines used in the rust programs I have written
-
winctx
A minimal window context for Rust on Windows
-
vesper
A slash-command framework meant to be used with twilight
-
stressed
Universal CLI stress tester for competitive programming
-
swiftide-integrations
Blazing fast, streaming pipeline library for AI applications
-
async-scgi
Async SCGI Client & Server
-
infect
Intent/effect/task - A variation on the Model View Intent (MVI) and State Action Model (SAM) paradigms
-
async-stomp
Unofficial successor to Asynchronous streaming STOMP client
-
futures-retry
Retry your Futures and Streams!
-
taskline
distributed task queue for Rust
-
vmcircbuffer
Double Mapped Circular Buffer
-
rocketmq-filter
Unofficial Rust implementation of Apache RocketMQ
-
dptree
An asynchronous event dispatch mechanism for Rust
-
tower-sessions-redis-store
Redis session store for
tower-sessions -
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
-
async-io-mini
Async I/O fork for embedded systems
-
mapped_futures
A collection of futures based on FuturesUnordered that supports insertion, removal and mutation of futures by key
-
railsgun
Excessive tooling for Result handling - If you want rails you got RAILS!
-
pistones
An wrapper for the Piston code execution engine
-
rio
GPL-3.0 nice bindings for io_uring. MIT/Apache-2.0 license is available for spacejam's github sponsors.
-
pubnub
SDK for Rust
-
redis-work-queue
A work queue, on top of a redis database, with implementations in Python, Rust, Go, Node.js (TypeScript) and Dotnet (C#)
-
tokio_kcp
A kcp implementation for tokio
-
wait
Syntactic sugar for calling async functions outside of an async context
-
async_io_stream
IntoAsyncRead on steriods
-
rseip
Ethernet/IP (CIP) client in pure Rust
-
rusturn
TURN server and client
-
tokio-hrtime
Hires timers for tokio
-
crossmist
Efficient and seamless cross-process communication, both synchronously and asynchronously
-
translators
Free Google Translator without API key and limits
-
senders_receivers
Senders/Receivers implementation for Rust
-
tools_interface
Abstractions of serveral Wikipedia/Wikimedia/Wikidata-related tools
-
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)…
-
gasket
Staged Event-Driven Architecture (SEDA) framework
-
rust-paper
Rust Wallpaper manager from ( https://wallhaven.cc/ ) for Linux/UNIX only
-
cache_loader_async
A thread safe loading cache with async loader functions based on tokio
-
vkapi2
vk api wrapper for rust
-
tls-api
TLS API without implementation
-
hydra-websockets
A websocket server for the hydra framework
-
nominatim
Bindings to the reverse geocoding API powered by openstreetmap
-
native_messaging
Async implementation of MDN native messaging. Provides the ability to install host manifest.
-
napi_ext
Extends napi-rs with the ability to run local futures
-
okstd
The standard library that's ok
-
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.)
-
pptr
Type-Driven Asynchronous Actor Runtime
-
tipsy
Cross-platform IPC for Tokio
-
process-lib
Cross-platform, asynchronous Rust library to run commands in pipelines
-
short_future
Future with shorter lifetime for async closures
-
moro-local
Experimental structured concurrency support for async Rust (similar to trio's nurseries). Works with non-Send futures on stable Rust.
-
async-ffi
FFI-compatible
Futures -
async_zmq
Async version for ZeroMQ bindings
-
borrow_mutex
Async Rust Mutex which does not require wrapping the target structure
-
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.
-
kapacitor-udf
creating Kapacitor User Defined Functions (UDFs)
-
retry-if
A tokio-compatible attribute-macro for decorating methods and functions with an exponential backoff
-
fil_actors_runtime
System actors for the Filecoin protocol
-
woddle
An async, synchronized, database-backed Rust job scheduler
-
coasys_juniper
GraphQL server library
-
kafka-threadpool
An async rust threadpool for publishing messages to kafka using SSL (mTLS) or PLAINTEXT protocols
-
pi_rt_file
async file 的封装，添加了多线程竞争排序。
-
noosphere-collections
Collection data types that are needed by an efficient implementation of Noosphere's IPLD data structures
-
futures-executor
Executors for asynchronous tasks based on the futures-rs library
-
async-codec
creating async codecs
-
simple-git
git interface for gix suitable for async context (with tokio)
-
mal-api
An asynchronous MyAnimeList (MAL) API library for Rust
-
uactor
The fastest and most modular actor system that doesn't force you to pay for what you don't need
-
pierport
Urbit pier import protocol implementation
-
peace_rt
Runtime logic for the peace automation library
-
graceful-shutdown
Graceful Shutdown for async code
-
rustygram
minimal and blazing fast telegram notification framework for Rust
-
futures-signals-ext
Extension to futures-signals: MutableOption with combinators, spawning, predicate driven selections from SignalVec
-
ipc-rpc
A wrapper over servo/ipc-channel which provides many high level features
-
tower-memlim
Tower based middleware layer to limit requests based on the host's computer memory usage
-
elfo
Your next actor system
-
php-tokio
Use any async Rust library from PHP!
-
pasts
Minimal and simpler alternative to the futures crate
-
pgboss
job queueing service
-
kuska-handshake
Secure Scuttlebutt handshake + boxstream library
-
axum-limit
A rate limiting library using token buckets, centered around extractor-based limits for async web applications
-
actix-multipart-rfc7578
multipart/form-data (RFC7578) for Actix
-
eventbuzz
A safe, fast, concurrent event publish/subscribe system based on tokio(async), inspired by Spring events
-
hyperbee
Peer to Peer B-tree
-
girlboss
async job manager with progress tracking
-
tokio-rayon
Mix async code with CPU-heavy thread pools using Tokio + Rayon
-
bb8_surrealdb2
Surrealdb support for the async bb8 connection pool
-
agnostic
users who want to write async runtime-agnostic crate
-
interthread
Auto implementation of the Actor Model
-
signal-hook-tokio
Tokio support for signal-hook
-
send-future
Ergonomic and performant fix for https://github.com/rust-lang/rust/issues/96865
-
rust-multipart-rfc7578_2
multipart/form-data (RFC7578)
-
rasi-mio
a rasi drivers implementation base on mio
-
proptest_async
proptest macro supporting async tests
-
persway
Sway IPC daemon
-
apocalypse
actor framework for Rust
-
meltdown
A lightweight service manager to help with graceful shutdown of asynchronous applications
-
stackfuture
wrapper around futures that stores the wrapped future in space provided by the caller
-
termusix
A terminal-based music player with a user-friendly terminal UI, built with Rust
-
wired_handler
Wired's handler library
-
future-queue
Adapters to manage a queue of futures, where each future can have a different weight
-
asynk
Multithread asynchronous runtime and reactor
-
discro
DISCRete Observables for asynchronous Functional Reactive Programming (FRP)
-
remi
🐻❄️🧶 Asynchronous Rust crate to handle communication between applications and object storage providers
-
gem-rs
that serves as a wrapper around the Gemini API, providing support for streaming
-
rustix-uring
The low-level
io_uringuserspace interface for Rust -
xan-actor
Akka actor
-
patharg
Treat "-" (hyphen/dash) arguments as stdin/stdout
-
deferred-future
模仿 jQuery.Deferred()，允许从 Future 实现类实例的外部对正在 pending 的 Future 对象进行 resolve 或 reject 处理。
-
bisync
write async-generic code
-
tokio-muxt
Timer for a limited set of events that multiplexes over a single tokio Sleep instance
-
async-fs
Async filesystem primitives
-
containerd-shim-protos
TTRPC bindings for containerd shim interfaces
-
passivized_vault_client
Vault Client - initialize and monitor Hashicorp Vault nodes
-
ultra-batch
Tokio-based library to batch and cache database queries or other data lookups
-
act_rs
Act.rs is an actor library built to be used with the standard library and Tokio
-
screeps-async
Tick-aware Async runtime for Screeps
-
named-retry
retrying fallible asynchronous operations
-
tower-sessions-rusqlite-store
(tokio-)rusqlite session store for
tower-sessions -
waterark
Watermark for implementing optimistic SSI (Serializable Snapshot Isolation) transactions
-
async_counter
Counter that implements a future to await on specific value
-
batch-channel
async channel that reduces overhead by reading and writing many values at once
-
cancellation-token
C#'s CancellationToken API
-
async-defer
Asynchronous Deferred Calls
-
constellation-rs
Constellation is a framework for Rust (nightly) that aides in the writing, debugging and deployment of distributed programs
-
linemux
providing asynchronous, multiplexed tailing for (namely log) files
-
fundamentum-sdk-mqtt
MQTT client targeting Fundamentum IoT's MQTT broker
-
async-executor
Async executor
-
cassandra-protocol
Cassandra protocol implementation
-
tokio-send-fd
A wrapper for tokio::net::UnixStream to send file descriptors
-
async-tls
Asynchronous TLS/SSL streams using Rustls
-
stream-wave-parser
The
stream-wave-parseris a crate that treats a stream from WAVE file -
ordered-stream
Streams that are ordered relative to external events
-
futures-finally
that executes a future after the completion of a future or stream regardless of the value or outcome
-
scylla-rs
An async ScyllaDB driver built on an actor-model framework
-
tokio-i3ipc
Bindings for i3 and tokio allowing async applications to communicate with i3 over it's IPC interface. Contains futures implementations and convenience functions for working with i3.
-
mio-pidfd
mio support for Linux's pidfd
-
xtra
A tiny actor framework
-
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) -
read_until_slice
AsyncBufRead::read_until extension to take a slice as a delimiter instead of a single u8
-
tokio-tower
Bridging the protocol gap between Tokio and Tower
-
streamunordered
An efficient async stream multiplexer
-
socksv5
SOCKS v4a and v5 basic building blocks to build your own async SOCKS application
-
kafka-rs
Native Rust Kafka client, built upon kafka-protocol-rs and Tokio
-
serial-thread
Asynchronous, multithreaded serial port communication library using mpsc::cjhannels or async-channels for efficient data handling
-
ctf-pwn
Pwn utilities for Rust
-
hakuban
Data-object sharing library
-
crossword_generator
generating crossword from provided words
-
async-tensorrt
Async TensorRT for Rust
-
async-select
select!multiplex asynchronous futures simultaneously -
async-task
Task abstraction for building executors
-
cbsk_socket_tokio
socket callback tool by tokio
-
smol-potat
Proc macro for smol runtime
-
singleflight-async
Singleflight in async style
-
async_async_io
AsyncRead,AsyncWritetraits but withasync fnmethods -
haalka_futures_signals_ext
vendored version of MoonZoon's futures_signals_ext, as it is yet to be released as a crate
-
async-transmit
Trait for transmitting data to peers asynchronously
-
bus_queue
Lock-free Bounded non-Blocking Pub-Sub Queue
-
knien
Typed RabbitMQ interfacing for async Rust
-
rustygear
Client library for communicating via the gearman protocol
-
ringlog
A fast and lightweight non-blocking logging framework
-
shutdown
can be used to gracefully exit (part of) a running program
-
mosquitto-rs
An async MQTT client based on libmosquitto
-
lsp-async-stub
An LSP server stub for futures
-
futures-boring
SSL streams for Futures built on top of the BoringSSL
-
fb_futures_ext
future crate extensions
-
tokactor
A actor model framework wrapped around tokio
-
elegant-departure
simplify graceful shutdown
-
async-unsync
asynchronous, unsynchronized (thread-local) channels and semaphores
-
debouncer
A simple debouncer for Rust
-
killswitch
used to broadcast a shutdown request
-
async-oneshot-channel
async oneshot channel implementation
-
aws-parameters-and-secrets-lambda
Cache AWS Secrets Manager secrets in your AWS Lambda function
-
wasmcloud-interface-factorial
Interface library for the wasmcloud factorial capability, wasmcloud:example:factorial
-
bsky-cli
CLI application for Bluesky using ATrium API
-
tokio_gen_server
Elixir/Erlang-GenServer-like actor on the Tokio runtime
-
monoio-rustls
Asynchronous TLS streams wrapper for Monoio based on Rustls
-
tokio-socketcan
Asynchronous Linux SocketCAN sockets with tokio
-
thread-waker
Waker implementation using current thread token
-
futures-map
Futures-based and hashmap-based alogrithms
-
async-rdma
async wrapper for RDMA ibvers lib
-
rocketmq-client-v4
rocket mq rust client for remote protocol. works on rocket mq V4
-
jni-utils
Extra Utilities for JNI in Rust
-
ianaio-worker
Convenience crate for working with Web Workers
-
tokio-stomp-rs
Asynchronous streaming STOMP client fork
-
ticks
ergonomic Rust wrapper for the TickTick Open API
-
supply-chain-trust-example-crate-000054
Lightweight non-blocking I/O
-
async-compatibility-layer
an abstraction layer for using both async-std and tokio
-
async-utf8-decoder
Convert AsyncRead to incremental UTF8 string stream
-
monoio-compat
A compat wrapper for monoio
-
hooch
A small async runtime that's been bootlegged for my projects
-
state_machine_future
Easily create type-safe
Futures from state machines — without the boilerplate -
tokio-util
Additional utilities for working with Tokio
-
wiremock_logical_matchers
Logical matchers for use with wiremock
-
ractor_cluster
Distributed cluster environment of Ractor actors
-
mpi-sys
Message Passing Interface bindings for Rust
-
nolocal-block-on
futures_lite::future::block_on that can run without using thread-locals
-
pi_async
Based on future (MVP), a universal asynchronous runtime and tool used to provide a foundation for the outside world
-
secret-lib
Cross-platform, asynchronous Rust library to retrieve secrets from different sources
-
handle
Trait for asynchronous context pipeline
-
sodium
FRP (Functional Reactive Programming)
-
zeroconf-tokio
Tokio-based wrapper around the zeroconf crate, which provides mDNS service discovery and registration capabilities
-
catalyzer
HTTP server framework
-
cortex-sources
Ready-made source implementations for various data inputs in the Cortex ecosystem
-
background-jobs-sled
Sled storage backend for background-jobs
-
discern
implementing the Command Query Responsibility Segregation (CQRS) pattern
-
asynclog
asynchronous log library
-
par-stream
Asynchronous parallel streams analogous to rayon
-
libuv-sys-lite
Tiny, raw bindings to libuv without linking to it
-
ticque
Take a queue for a resource
-
gcp_access_token
pure rust implimentation to get google cloud access token for servers with service account credentials
-
libublk
building linux block device in userspace
-
eyeball-im
Observable collections based on the
imcrate -
async-observable
Async & reactive synchronization model to keep multiple async tasks / threads partially synchronized
-
conva_ai
Rust SDK for using CONVA AI Copilots
-
aa-sms
Send messages from with Andrews & Arnold’s SMS API
-
tigerbeetle-unofficial
Safe high level async bindings to tigerbeetle client library
-
replay-channel
A broadcast channel where new receivers replay all past messages before receiving new ones
-
tower-sessions-libsql-store
A small library for using tower-sessions with libsql
-
livekit-runtime
Async runtime compatibility layer for LiveKit
-
async-rate-limiter
Implements a token bucket algorithm that can be used to limit API access frequency. Written in pure Rust.
-
sparkle-convenience
A wrapper over Twilight designed to make it more convenient to use
-
hass-rs
An async websocket client for Home Assistant
-
dwn
Decentralized Web Node
-
spin_on
inefficient Future executor
-
akinator-rs
wrapper around the undocumented Akinator API
-
turmoil
Simulation testing framework for distributed systems
-
git-next-server-actor
Server actor for git-next, the trunk-based development manager
-
stream-reconnect
Stream-wrapping traits/structs that automatically recover from potential disconnections/interruptions
-
minos
Authorization library
-
tokio_delayed_queue
Asynchronous delayed queue for Tokio runtime
-
pausable_future
Pausable and resumable future, useful in background tasks
-
ng-repo
Repository library of NextGraph, a decentralized, secure and local-first web 3.0 ecosystem based on Semantic Web and CRDTs
-
lending-stream
A lending version of Stream
-
pwner
Process Owner crate that allows ergonomic access to child processes
-
pegy
A derive based parser generator
-
monoio-thrift
Thrift for Monoio
-
piscina
generic pool that supports both sync and async
-
openraft-memstore
A in-memory implementation of the
openraft::RaftStoragetrait -
upstox-rust-sdk
SDK to access Upstox's Uplink v2 APIs programmatically
-
swiftide-indexing
Blazing fast, streaming pipeline library for AI applications
-
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.
-
tokio-nats
Async-await ready NATS library
-
asynk-strim
Lightweight stream generator library
-
mlua-luau-scheduler
Luau-based async scheduler, using mlua and async-executor
-
aranya-policy-ifgen
Tools for generating Rust interfaces to Aranya Policies
-
cyberex
Utilities Library
-
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.
-
alicemq
Wapper for the amqprs rabbitMQ library
-
lichess-api
client for Lichess API v2.0.0
-
fama
Pipeline Manager
-
polly-scheduler
A robust task scheduling system leveraging Tokio, with built-in fault tolerance, persistence, and recovery capabilities to ensure seamless task management and execution
-
readwrite
Combine Read and Write into a single Read+Write object
-
moeval
a toy interpreter
-
ksoft
KSoft.SI api wrapper written in pure Rust
-
taski
async task DAG execution
-
webex
Interface to Webex Teams REST and WebSocket APIs
-
spawns
Async runtime agnostic thread context task spawner for Rust
-
lookit
Asynchronously connect to devices
-
tub
Async Pool
-
async-rate-limit
Common traits for rate limiting and implementations in async contexts
-
islabtech-upw-sensor-v1
Rust client library for remote control of the ISLabTech UPW Sensor v1
-
truba
The minimal tokio runtime based actors for Rust
-
isoprenoid
signals runtime framework backing flourish
-
stdout-channel
Write stdout to an async queue
-
async-waitgroup
Golang like WaitGroup implementation that supports both sync and async Rust
-
futures-ticker
An asynchronous recurring time event
-
tokio-lxi
LXI protocol abstractions for Tokio
-
eventastic_postgres
An example postgres event store for eventastic
-
boomerang_builder
The Reactor assembly API for Boomerang
-
ply_jobs
ability to run background jobs on a schedule
-
felicia
service for accessing and sharing lists of bad actors
-
twilight-standby
filter wait for filtered incoming events for the Twilight ecosystem
-
zephyrus
A slash-command framework meant to be used with twilight
-
sonor
controlling sonos speakers
-
l337
connection pooler
-
tbot
Make cool Telegram bots with Rust easily
-
event_iterator
Asynchronous lending iterator
-
tokio-file
Asynchronous file I/O for Tokio
-
slim-futures
Asynchronous tools that intends for smaller binary size
-
pollable-map
Utilites for storing futures and streams in as a pollable map
-
busstop
A command and query bus
-
napmap
Async HashMap that halts requester tasks until the requested data is accessible
-
tokio-shared
Share tokio Runtime bwtween dylibs
-
embedded-io-convert
Convert embedded-io-async types back to futures ones (nightly only)
-
libevent-sys
Rust FFI bindings to the libevent library
-
rspack_futures
rspack futures
-
rmp-futures
Async Rust MessagePack and MessagePack-RPC
-
kioto-serial
Provide serial port I/O using tokio
-
sn_consensus
Safe Network Membership: Enables nodes to dynamically join and leave a section
-
retrier
A wasm-compatible retry library for futures
-
async-injector
Reactive dependency injection for Rust
-
io-pipe
A fast and thread-safe library for creating multi-writer and single-reader pipelines in Rust
-
kumoko
asynchronous server/client crate built on tokio for easy two-way streaming
-
parquet-format-async-temp
Temporary crate containing thrift library + parquet definitions compiled to support read+write async
-
lua_actor
Lua Actor for Rust(sync/async)
-
swimos_future
SwimOS Future Utilities
-
prometheus-utils
built on top of the prometheus crate
-
baildon
B+Tree library
-
rspl
A stream processor language
-
multi-readers
Combining multiple readers
-
futures-delay-queue
Async delay queue backed by async-std and futures-timer
-
disintegrate
build event-sourced applications
-
tokio-serde-cbor
Integration of serde_cbor into tokio-io, to allow sending CBOR encoded frames across network (and possibly through other transports)
-
fctools
An exhaustive, highly modular and extensible host SDK for the Firecracker microVM manager
-
situwaition
Run a closure continuously, until is succeeds or times out
-
ruchei
working with many streams
-
ianaio-dialogs
Convenience crate for working with dialogs in browser
-
stund
An SSH tunnel maintenance daemon
-
async_zip_futures
An asynchronous ZIP archive reading/writing crate using futures-rs
-
test_executors
async executors for testing
-
capp
Common things i use to build Rust CLI tools for web crawlers
-
async-global-executor
A global executor built on top of async-executor and async-io
-
async-blocking-stdio
std::io::std{in(), out(), err()} but async
-
moxie
Incremental runtime for interactive software
-
async-fuse
Helpers for fusing asynchronous computations
-
yield-now
Wakes current task and returns Poll::Pending once
-
tor-log-ratelim
Facility for rate-limiting log messages in Arti
-
futures-yamux
The yamux protocol implementation, rewritten from the ground up
-
hollywood
actor framework
-
iroh-io
async local io
-
taskalicious
Common Rust task workers
-
cbsk_run
async pool tool
-
rendezvous
Easier rendezvous channels for thread synchronization
-
proxy-scraper
command-line tool for scraping proxy information
-
space-traders
Async SpaceTraders API client for Rust
-
flurx
Create reactive asynchronous data flow
-
aiven_rs
sdk to interact with aiven-cloud apis
-
hala-io
hala asynchronous io programming primitive types
-
diazene
Actor for Rust (with Tokio)
-
goods
Async assets system
-
scipio
A set of utilities to allow one to write thread per core applications
-
async_tasks_recorder
A struct for recording execution status of async tasks with async methods
-
kioto-uring-executor
multi-threaded wrapper around tokio-uring
-
oneshot-handshake
providing a symmetric one time use channel type
-
rx_rust_mp
A protoype implementation of the ReactiveX API in Rust using a message passing approach
-
ref_count
Efficient, low-level asynchronous synchronization for real-time and embedded systems
-
agnostik
Executor Agnostic Runtime that can run your futures with your favourite Executor
-
rust-concurrent
Fast command line app in rust/tokio to run commands in parallel. Similar interface to GNU parallel or xargs.
-
reactor-trait
A collection of traits to define a common interface across reactors
-
miau
Async aware and extensible layered configuration system
-
maelstrom-util
by non-WASM Maelstrom libraries and binaries
-
async-wormhole
Async calls across non-async functions
-
selectme
A fast and fair select! macro for asynchronous Rust
-
peace-performance
osu! pp & stars calculation. Peace edition
-
corcovado
Non-blocking IO library
-
stop-token
Experimental cooperative cancellation for async Rust
-
actix-daemon-utils
Daemon Utilities by actix
-
xjbutil
A xjbly created utility library for my own use
-
adventure
your great adventure for the various type of requests
-
maily
easy, quick, and fault tolerant sending of emails
-
fil_builtin_actors_builder
WASM builder for builtin Filecoin actors
-
stakker_mio
Mio I/O polling integration for the Stakker crate
-
shutdown-handler
A shutdown handler that allows all parts of an application to trigger a shutdown
-
cb_fut
Call function that return value via callback without a callback
-
hypixel_api
Generic wrapper around the hypixel api (automatic rate-limiting on client-side)
-
any-mpsc
An mpsc that allows arbitrary types to be passed through
-
pcap-async
Async/Stream Extensions for libpcap
-
clia-rcproxy
A lightweight, fast and powerful Redis Cluster Proxy written in Rust
-
acu
building asynchronous actors
-
textmode
terminal interaction library backed by a real terminal parser
-
smoltimeout
A way to poll a future until it or a timer completes
-
awak
A small async runtime for Rust
-
foreback
Future adapters for running aditional work in the background
-
woven
set of async combinators, usable in a no_std environment
-
roux-stream
A streaming API for the roux Reddit client
-
metatrait
RPITIT Monads
-
tiny_kafka
A tiny Kafka client library with producer and consumer functionalities
-
webhttp
-
tokio_based
BASED Async Single-threaded Execution Dispatcher
-
extreme
Extremely boring async function runner. MIT/Apache-2.0 license is available for spacejam's github sponsors.
-
dialectic
Transport-polymorphic, asynchronous session types for Rust
-
orengine
Optimized ring engine for Rust. It is a lighter and faster asynchronous library than tokio-rs, async-std, may, and even smol
-
overclock
A framework for building data-driven distributed systems
-
zookeeper-cache
ZooKeeper client cache
-
slings
A small async runtime based on io-uring for Rust
-
wrtc
Wrapper around webrtc-rs library, focused on developer experience
-
curseforge
A straightforward asynchronous wrapper around the CurseForge Core API. Public API is subject to change before 1.0.0.
-
heph
actor framework based on asynchronous functions
-
pingora-timeout
Highly efficient async timer and timeout system for Tokio runtimes
-
negahban
🧐 A simple file watcher, based on
notify, designed to be fast, easy-to-use and async friendly -
txn
A generic optimistic transaction manger, which is ACID, concurrent with SSI (Serializable Snapshot Isolation)
-
futures-ratelimit
Bounded flavors of futures' FuturesUnordered and FuturesOrdered
-
carboxyl
functional reactive programming
-
verge
An experimental actor library
-
mio-wakeq
mio support for custom event queue via Waker
-
mini-c-ares-resolver
An asynchronous DNS resolver, backed by mini-c-ares
-
async_logger
Asyncronous logger allows writing arbitrary slices to a memory buffer, which then processed by a writer in it's own thread
-
luis_sys
FFI bindings for Microsoft LUIS API
-
passivized_docker_engine_client
Docker Engine Client - manage and run containers, images, and volumes
-
danube-client
The async client for Danube Pub/Sub messsaging platform
-
futures-async-stream
Async stream for Rust and the futures crate
-
event-source
Zero cost async immediate event dispatching
-
tierkreis-runtime
Runtime implementation for the tierkreis quantum-classical hybrid workflow orchestration tool
-
tokio-zmq
Futures abstractions for ZeroMQ on the Tokio event-loop
-
ksqldb
A thin wrapper around the KSQL DB REST API to make it more ergonomic to work with
-
fure
Retrying futures using different policies
-
future-local-storage
An init-once-per-future cell for thread-local values
-
night
A scalable Task Queue for executing asynchronous tasks in topological order
-
async-sleep
Async Sleep
-
act-zero
Ergonomic actor system
-
nsq-client
Rust client for the NSQ realtime message processing system
-
starbase_events
Async and mutable event system
-
futures_ringbuf
Mock Type implementing AsyncRead/AsyncWrite for testing and examples
-
sc2
StarCraft II Client API
-
packet-ipc
Share packets between services using servo ipc
-
telegram-bot-ars
creating Telegram bots
-
lapin-tower-worker
Framework for building AMQP workers with lapin and tower
-
task-motel
Opinionated (Tokio) task manager with nested task groups and stoppable tasks
-
didcomm-rs
DIDComm messaging v2 specifications implementation: https://identity.foundation/didcomm-messaging/spec/
-
terminusdm
Terminus Download Manager. Download files, resume interrupted downloads, and keep a history of your downloads - within terminal UI.
-
thin_main_loop
Thin, cross-platform, main event loop. A building block for native GUI applications, among other use cases.
-
backie
Background task processing for Rust applications with Tokio, Diesel, and PostgreSQL
-
cbsk_socket_rayon
socket callback tool by rayon
-
cannyls_rpc
RPC library for operating cannyls's devices from remote nodes
-
pirates
async RPC lib
-
async-gen
Async generator in stable rust using async/await
-
libmqm-sys
IBM® MQ Interface (MQI) and MQ Administration Interface (MQAI) bindings
-
zeebest
An unofficial zeebe client for the future!
-
tk-listen
A set of helper futures allowing to listen TCP (or unix) socket with resource limits and proper error handling
-
rocketmq-runtime
Unofficial Rust implementation of Apache RocketMQ
-
madsim-real-tokio
An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications
-
rusty_ao
A blazingly fast client for AO written in Rust
-
async-native-tls-2
Native TLS using futures
-
futures-io
The
AsyncRead,AsyncWrite,AsyncSeek, andAsyncBufReadtraits for the futures-rs library -
queen
message queue
-
stun-client
async_std based asynchronous STUN client library
-
merge-streams
Merge multiple streams into one
-
compio-driver
Low-level driver for compio
-
tactix
Actor Model based on Tokio
-
mamenoki
Complete implementation of a Beanstalkd client based on the Tokio runtime
-
abstract-ns
Abstract name service traits for use with futures (and tokio)
-
circulate
Lightweight PubSub framework that supports both sync and async
-
dioxus-v04-optional-hooks
Optional futures for Dioxus 0.4.0-0.4.3
-
reusable-box-future
A reusable
Pin<Box<dyn Future<Output = T> + Send>> -
deadqueue
Dead simple async queue
-
xilinx-dma
Userspace Xilinx AXI DMA Interface
-
arangoq
An AQL query builder layer and ArangoDb client for rust
-
tokio-uring
io-uring support for the Tokio asynchronous runtime
-
futures-test
Common utilities for testing components built off futures-rs
-
lutetium
tokio based simple actor library
-
rabbit_borough
Create a RabbitMQ consumer project with minimal effort, by bypassing templating, configuration and complicated resiliency logic
-
gcal_rs
A blazingly fast, hand written Google calendar API in Rust
-
swimos_messages
SwimOS Runtime Internal Messaging Protocol
-
pi_async_buffer
Asynchronous Buffer for IO
-
futuristic
Extensions to the futures crate
-
naumi
Lightweight and fast data transfer protocol. Fast de/serialization and tiny size!
-
async-gcode
An async gcode parser for no_std targets
-
flo-state
Lightweight actor library
-
tourniquet
Async native round-robin manager for remote services
-
miniloop
The simpliest async executor without heap memory allocation
-
tokio-graceful-shutdown-without-anyhow
perform a graceful shutdown on a Tokio based service
-
puff-rs
Puff - Deep Stack Python Runtime and GraphQL library
-
async_msp_cli
Async msp cli for iNav and BetaFlight
-
libaio-futures
Straightforward Linux AIO using Futures/async/await
-
rabbit_mqr
Extremely Simplified RabbitMQ Client
-
bipe
asynchronous I/O pipe
-
makepad-futures-legacy
Makepad futures legacy
-
callbag
spec for reactive/iterable programming
-
async-time-mock-smol
Mockable time for use in async runtimes (smol compatibility)
-
async-oncecell
Asynchronous versions of OnceCell and Lazy
-
safina-timer
Safe async timers - ARCHIVED: Code moved to
safinacrate -
msq
legacy Master Server Query Protocol
-
lazy_async_pool
An asyncronous object pool that generates objects on the fly
-
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) -
stream-broadcast
Runtime independent broadcast, which only polls it's underlying stream if no pending data is available
-
hybrid-logical-clock
Hybrid Logical Clocks for distributed systems
-
napi_async_local
Extends napi-rs with the ability to run local futures
-
tokio-sync2async
Helpers to bridge between sync and async code
-
callback-result
Assists in converting the callback function's method of obtaining results into the await method
-
async-lazy
A value which is initialized on the first access, with an async function
-
smol
A small and fast async runtime
-
popol
Minimal non-blocking I/O
-
murray
A minimal actor definition macro using Tokio
-
deluge
A highly concurrent stream library driving the underlying futures either concurrently or in parallel to process streaming operations as quickly as possible
-
viaduct
A duplex communication channel between a parent and child process, using unnamed pipes
-
parallel-future
fluent async task experiments
-
futures-stream-ext
Asynchronous stream extensions for the futures(-core) crate
-
metalmq
server
-
msft-runtime
Windows async helpers
-
saas-zmq
ZeroMQ tools by using Publish-Federation
-
timeware
timer used to schedule execution of closures at a given timestamp
-
io_tee
Tee Read, BufRead, and Seek instances to a writer
-
emitter_runtime
Runtime support for rs-event-emitter
-
cntrlr
async embedded framework
-
awaitable
type with input and output that can be stored in container
-
handoff
An unbuffered, asynchronous, single-producer/single-consumer channel
-
stream_router
A Future aware router to dynamically route between Streams and Sinks
-
ruchei-route
Sinks with routes
-
tobytcp
A little library for sending messages over a tcp stream
-
tiny_future
Condvarbased future with automatic cancellation on drop -
async-nats-tokio-rustls-deps
Fork of Asynchronous TLS/SSL streams for Tokio using Rustls
-
peace_resources
Runtime resources for the peace automation framework
-
tarpc-trace
foundations for tracing in tarpc
-
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
-
fundamentum-sdk-api
HTTP client targeting Fundamentum IoT devices RestAPI
-
kompact
Kompics component model combined with the Actor model
-
actix-rt
Tokio-based single-threaded async runtime for the Actix ecosystem
-
fork_stream
Clone any stream
Swhere<S as Stream>::Item: Clone -
rants
An async NATS client library
-
tokio-easy-timer
A tokio-based task scheduler, with a user-friendly API
-
async-sse
Async Server Sent Event parser and encoder
-
async_shared
signal implementation
-
tenorite
A concurrency abstraction library. Provides a client-server model for asynchronous workers
-
tokio-bitstream-io
Tokio port of bitstream-io: Library for reading/writing un-aligned values from/to streams in big-endian and little-endian formats
-
async-minecraft-ping
An async Rust client for the Minecraft ServerListPing protocol
-
tokio-async-drop
macro to enable async drop in a tokio multithreaded runtime
-
pw-telegram-bot-fork
creating Telegram bots
-
actix-signal
Manage the lifecycle of an actix actor with its address
-
visiting_ref
Container types that asynchronously return ownership of a value to another context upon exiting scope
-
stream-ext
An extension trait for Streams that provides a variety of convenient combinator functions
-
radix-router
Rust port of httprouter
-
rumqttlog
kafka inspired rumqtt's mqtt commitlog
-
parity-runtime
Tokio runtime wrapper
-
mqtt_actor
An mqtt adapters (from port and adapters) to be used with actix actors
-
actix-interop
Use async/await syntax with actix actors
-
futures_cbor_codec
A codec for framing an AsyncRead/AsyncWrite with cbor for all types that are serializable with serde
-
read-progress-stream
Stream reader wrapper that tracks the number of bytes read
-
prevayler-rs
System prevalence in rust
-
async-xml
deserializing XML data asynchronously
-
atticus
A mimimal API to create asynchronous actors
-
terminal-wait-exit
wait user exit terminal, like Ctrl+C
-
async-recorder
Store records without waiting for your persistence backend
-
futures-core
The core traits and types in for the
futureslibrary -
hls_lfcd_lds_driver
Rust driver for ROBOTIS HLDS HLS-LFCD-LDS (LDS-01)
-
automerge_repo
automerge-repo
-
waitgroup
Async waitgroup for a collection of task to finish
-
maelstrom-node
Maelstrom Rust node framework
-
sigio
signal-based async io
-
zellij-utils
Zellij client and server
-
plumbing
An async abstraction to pipeline requests through a channel
-
simple_spawn_blocking
spawning blocking tasks more ergonomic
-
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. -
bb8-bolt
A bolt-client adaptor for the bb8 connection pool
-
mediator
pattern in Rust
-
nextgraph
client library. Nextgraph is a decentralized, secure and local-first web 3.0 ecosystem based on Semantic Web and CRDTs
-
rt-local
Thread local asynchronous runtime working with platform-specific event loops
-
lifeline
dependency injection library for asynchronous message-based applications
-
async-ctrlc
Async wrapper of
ctrlc -
async_object
Async Object wrapper
-
swarm-commander
Manage tons of commands asynchronously
-
untokio
Automatically create tokio runtimes
-
openai-api
OpenAI API library for rust
-
async_singleflight
Async singleflight
-
pochta
Addressable channel registry
-
tokio-socks
Asynchronous SOCKS proxy support for Rust
-
prost-codec
Asynchronous de-/encoding of Protobuf structs using asynchronous-codec, unsigned-varint and prost
-
simple-scheduler
Schedule periodic tasks to run asynchronously
-
puteketeke
An asynchronous runtime built on smol
-
signalfut
A future similar to tokio::signal::unix::Signal, but can be used with all the runtimes
-
dabus
Dynamic Aplication Controll Bus - an asynchronous, event based module system for thoes who want to move fast and *not* break things
-
riker
Easily build fast, highly concurrent and resilient applications. An Actor Framework for Rust.
-
in-keys
utilizing streams in a convenient
Terminalconstruct -
black-box
A minimal actor framework
-
pick_action_from_image
Pick an action from an image
-
async-send-fd
A wrapper for async UnixStream's to send file descriptors
-
blocker
Block rust futures to create a synchronous wrapper around an asynchronous api
-
linked-futures
Link futures into a block, which stops all of the included futures when any of the futures complete
-
eyeball-im-util
eyeball-im -
susync
An util crate to complete futures through a handle. Its main purpose is to bridge async Rust and callback-based APIs.
-
rlua-async
Async support for rlua, via coroutines
-
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 -
mikrotik_api
& minimal client to connect and interact with Mikrotik RouterOS API, usually exposed on port 8728
-
bp3d-threads
threading library intended to simplify concurrency in BP3D
-
selecting
Cross-platform wrapper over select
-
tracing-orchestra
Give me more instruments!
-
stow
Cloud storage abstraction package for Rust
-
spaad
Zero boilerplate actor systems with xtra
-
tokio-lk
Futures-aware lock-by-id primitives
-
stream-guard
RAII wrapper around Stream that invokes a custom action on drop
-
pantry
Temporary storage for reusing values that may decay
-
tokio-shutdown
Wait for a stop signal across multiple threads
-
auto-future
For quickly making a struct into a future via an async fn
-
wasmflow-packet
encapsulating the message packets sent across Wasmflow components
-
continue
Swift-style continuation API
-
monoio-native-tls
Asynchronous TLS streams wrapper for Monoio based on NativeTLS
-
async-mavlink
An async adapter for mavlink conections
-
tokio-libtls
Tokio bindings for LibreSSL's libtls
-
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
-
nyantrack-common
Common data types and functionality for NyanTrack
-
tokio-stream-multiplexor
Stream Multiplexor for tokio with a tcp like interface
-
must_future
A wrapper future marked must_use - mainly to wrap BoxFutures
-
gentian
proc macro that transforms generators to state machines
-
csnmp
Community-based async (Tokio) SNMP client library
-
rusty_tarantool
Tarantul async client based on tokio framework
-
proxycurl-linkedin-rs
client for the Proxycurl LinkedIn API
-
fluke-io-uring-async
An abstraction on top of io-uring
-
csv-async
CSV parsing for async
-
tauri-specta
Completely typesafe Tauri commands
-
tracing-actix
Allow tracing actor futures in actix
-
streammap-ext
StreamMap of Tokio with altered
nextthat returns when stream is dropped -
this-state
way to store state in a thread-safe manner as well as a way to asynchronously wait for state changes
-
async-http1-lite
Asynchronous http1 stream
-
tls-api-2
TLS API without implementation
-
streamline
Reversible futures::Stream-based state machines
-
winmsg-executor
Per-thread async rust executor for windows
-
async-copy-progress
Asynchronous copying with progress callbacks
-
snarc
Sendable Non-Atomically Reference Counted
-
zookeeper-cache-rust
ZooKeeper client cache
-
blec
cross-platform ble client library based on btleplug
-
side-futures
Send future for execution on the runtime that may be in a different thread
-
nonblock
Read available data from file descriptors without blocking (e.g. sockets, streams, child stdout, named pipes)
-
fb_futures_01_ext
Extensions for future 0.1 crate
-
pupactor
actor model library built with tokio
-
compio-fs
Filesystem IO for compio
-
async-notify
A general version async Notify, like
tokioNotify but can work with any async runtime -
async-mq
Zero-cost async-await abstraction of lapin AMQP client crate
-
dyn-timeout
Dynamic timeout, cancel, add and remove time before a callback execution
-
bean_factory
bean factory,support inject reference bean
-
async-log
Async tracing capabilities for the log crate
-
activitystreams-types
Base types from the Activity Streams spec
-
tidy-browser
Tidy up browser information
-
qbit-api-rs
A asynchronous Rust wrapper for qBittorrent Web API
-
streamcatcher
A thread-safe, shared (asynchronous), almost-lockless stream buffer
-
loading-bytes
Load bytes from paths on native and WASM
-
background-jobs-tokio
in-process jobs processor based on Tokio
-
async-graphql-tide
async-graphql for tide
-
glib-signal
GObject signal bindings
-
task-collection
Types for managing and waiting on groups of tasks
-
gritlab
Gitlab rust API sdk
-
pymedusa-zip
A PyOxidizer interface to high-performance parallelized implementations of common zip file operations
-
zusammen
Download files in parallel
-
async-dispatcher
async runtime based on a pluggable dispatcher
-
rumpsteak
Session types for asynchronous communication between multiple parties
-
coachman
rust asynchronous task manager built on top of tokio framework
-
heph-inbox
Bounded capacity channel designed to be used as inbox for actors. Also supports one shot channels.
-
speedracer
racing futures and ranking the results
-
futures_codec
encoding and decoding frames using
async/await -
linkd
actor model framework that takes inspiration from OTP in the erlang ecosystem
-
smolscale
A high-performance async-task scheduler
-
apalis-cron
extensible library for cron-like job scheduling for rust
-
netty-rs
allows exposes a simple-to-use API used to create stateful application level network protocols as both a client or server
-
mpc-bench
Multi-party computation experimentation library
-
wasmer-wit-bindgen-rust
wit-bindgen-gen-c
-
piston_rs
An async wrapper for the Piston code execution engine
-
init_system
Framework to wrap application init
-
test-with-tokio
attribute macro for tests using tokio with cases and async guards
-
rust-rsm
RSM:A Realtime Software Middleware framework. Asynchronous, event driven framework
-
peekable
reader and async reader, which enhance your network programming experience
-
tokio-stomp-rs-rs
Asynchronous streaming STOMP client fork
-
tokio-stdin-stdout
Thread- and future::sync::mpsc-based AsyncRead/AsyncWrite stdin/stdout with little buffering
-
openaction
creating plugins for the OpenAction API
-
aral
Async Runtime Aggregation Layer
-
js-sys-futures
working with the futures and js-sys crates
-
specta
Easily export your Rust types to other languages
-
dstream
DelayedStream - delays items and drops same items coming within given interval
-
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…
-
tokio-switching-sleep
A tokio Sleep with a switchable state
-
rocketmq-store
Unofficial Rust implementation of Apache RocketMQ
-
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.
-
bufstream
Buffered I/O for streams where each read/write half is separately buffered
-
event-listener-strategy
Block or poll on event_listener easily
-
dialectic-compiler
Session type macro compiler for the Dialectic crate
-
paperless-rs
An asynchronous Rust library for the Paperless-ngx document manager
-
taps
taps (Tokio Asynchronous Pub/Sub) is an in-process async message broker that can be used for messaging between spawned tokio tasks
-
dyn-future
Convenient and fast dynamic Futures for Rust
-
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.
-
async-variadic
async variadic functions in Rust with trait bounds
-
evdev-shortcut
Global shortcuts using evdev
-
libsync
containing channels and other synchronisation object implementations
-
heim-cpu
Cross-platform CPU information
-
co_managed
Create managed sub coroutines. Managed sub coroutines will be cancelled when the parent exit
-
rust-moysklad
Framework for moy sklad
-
try-again
Retry synchronous and asynchronous operations
-
mini-c-ares
A minimal Rust wrapper for the c-ares library, for asynchronous DNS requests, based on rust-c-ares
-
bastor
A wrapper helps implementing actor with Bastion more easier with self-implemented state
-
rio_rt
A minimal async runtime with an experimental ambition to be an portable and interoperable async runtime for Rust
-
zstd-framed
zstd seekable format compression and decompression. Supports sync and async I/O
-
xtra-addons
Add-on functionality (Broker, Registry) for crate xtra
-
pakr-fsm
Template to implement finite-state-machines
-
async_progress
Create sync points across async tasks
-
pangotls
TLS Reverse Proxy using Tokio and Rustls
-
futures-net
The futures-net library
-
dagrs
The DAG engine, named dagrs, is designed to execute multiple tasks with graph-like dependencies. It offers high performance and asynchronous execution, providing a convenient programming interface for Rust developers.
-
reception
creating TCP listeners that spawns clients providing model abstraction layer
-
simple-middleware
General purpose middleware crate
-
cs-utils
Common utilities
-
blocking-permit
Permits and a thread pool for blocking operations
-
epicenter
synchronous and asynchronous event dispatcher for Rust
-
async_monad
Asynchronous monad for rust
-
tokio-childstream
Convert a tokio::process::Child into a Stream for stdout, stderr, and exit events
-
teloxide-core
Core part of the
teloxidelibrary - telegram bot API client -
happyeyeballs
Happy Eyeballs implementation in Tokio (not RFC compliant atm)
-
peace_rt_model
Runtime data types for the peace automation framework
-
key-lock
mutual exclusion by keys
-
async-rayon
Mix async code with CPU-heavy thread pools using Futures + Rayon
-
raftlog
distributed replicated log based on the Raft algorithm
-
tokio-process-stream
that wraps a tokio::process into a tokio::stream
-
async-hid
A async library for interacting with HID devices
-
deadpool-lapin
Dead simple async pool for lapin
-
peermerge
Manage JSON-like documents with multiple writers, without a central authority, using a P2P protocol
-
parallel-stream
Data parallelism library for async-std
-
maybe-future
Future that can be None
-
buffer-unordered-weighted
Stream::buffer_unordered where each future can have a different weight
-
openai-api-fork
OpenAI API library for rust
-
tokio-rusqlite
Asynchronous handle for rusqlite library
-
tokio-nsq
NSQ client built on Tokio. Tokio NSQ aims to be a feature complete NSQ client implementation.
-
arti-rpcserver
Backend functionality for Arti's RPC service
-
cancellable
providing a generic cancellable utility
-
elfo-utils
Some utils for the elfo system
-
random-access-storage
Abstract interface to implement random-access instances
-
rasio-mio
a RASIO drivers implementation base on mio
-
contained-actors
contained is a research project implementing the proposed harmonic runtime for orchestrating cloud-native systems
-
swimos_trigger
SwimOS Asynchronous Trigger
-
quick_crawler
QuickCrawler is a Rust crate that provides a completely async, declarative web crawler with domain-specific request rate-limiting built-in
-
zeebe
client for defining, orchestrating, and monitoring business processes across microservices using Zeebe
-
futures-diagnose
Wraps around a Spawn and provides lots of diagnostics
-
pingora-rustls
RusTLS async APIs for Pingora
-
async-anyhow-logger
An easy crate for catching anyhow errors from an asynchronous function, and passing them to your logger
-
io-tubes
functionality like pwntools tube for async io in rust
-
enstream
Conversion from Future to Stream
-
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…
-
deferred
help perform deferred execution of code logic
-
safina-threadpool
Safe thread pool - ARCHIVED: Code moved to
safinacrate -
viz-utils
Viz utils
-
swimos_downlink
SwimOS Downlink Runtime
-
tokio-stomp
Asynchronous streaming STOMP client
-
multiqueue2
A fast mpmc broadcast queue
-
signalr_rs
SignalR client based on actix web client and async await
-
pipestream
Async support for pipe or something has file descriptor
-
fut_rwlock
A read-write lock that is read and written via Futures
-
limitation
A rate limiter using a fixed window counter for arbitrary keys, backed by Redis
-
acril-rt
A lightweight single-threaded runtime for Acril actors
-
io_uring_buf_ring
Help user create and manage io-uring buffer-ring
-
stream-kmerge
K-way merge for streams
-
agner-sup
An actor toolkit inspired by Erlang/OTP (supervisors)
-
gossip-relay-picker
A relay picker for nostr, used by gossip
-
futwaiter
The container of Future's that has the ability to complete them all at once
-
async-select-all
A futures library adapter for selecting over a list of futures
-
io-tether
Traits for defining I/O objects which automatically reconnect upon failure
-
async-time-mock-async-std
Mockable time for use in async runtimes (async-std compatibility)
-
kay
Experimental high-performance actor system framework for Rust
-
eventsource-stream
A basic building block for building an Eventsource from a Stream of bytes
-
luarmor
API wrapper for luarmor.net
-
pseudoterminal
A cross-platform pseudoterminal implementation with async support
-
pi_async_file
A async file tools library
-
qp
Quick Pool: High Performance Async Generic Pool
-
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
-
git-event
Customizable event handler for updates in remote git repositories
-
spekt
std::future::Future and Result-based testing trait for managing the lifecycle of stateful, asynchronous tests
-
salvia
Incremental computing brought to async Rust
-
rmw_ttlmap
Minimal async cache in Rust with support for key expirations
-
tower-amqp
Framework for building AMQP workers with tower
-
wag
Go like sync.WaitGroup implementation in Rust. (sync/async)
-
croissant
A scheduling library
-
srmw
Asynchronous single-reader, multi-writer
-
mak
but mak it faster
-
peachy
async task manager, similar to thread pool but cooler and for structs
-
stream_generator
Allows to easily generate streams with async/await
-
patchable-async-sleep
An async sleep function, patchable to the preferred runtime
-
rexecutor
A robust job processing library
-
simple_futures
futures for use in async operations
-
rexecutor-sqlx
A robust job processing library
-
russh-agent
Asynchronous ssh-agent client
-
rad
A type-safe, high-level interface to librados using the low-level C bindings from ceph-rust
-
alopecosa
Pure rust async Tarantool 1.6+ connector built on tokio
-
amqp-lapin-helper
rust lapin helper
-
async_dataloader
Powerful tool for avoiding N+1 queries using async/await, based on the DataLoader pattern
-
tinkoffpay
tinkoff integration (the seller receives a link to the payment form and redirect the buyer to it); NB: with callback method
-
clap-and-async-test
Is a example to use clap with tokio and futures, how run concurrently some functions with a loop inside
-
newsblur_api
NewsBlur-API
-
multiqueue
A fast mpmc broadcast queue
-
tokio-rustls-wasi
Asynchronous TLS/SSL streams for Tokio using Rustls
-
hypixel
Rust wrapper for the Hypixel public API
-
toy-async-runtime
Toy library to start to work with async rust, build for reckless person!
-
intercomm
Asynchronous inter-component communication library
-
future-utils
Extensions to Rust's Future and Stream traits
-
sparkle-impostor
A third party crate for Twilight to execute Discord webhooks that clone an existing message
-
ssip-client-async
Client API for Speech Dispatcher
-
blockz-futures
working with futures for the tokio stack
-
haiyuu
experimental actor-like library
-
async-file-lock
Asynchronous file lock that can auto lock and auto seek
-
tezaursapi
api wrapper for tezaurs.lv
-
switchboard
Enables inter-process communiucation via queues and wakers
-
pi_weight_task
任务池
-
webrocket
A closure focused WebSocket server implementation
-
delimiter-slice
Stream type for splitting a delimited stream
-
swait
Blocking on Futures
-
async-jobs
Asynchronous job orchestration for Rust
-
ruw
Read-Update-Write
-
async-refresh
Create values that refresh automatically and asynchronously after a given duration
-
lelet
golang like task executor
-
future-clicker
Reimplementation of manual_future without using
futuresunstable -
rtx
zero-cost runtime-abstraction intended for use by Rust libraries to enable the Freedom of Choice between asynchronous runtimes
-
enfync
Environment-friendly async utilities
-
ringbuf-rs
in-memory ringbuf implementation
-
tokio-scoped
Scoped Runtime for tokio
-
quickwit-actors
Actor framework used in quickwit
-
f289ctrl
Communication library for Fluke 289 digital multimeter
-
openraft-rocksstore
A rocksdb based implementation of the
openraft::RaftStoragetrait -
async-result
wrapper providing a convenient way to await a result, built on futures-channel's oneshot channel
-
interval_future
Wraps a synchronous, waker-less polling function in an interval-based future
-
select-next-any
Alternative to futures::StreamExt::select_next_some that returns the None variant
-
tasc
A minimnal, asynchronous threadpool
-
streams
A collection of stream-extensions that are missing in the
futurescrate -
dwbhk
dwbhk-rs is a library for working with Discord Webhooks
-
crown
jewel of rust libraries
-
rxqlite-common
A distributed sqlite database built upon
openraft,sqlxandsqlite -
compio-net
Networking IO for compio
-
gabelung
Branch an asynchronous stream of cloneable items into two
-
laizy
stable and thread-safe implementation of a lazy value
-
settimeout
Creates a std::future::Future implementation to be ready at some point
-
mrwei
that implements the common promise primitive for rust based on std future
-
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
-
tower-util
working with
Service -
rs-copier
Copy and move files asynchronously
-
mio-uds
Unix domain socket bindings for mio
-
serial-io
A serial port implementation
-
sched-clock
A timer for task scheduling
-
tokio-executor-trait
executor-trait implementation for tokio
-
tokio-socketcan-bcm
Asynchronous Linux SocketCAN - Broadcast Manager support (BCM) with tokio
-
fluvio-async-tls
Asynchronous TLS/SSL streams using Rustls
-
tokio-duplex
Combine seperate
AsyncReadandAsyncWritetypes into a singleAsyncRead + AsyncWritetype -
mlua_actor
Lua Actor for Rust(sync/async)
-
async-compat
Compatibility adapter between tokio and futures
-
agreed
Fork of async-raft, the Tokio-based Rust implementation of the Raft protocol
-
foxhole-api
wrapper for the Foxhole War API
-
arta-tokio
Async abstractions implementation for Tokio
-
madsim-tokio
The
tokiosimulator on madsim -
histlog
hdrhistogram crate, provides off-thread serialization of HdrHistogram interval logs to file
-
koibumi-socks
A minimal SOCKS5 client library
-
tokio_interval
基于Tokio实现了 setInterval(callback, ms) 和 setTimeout(callback, ms) 类似于Javascript的API
-
pixelflut
An async/sync Pixelflut server/client library
-
async-timers
asynchronous timer primitives
-
awesome-operates
A reposity includs many common use code utils
-
stellwerksim
Rust SDK for StellwerkSim
-
sntpc
making SNTP requests
-
fb-api
Facebook Api abstraction for async rust
-
catty
Send and await a value asynchronously
-
actix-storage-sled
actix-storage based on sled
-
lib3h_zombie_actor
lib3h actor request tracking module
-
salvo-serde-util
serde util for salvo
-
eventually-postgres
Event Store implementation using PostgreSQL for the Eventually crate
-
tower-actor
A
towermiddleware that creates aServiceby passing messages to an actor -
page-turner
A generic abstraction of APIs with pagination
-
andiskaz
A convenience library for writing games and other apps in TUI
-
ndless-async
Ndless-specific integration with async/await for the TI-Nspire
-
unblock
A thread pool for isolating blocking in async programs
-
gcp_auth
Google cloud platform (GCP) authentication using default and custom service accounts
-
gcs-rsync
rsync support for gcs with higher perf than gsutil rsync
-
deadpool-bolt
A bolt-client manager for the deadpool connection pool
-
tag_nominatim
Bindings to the reverse geocoding API powered by openstreetmap
-
containerd-snapshots
Remote snapshotter extension for containerd
-
sidekiq-rs
Sidekiq compatible server in Rust
-
async-http-body
Agit init HttpBody Support Async Expressions
-
future_handles
complete futures via handles
-
split-stream-by
Stream extension crate for splitting a Stream into two per a predicate
-
tokio-agent
Agents are a simple abstraction around state, inspired by Elixir's Agent
-
futures-zmq
Futures abstractions for ZeroMQ on any futures executor
-
releez
run application release-checklist safely
-
wgp
waitgroup implementation
-
italo-api
Rust binding for Italo API
-
lnd_grpc_rust
An async library implementing LND RPC via tonic_openssl and prost
-
thread-async
Execute a task in a new thread and await the result asynchronously
-
broadcaster
Broadcasting futures mpmc channel
-
nakadion
Types for interacting with the Nakadi Event Broker
-
tokio-rustls-fork-shadow-tls
Asynchronous TLS streams wrapper for Tokio based on Rustls
-
future-combinator-params
functions to inject extra arguments between futures combinators Then/AndThen
-
swimos_byte_channel
SwimOS Byte Channel
-
fs-mel
Mélodium core filesystem interaction library
-
browser-window
optionally async, optionally threadsafe, electron-like browser toolkit for Rust
-
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
-
strawpoll
A wrapper to avoid spurious polling
-
change_stream
A Stream that only emits if the value is different
-
eventador
lock-free pub/sub event-bus with sync and async APIs
-
scoped_async_spawn
spawn non-static futures
-
async-ops
Use std::ops traits with Futures
-
joyent-tokio-zookeeper
Asynchronous client library for interacting with Apache ZooKeeper
-
oc-wasm-futures
Futures that allow async/await to be used in OC-Wasm for a more ergonomic experience
-
crate-test-xxx
test crate
-
rivulet
Asynchronous contiguous-memory streams
-
qcow2-rs
read/write qcow2 image in async/await
-
async_closure
utilizes the nightly-only feature async_fn_in_trait to imitate async_closures
-
xo-api-client
Unofficial crate for accessing Xen Orchestra through its API
-
completion
writing completion-based asynchronous code
-
samotop
SMTP server and library built on async-std
-
async-raft
An async implementation of the Raft distributed consensus protocol
-
cdrs-tokio
Async Cassandra DB driver written in Rust
-
amqp
AMQP/RabbitMQ protocol client
-
gandi-v5-livedns-api
Gandi LiveDNS Api
-
messagebird-async
Wrapper around the message bird SMS API
-
futures-util-either
futures_util::future::Either Ext
-
async_tasks_state_map
A struct for recording execution status of async tasks with async methods
-
rustpub
Activitypub types
-
stackful
Bridge between sync and async
-
async-openai
OpenAI
-
broker-tokio
tokio for broker
-
async_chanx
Implement
Sinkfor some channel implementations -
deploy
The
deploylibrary to aide writing and debugging of distributed programs, as well as tooling to run them across a cluster -
kythera-fvm
Core implementation of the Kythera FVM
-
alligator
getting the output value from a future
-
makepad-futures
Makepad futures
-
tokio-stream_wasi
work with
Streamandtokio -
raft-lite
understandable implementation of Raft consensus algorithm
-
plctag-async
async wrapper for libplctag
-
heim-common
Common stuff shared across heim project crates
-
medea-reactive
Reactive mutable data containers
-
yaanhyy_rust
cargo mod example
-
anotify
Async iNotify Filesystem Watcher
-
promise
future/promise library for rust
-
xactor
actors framework based on async-std
-
tokio-uds-proto
Unix Domain sockets working with tokio-proto
-
retry_future
Retry futures mechanism
-
medina
An asynchronous web crawling engine
-
log-tracing-layer
Build your own custom tracing layer
-
tcp-channel-client
Asynchronous tcpclient based on aqueue actor
-
rust-gpt
interaction with the Completion/Chat OpenAI API
-
rocketmq-broker
Unofficial Rust implementation of Apache RocketMQ
-
mutex-extra
RefMutex<T>that is similar toMutex<T>but isSyncandSendeven ifTisn’tSend -
futures-websocket
A futures-based websocket implementation
-
discord_api
Interact with the Discord API from your shell
-
async-openai-wasm
OpenAI on WASM
-
relm
Asynchronous, GTK+-based, GUI library, inspired by Elm, written in Rust
-
awaitgroup
Wait for a collection of async tasks to finish
-
simple-async-pipe
Aims to provide a simple pipe-like functionality for async code
-
nanopore
A minimalist async runtime based on io_uring (Linux) and I/O rings (Windows)
-
rfm69-async
async driver for the rfm69 radio transceiver
-
futures-test-preview
Common utilities for testing components built off futures-rs
-
futures-io-preview
The
AsyncReadandAsyncWritetraits for the futures-rs library -
async-read-progress
Extension traits for inspecting
AsyncReadprogress -
promises
Effective, simple, lightweight Javascript promises in Rust
-
async-cuda-npp
Async NVIDIA Performance Primitives for Rust
-
sync_stream
Aggregate multiple streams by polling stream items in order, keeping the consumption of multiple streams in sync
-
jenner
Tools for working with generators to work with both iterators and streams
-
batchloader
A type-safe async request batcher based on facebook's dataloader
-
augrim
consensus algorithms implemented in Rust
-
streamtools
Additional stream combinators
-
manual_future
A future that must be manually completed, similar to Java's CompletableFuture
-
future-by-example
Examples of common patterns using Future
-
futures-task
Tools for working with tasks
-
allochronic-util
Private utility crate for allochronic and khonsulabs
-
remote_config
Flexible crate for asynchronously loading configuration from remote source with caching and automatic revalidation
-
ardop_interface
Interface to the Amateur Radio Digital Open Protocol (ARDOP)
-
callback-future
Adapter between callbacks and futures
-
async_msp_lib
Async msp library for iNav and BetaFlight
-
agent_rt
agent scheduling
-
sender-sink
classes for working with tokio UnboundedSender and the Sink trait
-
gen-stream
Generator-based streams for Rust and futures 0.3
-
Agentic-rs
agentspackage provides a set of tools for creating and managing agents capable of processing text and performing specified tasks based on a given role. It leverages asynchronous… -
atcoder
A template for Rust project
-
tokio-stomp-2
Unofficial successor to Asynchronous streaming STOMP client
-
ebus
Basic Event Bus implementation
-
starstruck
A game building utility that is made to be simple to use while still providing great performance
-
cdp-html-shot
capturing HTML screenshots using CDP
-
libuio
A io_uring based async framework designed for high performance networking on linux
-
enjoin
Powerful syntax-level async join macro
-
c_mcai_worker_sdk
AMQP Worker to listen and provide trait to process message
-
embedded-executor
Embedded systems-friendly
Futuresexecutor -
scd4x-rs
query SCD4x sensors over I²C
-
hala-future
hala asynchronous programming primitive types
-
termion-input-tokio
An adapter that exposes termion's input and key event iterators as asynchronous streams
-
futures-sink
The asynchronous
Sinktrait for the futures-rs library -
restartables
Future that restarts an inner future if it doesn't meet a condition
-
north-config
North config is a multi source configuration crate designed as part of the North Microservice Framework
-
hermod
futures-based RSS/Atom library
-
async-cron-scheduler
Runtime-agnostic async task scheduler with cron expression support
-
service-io
Build your service-server fast, easy (and without hosting!)
-
fut-compat
Offers compatibility between the tokio and async_std runtimes
-
folo
Runtime engine for Rust services
-
tiny-jsonrpc
Json rpc lib based on reqwest
-
encrypted-dns
A modern encrypted DNS server (DNSCrypt v2, Anonymized DNSCrypt, DoH)
-
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
-
kompact-actor-derive
A derive macro for Kompact Actors
-
heim-sensors
Cross-platform sensors information
-
async-signal
Async signal handling
-
try_future
Convenient short-hand for returning early from
futures-based functions -
typout
Command-line typewriter output stream
-
mqttc
client for the MQTT protocol
-
mobc-forked
A generic connection pool with async/await support
-
cooper
in-process, async Actor library for Rust
-
async-lease
Essentially a futures-oriented Arc<Mutex<Option<T>>>
-
unsync
Unsynchronized synchronization primitives for async Rust
-
fsdr-blocks
Building blocks for FutureSDR signal processing library for SDR and real-time DSP
-
futures-time
async time combinators
-
stream-download
streaming content to a local file-backed cache
-
futures-cache
Futures-aware cache backed by sled
-
appliance
A lightweight framework to build async-friendly components with message-based intercommunications
-
simple-tokio-watchdog
Pretty simple but bulletproof watchdog actor
-
tokio-uring-rustls
Integrate rustls into tokio-uring
-
genserver
Elixir inspired async actor library
-
async-dropper-simple
struct-wrapper (i.e. AsyncDropper<T>) based implementation of AsyncDrop
-
connection-utils
Connection related utilities
-
pingora-runtime
Multithreaded Tokio runtime with the option of disabling work stealing
-
tokio_telegraf
Minimal async rust wrapper for the telegraf/influxdb protocol, based on Tokio
-
rusty-gql
Schema first GraphQL Library for Rust
-
scoped_tasks_prototype
A quick-and-dirty attempt to get scoped tasks in Rust
-
coordinator
load balance tasks into task runners
-
atomic-actor
An
Actorwithasync fnhandlers -
tl-async-runtime
A bad runtime impl for educational purposes only
-
cf-turnstile
client for Cloudflare Turnstile
-
ruva
Event Driven Message Handling
-
eventific
that gives you the needed building blocks for event sourcing
-
tokio-anon-pipe
Asynchronous anonymous pipe for Windows
-
agner-actors
An actor toolkit inspired by Erlang/OTP (actors)
-
dynamodb-mutex
Use Dymanodb mutex library
-
set_timeout
allows efficiently executing futures after some delay has passed
-
dbus-async
Asynchronous DBus library
-
geph4-aioutils
geph4
-
est
Extensions for the rust Standard library and Tokio
-
uid-mux
Async multiplexing library with user provided stream ids
-
jarust
A janus client SDK in Rust
-
rexer
Async I/O multiplexing library for rust
-
hitbox-actix
Asynchronous caching framework for Actix
-
sctp-proto
A pure Rust implementation of SCTP in Sans-IO style
-
lunatic-distributed
Node to node communication
-
hydrolink
Lavalink client made with tokio independent of the Discord library, used in production by Hydrogen
-
scuttlebutt
interface for kubernetes events
-
stream-operators
a collection of selected rxjs operators for rust standard Stream
-
kompact-component-derive
A derive macro for Kompact component definitions
-
wasmflow-streams
encapsulating the message packets sent across Wasmflow components
-
cloudflare_dyndns
DynDNS client for Cloudflare
-
gnostr-core
Replication protocol for Hypercore feeds
-
repsheet_etl
ETL tools for repsheet
-
futura
Helpers for working with futures
-
stateful_async_worker
Asynchronous stateful worker threads utilizable as futures
-
fbinit-tokio
detail of fbinit crate
-
mias_channel
that supports bi-directional channels by wrapping others
-
go-zoom-kinesis
A robust AWS Kinesis stream processor with checkpointing and retry capabilities
-
aipim
designed to provide a unified interface for interacting with various AI providers. It abstracts the complexities of different AI APIs, allowing developers to easily switch between providers…
-
asyncio-utils
Support limit,skip on AsyncRead traits
-
uds
A unix domain socket crate that supports abstract addresses, fd-passing and seqpacket sockets
-
unsend
A thread unsafe runtime for thread unsafe people
-
tower-pipeline
A Tower Service combinator that "pipelines" two services
-
serenity_ctrlc
Ctrl+C handler for serenity
-
sfio-tokio-ffi
An oo-bindgen model for using Tokio in an FFI environment
-
eventsourcing
Event Sourcing for Rust
-
tk-cantal
A client for cantal monitoring service. This is not for submitting metrics to the cantal. This library is for accessing metrics that cantal tracks.
-
syndicate
Syndicated Actor model for Rust, including network communication and Dataspaces
-
async-ringbuffer
A nonblocking spsc ring buffer with fixed capacity
-
projections
Macro-free pin projections because why not?
-
axiom
Implements a highly-scalable and ergonomic actor system for Rust based on the best of Erlang / Elixir and Akka
-
aktors
Driver for derive-aktor
-
suppaftp-cli
FTP command line client, based on suppaftp
-
requiem
Actor framework for Rust
-
image_search
designed to search Google Images based on provided arguments
-
openraft-rocksstore-compat07
A example v07 compatible implementation of the
openraft::RaftStoragetrait -
iou
io_uring bindings
-
vkteams-bot-cli
VK Teams Bot API CLI
-
abs_art
ABStraction of Asynchronous RunTime
-
trillium-tokio
tokio runtime adapter for trillium.rs
-
register-count
Counting
Registers created by aCounter -
tokio-pty-process-stream
wraps tokio-pty-process in order to provide a simpler API as a single stream object
-
cocoro
A more type-safe take on Rust stackless coroutines
-
smelling_salts
Abstraction over OS APIs to handle asynchronous device waking
-
par_io
Parallel, async file I/O library with control over memory usage with no dependencies
-
noosphere-core
Core data types of the Rust Noosphere implementation
-
tokio-tun
Asynchronous allocation of TUN/TAP devices using tokio
-
rseip-cip
common industry protocol for rseip
-
ianaio-file
Convenience crate for working with JavaScript files and blobs
-
tokio-netstring-trait
A trait for tokios AsyncRead to easily read netstrings from streams
-
graus-db
A high-performance, thread-safe key-value embedded data store
-
rsdns
DNS Client Library
-
tokio-task-queue
Execute futures from a stream of futures in order in a Tokio task
-
syncthing
controlling syncthing file synchronization through its REST interface
-
django-query
Tools for mocking Django-style endpoints
-
jittr
A binary heap based jitter buffer implementation for zero latency udp/rtp streams
-
otdb
An open trivia database API wrapper
-
tokio-reactor-trait
reactor-trait implementation for tokio
-
rustmark
Extensible web application for serving Markdown-based content
-
thread_runner
executing tasks concurrently
-
tigermq
Message Queue and Batch processing for Rust
-
agnostic-lite
agnostic-liteis WASM friendly and light version ofagnostic, for users who want to write async runtime-agnostic crate -
async-zeroconf
Async library for wrapping Zeroconf implemenations for use with Tokio
-
dtbh_interface
Interface library for the automated scanner
-
async_io_utilities
An asynchronous IO utilities crate powered by
tokio -
safina-executor
Safe async runtime executor - ARCHIVED: Code moved to
safinacrate -
vss
A dead simple library to allow for easily reused shutdown signal handling
-
back-to-the-future
Conversions between std::future::Future and futures::Future
-
asygnal
[WIP] Async-first signal handling, such as ctrl-c
-
crypto-auditing
Client library for crypto-auditing project
-
yew-interop
use javascript and css asynchrously in yew
-
mailbox_processor
A small little actor abstraction inspired by the FSharp Mailbox Processor which in turn was inspired by erlang
-
poolparty
Added functionality for the
futures::executor::ThreadPoolfutures executor -
baildon-store
B+Tree CLI
-
batch-renamer
Framework and command line utilities for interactive renaming of a potentially large number of files
-
wookie
Async test/bench toolkit including single stepping executors. No-std compatible.
-
iterstream
Converts Iterator into real asynchronous Stream
-
async-graphql-relay
Relay support for async-graphql
-
twitch_comment_stream
stream comments from Twitch
-
bluest
A cross-platform Bluetooth Low Energy (BLE) library
-
message-sink
Message framing for AsyncRead + AsyncWrite
-
async-handle
A reference-counted async RwLock
-
futures-loco-protocol
Asynchronous Loco protocol stream for futures
-
socks5-proxy
socks5 library based on tokio offering both server and client functions
-
amqp-manager
Lapin wrapper that encapsulates the use of connections/channels and creation of amqp objects
-
futuresdr-types
Polymorphic Types for an Experimental Async SDR Runtime for Heterogeneous Architectures
-
deduplicate
caching, asynchronous, request deduplication
-
asynciter
Asynchronous iterator
-
hentai
API wrapper for nhentai.net
-
tokio-xmpp
Asynchronous XMPP for Rust with tokio
-
futures-state-stream
A version of the futures crate's Stream which returns state on completion
-
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.
-
dbus-async-derive
Handler trait derive macro for dbus-async
-
tauri-plugin-polodb
A Tauri plugin to expose the PoloDB embedded database to applications
-
openrazer
Asynchronous bindings to the OpenRazer daemon
-
archlinux-repo
Arch Linux repositories parser
-
twitch-irc
Connect to Twitch chat from a Rust application
-
epoxy_streams
Base streams implementation for the
epoxy_frplibrary. Please use epoxy_frp instead. -
reactive-messaging
Reactive client/server communications, focused on high performance
-
suspend
A common mechanism for suspending a thread or a Future until notified
-
tokio-pty-process
Interact with a child process through a pseudo-TTY, asynchronously using Tokio
-
intervalier
Interval events with handling notifications
-
paranoid-hash
A Hashing Library For Those Paranoid With Their Security
-
lemmy_apub_lib
A link aggregator for the fediverse
-
execution-engine
Toca Execution Engine implemented using Futures and async/await
-
mailfred
Process emails as an HTTP server
-
gmqtt-client
MQTTv5 client
-
idb
A futures based crate for interacting with IndexedDB on browsers using webassembly
-
bawawa
Opinionated set of tools to manage and compose process executions
-
reactors
Performance-focused cross-platform asynchronous IO implementation
-
nasu
Command-line utility which poll on remote addresses in order to perform status checks periodically
-
attempt
do something over and over and over and over and
-
coerce-redis
Redis actor persistence provider for Coerce. Supports event sourcing and snapshots
-
bililive
stream-based bilibili live client library
-
mio-signals
handling signals with Mio
-
pinarcmutex
PinArcMutextype, for shared mutable access to pinned data -
icanhazdadjoke-sdk
An SDK to interact with the icanhazdadjoke Dad Jokes API
-
heph-rt
speciailised runtime for Heph's actor
-
neo-email
The modern way to build emails services with Rust
-
retry_fn
retry function with versions for blocking or non-blocking, tokio or async-std
-
mfio
Flexible completion I/O primitives
-
underway
⏳ Durable step functions via Postgres
-
futures-promises
Promises and Watched Variables for Futures
-
transform-stream
Lightweight async stream wrapper
-
oneshot-broadcast
channel that broadcasts a value once without cloning it
-
af-core
A core library and async runtime for Rust applications
-
tracing-layer-slack
Send filtered tracing events to Slack
-
osaka
async for rust without the noise
-
rust-cli-commands
-
tripwire
makes futures pre-emptible
-
assets
asynchronous asset management
-
bonsaimq
Message/job queue based on bonsaidb, similar to sqlxmq
-
lib-wc
Will's Programming Toolbox
-
email-lib
Cross-platform, asynchronous Rust library to manage emails
-
salvo-oapi
OpenApi support for Salvo web framework
-
process-stream
Thin wrapper around [
tokio::process] to make it streamable -
ipc-orchestrator
Orchestion of command line processes for local dev usage with IPC communication
-
retry-strategy
A better asynchronous retry tool based on Tokio
-
watchfile
An async utility trait to subscribe to file changes of a serializable file
-
bevy_flurx
Allows you to write sequential description of processes involving delays, user input, and other waits
-
epoxy_frp
The Reactive Glue for Frontend Applications
-
parabuild
A parallel build utility for template heavy projects
-
crb-core
CRB | Composable Runtime Blocks | Core
-
tempest
Realtime message handling framework inspired by Apache Storm and built with Actix
-
asyncs-sync
Asynchronous runtime agnostic synchronization utilities
-
tokio-extra-macros
Extra proc macros for Tokio
-
async-native-tls-alpn
Native TLS using futures
-
async-pipe
Creates an asynchronous piped reader and writer pair using tokio.rs
-
tokio-task-tracker
graceful shutdown solution for tokio
-
tokio-global
Global tokio runtime
-
spin_future
Convert synchronous functions into valid but inefficient futures
-
monoio-io-wrapper
A read/write wrapper to bridge sync and async io
-
futures-to-stream
Turn heterogeneous Futures of same associated Output type to a stream
-
tokio-tasks
Task managment for tokio
-
retainer
Minimal async cache in Rust with support for key expirations
-
vino-packet
encapsulating the message packets sent across Vino components
-
async-rx
functions for async reactive programming
-
flysystem
A filesystem abstraction layer for Rust
-
duplexify
Combine a reader + writer into a duplex of Read + Write
-
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
-
futures-mockstream
Minimal mockstream which implements futures async traits
-
leaves
Distributed ID Allocator
-
futures-shuttle
Futures-aware shuttle synchronization object
-
tokio-transports
used for communication between processes
-
libp2p
Peer-to-peer networking library
-
lease
Object pool that leases values and automatically returns them with async support
-
xtor
Async Actor framework for Rust which is blazing fast and rock solid
-
lsp-codec
Tokio-compatible codec implementation for Language Server Protocol
-
gdext_coroutines
Run Rust Async functions and Coroutines in Godot 4.2+ (through GDExtension), inspired on Unity's Coroutines design
-
futures-cputask
Turn synchronous CPU-bound tasks into futures
-
mysql_async
Tokio based asynchronous MySql client library
-
akinator-py
Python bindings for akinator-rs
-
channels-io
Async agnostic/Sync IO & buffer management abstractions
-
blocksr
Drew's Rust library for (clang/objc) blocks
-
fundamentum-edge-pfwd
The port forwarding tool for edge daemon
-
compio-buf
Buffer trait for completion based async IO
-
limitr
offering various rate-limiting algorithms such as Token Bucket, Leaky Bucket, and more
-
peace_item_sh_cmd
Manages running a shell command for the peace framework
-
async-codec-lite
Adaptors from AsyncRead/AsyncWrite to Stream/Sink using futures
-
fates
creating reactive declarations
-
tokio-lock
Access an object from a single Tokio task
-
elfo-test
Test utils for the elfo system
-
basu
Eventbus crate with sync and async features
-
riker-cqrs
Command Query Responsibility Separation for Riker applications
-
tower-sessions-sqlx-store
SQLx session stores for
tower-sessions -
lwactors
Lightweight actors for Rust using futures-rs
-
conquer-struct
macros to perform concurrent future resolution, while populating struct fields
-
bevy-tokio-tasks
integration of a Tokio runtime into a Bevy app for background processing
-
dummy-waker
Get a
core::task::Wakerthat does absolutely nothing -
async-hofs
Various extention traits for providing asynchronous higher-order functions
-
wait-for-me
Async CountDownLatch
-
redis-asio
Asynchronous Redis driver based on tokio
-
rust-runc
consuming the runc binary in your Rust applications
-
mini-tokio
basic asynchronous rust executor
-
wd_event
event system
-
futures-rate
easy tools to help Rust applications guide critical resources or code paths from being overwhelmed
-
tokio-resource-pool
A generic resource pool for the Tokio ecosystem
-
serviceless
actor model in rust, like actix
-
retry_async
retrying, with specific support for the Azure SDK for Rust (cf. https://github.com/Azure/azure-sdk-for-rust).
-
futures-async-combinators
toy futures combinators
-
tokio-shared-udp-socket
Easily share a UDP socket between different futures in tokio
-
june
ergonomic remote actors via actix and canary
-
runtime-loop
Runtime loop for Rust
-
axum-server
High level server designed to be used with axum framework
-
blocking_pool
A thread pool for running synchronous I/O in asynchronous applications
-
tower-limit
Limit maximum request rate to a
Service -
async-stream-http-tunnel-grader
Asynchronous stream http tunnel grader
-
indexed_db_futures
Future bindings for IndexedDB via web_sys
-
stomp
A full STOMP 1.2 client implementation. Allows programs to interact with message queueing services like ActiveMQ and RabbitMQ.
-
araft
An async raft implementation based on tokio + tonic
-
mio-extras
Extra components for use with Mio
-
completeio
Completion based IO drivers and async runtime
-
gpiocdev
Access GPIO lines on Linux using the GPIO character device
-
kapacitor-multi-indicator-batch-udf
A multi-indicator batch UDF for Kapacitor
-
tarpc
An RPC framework for Rust with a focus on ease of use
-
fluke-maybe-uring
Replicates some tokio-uring types to allow building code without it
-
rqlite-ha421
An async implementation of a rqlite client
-
bleasy
High-level BLE communication library
-
euklid
CRDT
-
ockam_node_no_std
Ockam library types that do not need
std -
minehut
easy to use Rust wrapper for the Minehut API
-
actix-async-await
Experimental async/await support for Actix
-
makiko
Asynchronous SSH client library in pure Rust
-
rust-stream-ext-concurrent
Concurrent behavior extensions for any futures::stream::Stream objects
-
whorl
was created to teach you how async executors work in Rust
-
async-graphql
A GraphQL server library implemented in Rust
-
actix-raft
Raft distributed consensus protocol using the Actix actor framework
-
oauth-lib
Asynchronous Rust library to deal with OAuth flows
-
bme280-rs
query BME280 sensors over I²C
-
tk-easyloop
A thread local loop and other loop helpers
-
volo-macros
Volo's proc macros
-
rexa
GraphQL MongoDB API builder
-
rt-local-core
Thread local asynchronous runtime working with platform-specific event loops
-
futures-option
Extension traits for dealing with optional futures and streams
-
coerce-k8s
Kubernetes discovery provider, automatically discover cluster peers hosted in Kubernetes, based on a configurable pod-selection label
-
heim-disk
Cross-platform disk information
-
hl7-mllp-codec
A Tokio codec for HL7 Minimal Lower Layer Message Transport protocol (MLLP)
-
todc-net
Algorithms for message-passing (HTTP) distributed systems
-
eventually-redis
Event Store implementation using Redis, for Eventually crate
-
rillrate-system
RillRate agent for system monitoring
-
cargo-daku
Daku API cargo plugin
-
posturn
Build turn-based games with
asyncRust -
tracing-durations-export
Record and visualize parallelism of tracing spans
-
f189ctrl
Communication library for Fluke 189 digital multimeter
-
async-raft2
An async implementation of the Raft distributed consensus protocol
-
safe-vk
create your own vk bot for conversations
-
gmf
An RPC library using Glommio and Tonic. Note: This package only works on Linux.
-
async-pidfd-next
Process file descriptors (pidfd) for Linux
-
cute-async
Cute async utilities
-
local-spawn-pool
Spawn
!Sendfutures in a pool and await for all of them to finish. Standalone alternative totokio::task::LocalSet. -
simple-actor
Helper to write actor-based async code
-
specta-typescript
Export your Rust types to TypeScript
-
hyper-futures
Compatibility layer for futures to use AsyncRead and AsyncWrite traits with hyper
-
async-openai-wasi
Async bindings for OpenAI REST API based on OpenAPI spec
-
egg-mode-extras
Rate-limited streams and other helpers for egg-mode
-
paggo
A small, fast, and safe in-memory database
-
async-io-traits
Async versions of io traits
-
one_for_one
supervize spawn'ed async tasks
-
relaxed_channel
Wrapper around async-channel, more performant on heavy pipelines
-
mobc-bolt
A bolt-client manager for the mobc connection pool
-
ekv
Key-value database for embedded systems, for raw NOR flash, using an LSM-Tree
-
libpool
threadpool from The Rust Programming Language
-
grpcio
language implementation of gRPC, base on the gRPC c core library
-
monoio-rustls-fork-shadow-tls
Asynchronous TLS streams wrapper for Monoio based on Rustls
-
tonic_lnd
An async library implementing LND RPC via tonic and prost
-
mio-utun
Utun bindings for mio
-
tus_async_client
native async client library to interact with *tus* enabled endpoints
-
tracing-appender
file appenders and making non-blocking writers
-
eventastic
opinionated fork of Eventually-rs. It enforces the use of transactions and handles idempotency.
-
safina-select
Safe async select function, for awaiting multiple futures - ARCHIVED: Code moved to
safinacrate -
rustls-acme
TLS certificate management and serving using rustls
-
smol-hyper
Integrations between smol and hyper
-
mofo
Multiple Ongoing Futures Object - an abstraction for easily managing ongoing child tasks with futures
-
stream-utils
Additional stream combinators
-
minicoro-sys
rust binding to minicoro
-
arti-bench
benchmarking utility for Arti
-
ex-futures
An extension of
futures -
stick
Platform-agnostic asynchronous gamepad, joystick and flighstick library
-
prokio
An asynchronous runtime compatible with WebAssembly and non-WebAssembly targets
-
tokio-rustls-acme
Automatic TLS certificate management using rustls
-
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.
-
futures-timeout
that provides timeouts for futures and streams
-
init_sysytem
Framework to wrap application init
-
tbon
TinyChain Binary Object Notation is a compact and versatile stream-friendly binary serialization format
-
streamify
Conversions from values to Stream
-
client-handle
A macro to generate client handles when using multithreaded / asynchronous code
-
component-future
implements the inner future protocol documented in the tokio docs
-
itla
ITLA (micro laser) non-blocking control library using embedded-hal
-
safina-async-test
Macro for running async tests - ARCHIVED: Code moved to
safinacrate -
forceps
async & on-disk database
-
hyper-multipart-rfc7578
multipart/form-data (RFC7578) for Hyper
-
elfo-configurer
Loads and distributes configs across the elfo system
-
spawn_groups
Structured concurrency construct written in Rust, for Rustaceans
-
online
📶 Library to check your Internet connectivity
-
aral-runtime-tokio
Aral Runtime for tokio
-
gearbox
Excessive tooling for Rust, boosting productivity and operations
-
kvarn-tokio-uring
Temporary Kvarn fork: io-uring support for the Tokio asynchronous runtime
-
bb8-ruarango
bb8 connection pooling impmentation for the ArangoDB database
-
crb-task
CRB | Composable Runtime Blocks | Task
-
tokio-prepend-io
Wrapper types that prepends data when reading or writing with AsyncRead or AsyncWrite
-
async-weighted-semaphore
An async weighted semaphore
-
client-util
Help you to build requests and handle responses by several extension trait!
-
gritea
Gitea API sdk
-
futures-util-io-peek
AsyncPeek trait
-
async-pidfd
Process file descriptors (pidfd) for Linux
-
smol-macros
Macros for setting up a smol runtime
-
skrillax-stream
Combines skrillax-network crates to work nicely on top of a tokio tcp stream
-
asyncore
-
async_message_dispatcher
dispatching messages to asynchronous handlers easier
-
deadline
A one-macro crate to ensure assertions meet their deadlines
-
py_mcai_worker_sdk
AMQP Worker to listen and provide trait to process message
-
tokio-async-write-utility
Some helper functions for types impl AsyncWrite
-
async-stream-tls-upgrader
Asynchronous stream tls upgrader
-
pinned
Synchronisation primitives for !Send tasks
-
implicit-await
Implicitly await calls returning Future impls
-
app-queue
In-app persistent queue for asynchronous jobs
-
signals
A functional-reactive-like library for Rust that allows asynchronous chaining
-
mycelium_lib
Mycelium DDM
-
jelastic-rs
Rust wrapper for the Jelastic API
-
futures-async-runtime-preview
Runtime for the async/await macros in the
futurescrate -
async-read-util
A collection of utilities for working with AsyncRead
-
gen-z
Macro-free stream construction through asynchronous generators via an awaitable sender
-
strife
A lightweight library for the Discord API
-
interprocess-docfix
Interprocess communication toolkit. Docs fixed.
-
akt
An actors library for Rust and Tokio designed to work with async / await message handlers out of the box
-
plumb
A functional, async pipeline framework
-
tokio-utun
Utun bindings for Tokio
-
gneiss-mqtt
Asynchronous and threaded MQTT(5) clients
-
rs-car-ipfs
rs-car wrapper to read files from IPFS trustless gateways
-
quicksink
Create a Sink from some value and a closure returning a Future
-
charred
char checking
-
wasmcloud-interface-sleepy
Interface for interacting with the sleepy capability provider
-
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.
-
worst-executor
A spin-loop like executor for async
-
activitystreams-traits
Traits for ActivityStreams 2.0 objects
-
axum-serde
multiple serde-based extractors / responses for the Axum web framework, also offers a macro to easily customize extractors / responses
-
futuresdr-pmt
Polymorphic Types for an Experimental Async SDR Runtime for Heterogeneous Architectures
-
tokio-context
Contexts for cancelling asynchronous tasks using tokio
-
ginepro
A client-side gRPC channel implementation for tonic
-
async-drop-guard
offers hash map and cache data structures where individual entries can be locked
-
task-exec-queue
A asynchronous task execution queue
-
cucumber-codegen
Code generation for
cucumbercrate -
medusa-zip
A command-line interface to high-performance parallelized implementations of common zip file operations
-
zippyst
Resolve zippyshare.com download links
-
incoming
Trait for taking ownership of a stream of incoming connections
-
mediatrix
Strongly typed, extensible event mediator
-
async-component-components
async-component components
-
sampr
A message passing framework using actors
-
volo-grpc
gRPC framework implementation of volo
-
fd-queue
support fd passing on Unix sockets
-
starpu-sys
Low-level bindings to the StarPU runtime
-
limited-join
A zero-dependency crate providing a join future with limited concurrency
-
async-dup
Duplicate an async I/O handle
-
st7735-async-low
Low-level async library for 4-wire serial ST7735
-
swimos_runtime
SwimOS Agent & Downlink Runtime
-
stewart-utils
Small common utilities for stewart
-
izihawa-common-multipart
multipart/form-data
-
acton_test
Testing utilities for Acton agents, providing tools to help in the testing and validation of agent behavior
-
simple-process-stats
Get memory usage and CPU time on Linux and Windows
-
sealrs
Set of classic asynchronous primitives (Actors, Executors, Futures / Promises)
-
tokio-async-std
An async-std that can fit into tokio ecosystem straight ahead
-
veilid-async-tls
Asynchronous TLS/SSL streams using Rustls
-
garcon
A collection of trait and classes to make your thread or async function wait
-
tower-buffer
Buffer requests before dispatching to a
Service -
async-task-ffi
Task abstraction for building executors
-
orcinus
async-ready mysql protocol implementation / wrapper libraries
-
northstar-rcon-client
Asynchronous RCON client for the Northstar mod
-
ratchet_rs
Async WebSocket implementation
-
and-then-concurrent
Concurrent and-then combinator for Rust streams
-
real-async-trait
A proc macro that uses experimental features to work around type erasure for async traits
-
riker-patterns
A collection of common actor patterns for Riker
-
jsonrpc-rs
Futures base jsonrpc server/client framework
-
wtx
A collection of different transport implementations and related tools focused primarily on web technologies
-
smol-timeout2
A way to poll a future until it or a timer completes
-
reqwest-streams
HTTP body streaming support for reqwest: JSON/CSV/Protobuf and others
-
streem
creating and consuming streams
-
futures-test-sink
Test utilities for futures::sink
-
async-graphql-viz
async-graphql for viz
-
pipebuf_mio
PipeBuf support for
miobyte-streams -
egui_task_manager
Manage asynchronous easily
-
holidayapi_rust
A HolidayAPI library for Rust
-
dbus-tokio
Makes it possible to use Tokio with D-Bus, which is a bus commonly used on Linux for inter-process communication
-
async_repeat
Retry futures mechanism
-
rama-socks5
SOCKS5 support for rama
-
stalk
sending serialized data with tokio
-
ttl_cache_with_purging
A time-to-live (TTL) cache implementation with optional background purging for expired entries
-
flynn-openai
OpenAI
-
desaturate
This package aims to makes it easier to maintain a single code base for both regular and async functions
-
noop-waker
A waker that does nothing
-
local-pool-with-id
A minor variation on a LocalPool executor which exposes unique IDs for tracking future completion
-
tes3mp-plugin
Stubs for creating a TES3MP server plugin
-
booru-dl
A command line tool to download images and tags txt from booru
-
bookkeeper-client
Async rust client for Apache BookKeeper
-
async-subscription-map
Async bookkeeping datastructure for state subscriptions
-
must-done
An experimental Future that is guaranteed to be done
-
callysto-avro
Avro serde for Callysto Stream Processing Framework
-
puppet
actor framework which uses no dynamic dispatch or boxing
-
uller
Generate/Donwload your links
-
yaaf
Actor Framework
-
ector
open source async, no-alloc actor framework for embedded devices
-
async-ioutils
A collection of async utilities for I/O
-
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. -
tokio-futures-respawn
function to respawn failed long running tasks
-
noosphere-fs
A high-level, FS-like view over Noosphere content
-
tower-async-hyper
Bridges a
tower-asyncServiceto be used within ahyper(1.x) environment -
azur
A no_std Rust crate that implements an executor/reactor and futures using io_uring
-
basteh
Generic kv storage with replaceable backend
-
proxied
Asynchronous client connector for proxies
-
thespis
The interface of the thespis actor model (contains only traits)
-
tor-general-addr
Generalized socket address type used by Tor
-
bottle
Actor model framework for Rust
-
dioxus-query
Fully-typed, async, reusable cached state management for Dioxus 🧬
-
futures-waitmap
future-based concurrent event waiting hashmap
-
again
wasm-compatible retry util for std library futures
-
felixs-tower-lsp
Language Server Protocol implementation based on Tower
-
jarust_plugins
A janus client SDK in Rust
-
async-http-client-lite
Asynchronous http client
-
troupe
modelling Rust applications with actors
-
spotify-rs
wrapper for the Spotify API
-
agner-reg
An actor toolkit inspired by Erlang/OTP (reg)
-
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.
-
some_local_executor
local executor
-
bevy_async_system
ability to wait for game status asynchronously
-
cache-compute
implements request/async computation coalescing
-
spawns-compat
Async runtime detections for thread context task spawner
-
handy_async
A handy library for describing asynchronous code declaratively
-
tokio-udev
Non-blocking/Asynchronous Tokio support for udev device events
-
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
-
async-shell
Asynchronous process child wait
-
vru-cancel
Cancel tokio stream
-
tower-balance
Balance load across a set of uniform services
-
async-read-length-limit
limit the size of an async read
-
hyper_lua_actor
Binding of lua_actor & hyper
-
tk-bufstream
A buffered stream backed by contiguous buffers (netbuf) for tokio
-
tower-sessions-file-store
Store sessions for Tower Session store on the file system
-
async-entry
extended Tokio's proc macros
-
ctrlgen
Generate enums for message-passing services
-
aster-proxy
A light, fast and powerful cache proxy written in Rust
-
sn_data_types
Safe Network Data Types
-
tokio-util_wasi
Additional utilities for working with Tokio
-
isostatic
minimal url shortner
-
bader-db
Key-value cache RESP server with support for key expirations
-
fil_actors_runtime_v9
System actors for the Filecoin protocol
-
tokio-tls-gmssl
TLS/SSL streams for Tokio using native-tls giving an implementation of TLS for nonblocking I/O streams
-
tourniquet-celery
Async native round-robin manager for remote services. celery integration.
-
safina-net
Safe async network functions - ARCHIVED: Code moved to
safinacrate -
uringy
single-threaded concurrency runtime for Rust based on io_uring
-
mwmr
A generic optimistic transaction manger, which is ACID, concurrent with SSI (Serializable Snapshot Isolation)
-
lunatic-distributed-api
control server implementation
-
rtix
Actors with generators. Name up for grabs until I do something with it, or rust supports proper coroutines
-
tractor
Actor system modelled after Pony's actors
-
ero
Erlang-inspired framework for organizing async code in a fault-tolerant way
-
crossbus
A Platform-Less Runtime-Less Actor Computing Model
-
tower-sessions-sqlx-store-chrono
SQLx session stores for
tower-sessionsbut usingchronoinstead oftime -
serio
providing traits and utilities for typed IO using format agnostic serialization built on serde
-
atomic-waker
A synchronization primitive for task wakeup
-
agner
An actor toolkit inspired by Erlang/OTP
-
axum-router-plugin
Shared library-based plugins for Axum
-
tokio-fastcgi
FastCGI handler (responder, authorizer, filter) library for Tokio
-
fibers_inotify
A futures friendly inotify wrapper for fibers crate
-
fibers_tasque
A
tasqueextension specialized forfibers -
async-resource
Async resource pool
-
nr-tracing-layer
Send your logs to New Relic
-
cloudflare-workers-kv-sdk-rs
Unofficial Cloudflare Workers KV SDK for Rust-Lang
-
async-graphql-axum-wasi
async-graphql for axum
-
linux-io-uring
The
io_uringlibrary for Rust -
tonic-middleware
Async middleware and interceptor for Tonic services
-
background-jobs-core
Core types for implementing an asynchronous jobs processor
-
tokio-takconnect
Asynchronous Playtak client
-
spmc-logger
A single-producer multi-consumer persistent logger
-
associated-async-io
Async IO traits that use futures instead of poll
-
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
-
etcd-rs
etcd client for rust
-
tower-sessions-dynamodb-store
AWS DynamoDB session store. Not for direct use; see the
tower-sessionscrate for details. -
tokio-mockstream
A fake stream for testing network applications backed by buffers
-
ws-gonzale
Naive websocket server implemented using async / await
-
pipebuf_websocket
PipeBuf support for websockets
-
shared_stream
easily cloneable streams
-
ntex-files
Static files support for ntex web
-
tokio-macros
Tokio's proc macros
-
kapacitor-multi-indicator-stream-udf
A multi-indicator stream UDF for Kapacitor
-
tokio-shield
Prevent futures from being aborted by wrapping them in tasks
-
safina-sync
Safe structs for sharing or sending data between async tasks - ARCHIVED: Code moved to
safinacrate -
elk-mq
A Message Queue implementation in rust, using Redis as a communication medium
-
agreed-memstore
An in-memory implementation of the
agreed::RaftStoragetrait. Fork of async-raft’s memstore crate. -
telers
An asynchronous framework for Telegram Bot API written in Rust
-
noosphere-ipfs
An interface for an IPFS client
-
relock
Distributed async locking using Redis
-
fourche
task queue named after a lion with forked tail (queue fourché), works with Redis
-
future-result
An ideomatic way of mapping a Result to a Future of Result
-
kvarn_async
Async utilities used in the Kvarn web server
-
stry-evermore
allowing you to run an fixed number of asynchronous task repeatedly until a shutdown signal is sent out
-
signald-rust
interface with Signald
-
tokio-hglib
Tokio-based async client library for Mercurial command server
-
actordb
An actor-first distributed database
-
openssh-sftp-protocol-error
Data format used to communicate with openssh mux server
-
greenthread-future
Convert closures to futures based on greenthread on bare-metal (no_std + no_alloc)
-
rxqlite-lite-common
A distributed sqlite database built upon
openraft,sqlxandsqlite -
wasmflow-traits
encapsulating the message packets sent across Wasmflow components
-
tokio-timerfd
timerfd support for tokio
-
stream-reduce
Fold a stream without an initial value
-
promising-future
Promise/Future pairs
-
core-futures-tls
A libcore wrapper allowing async/await to be used from no_std crates
-
rxqlite-tests-common
A distributed sqlite database built upon
openraft,sqlxandsqlite -
lunatic-messaging-api
Lunatic host functions for message sending
-
tasky
fluent async task experiments
-
async_dag
An async task scheduling utilitiy
-
heim-virt
Cross-platform virtualization system detection
-
feature-extension-for-async-std
Feature extension for async-std
-
aspartam
Minimalistic actor framework based on tokio, inspired by actix
-
wasm-agnostic
users who want to write async runtime-agnostic crate for wasm target
-
arta-async-std
Async abstractions implementation for async-std
-
chikatetsu
An(other) actor framework for Tokio
-
futures-stable-preview
futures which support internal references
-
tosho-kmkc
An asynchronous client of KM API by KC
-
coerce-rt
Async actor runtime
-
async_event_streams
Asynchronous Events Pub/Sub Library
-
libp2p-dns
DNS transport implementation for libp2p
-
noosphere-into
Transformations of Noosphere content into various target formats
-
waitfor
Retry a function until it succeeds, errors out, or a timeout/deadline is reached
-
vertigo
Reactive Real-DOM library with SSR for Rust
-
async-middleware
async monad(ish) middleware in Rust using tuples and async trait transforms
-
rados_hi
Opinionated high-level wrapper for librados (Ceph)
-
stream-flatten-iters
Flattens a stream of iterators into one continuous stream
-
dndx-fork-tokio-tun
Asynchronous allocation of TUN/TAP devices using tokio
-
suspend-channel
Channel and stream implementations
-
pipebuf_rustls
PipeBuf wrapper for Rustls
-
async-acme
async ACME client for tls-alpn-01 challenge
-
compio-runtime
High-level runtime for compio
-
futures-stream-select-ext
futures::stream::select Ext
-
tokio-compat-02
Tokio 0.2 compat utilities
-
svix
Svix webhooks API client and webhook verification library
-
mold2d
platformer game library in Rust
-
kay_codegen
Code generation for implementing kay actors
-
async-graphql-extension-apollo-tracing
An async_graphql extension to send traces & metrics to Apollo Studio
-
atm-async-utils
implementing and testing futures::Sink and futures::Stream related code
-
async-option
Essentially an asynchronous Async<Mutex<Option<T>>>
-
opentls
TLS connections with OpenSSL
-
stream-future
Implement an async iterator with return value
-
bevy_impulse
Reactive programming and workflow execution for bevy
-
rseip-eip
encapsulation protocol for rseip
-
cynthia
A high performance asynchronous programming runtime for Rust
-
unix-udp-sock
async & sync UDP sockets supporting sendmsg/recvmsg and src IP manipulation
-
kad
A generic / futures based implementation of the Kademlia Distributed Hash Table (DHT)
-
openssh-mux-client
openssh mux client
-
accumulate-api
Lower-level API for interfacing with the Accumulate Protocol via JSON-RPC
-
ockam_node_attribute
Ockam node attribute proc_macro
-
async-compression
Adaptors between compression crates and Rust's modern asynchronous IO types
-
rasi-ext
includes extend features or experimental features that are useful for asynchronous programming
-
peace_item_spec_file_download
Manages downloading a file for the peace framework
-
mqtt-channel-client
MQTT client that communicates over Tokio channels
-
trovo
A trovo.live api & chat client written in and for rust
-
tokio-iocp
IOCP support for the Tokio asynchronous runtime
-
comet-eventbus
strong-typed sync and asynchronous eventbus
-
surrealdb-async-graphql-axum
async-graphql for axum
-
docker_engine_api
way to interact with the Docker Engine API
-
async-gitlib
Asynchronous library with libgit2 artifacts
-
actix-ws-ng
WebSockets for Actix Web, without actors
-
agilulf_protocol
Agilulf Protocol serializer and deserializer
-
chtsh
Rust CLI for interacting with https://cht.sh
-
awaitable-error
Awaitable type with input and output that can be stored in container
-
async-thread
Futures version of std::thread
-
async-rustls-stream
An async tls stream library based on rustls and futures-io. Both for server/client.
-
sqlxmq
A reliable job queue using PostgreSQL as a backing store
-
asteroid-mq-model
Basic models for asteroid-mq
-
json-array-stream
Incrementally reads a JSON array through an async stream
-
indexed-db
Bindings to IndexedDB that default the transactions to aborting and can work multi-threaded
-
peace_item_tar_x
Manages extracting a tar file for the peace framework
-
clia-ntex-files
Static files support for ntex web
-
derive-tokio-io
Derive AsyncRead and AsyncWrite
-
volo-thrift
Thrift RPC framework implementation of volo
-
beul
It executes futures
-
swiftide-core
Blazing fast, streaming pipeline library for AI applications
-
posixmq
An idiomatic library for using posix message queues, with optional mio integration
-
sendblue
that provides an API client for interacting with the SendBlue REST API, enabling businesses to integrate iMessage and SMS services into their applications
-
actix-server
General purpose TCP server built for the Actix ecosystem
-
specta-serde
Serde support for Specta
-
futures-utils-lite
futures about utils in lite
-
async-graphql-value
GraphQL value for async-graphql
-
eventually
using Event Sourcing in Rust applications
-
txrx
take on the C++ unified executors proposal
-
tigerbeetle-unofficial-core
Safe low level callback-based async bindings to tigerbeetle client library
-
tower-sessions-surrealdb-store
SurrealDB session store. Not for direct use; see the
tower-sessionscrate for details. -
heim
Cross-platform framework for system information
-
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.
-
barrage
An async broadcast channel
-
vanilla_tokio_actor
Vanilla Tokio Actor
-
futuredsp
A signal processing library for SDR and real-time DSP
-
aector
Dynamic implementation of the actor model with a smart built-in testing framework
-
pn532
protocol implementation
-
async-throttle
Asynchronous Rate Limiting
-
swimos_introspection
SwimOS Agent Introspection
-
ffi_rpc
Use FFI with RPC
-
compio-tls
TLS adaptor with compio
-
event_handlers
A unified library for handling events
-
libevent
Rust bindings to the libevent async I/O framework
-
takyon
single threaded async runtime
-
genawaiter-macro
Convenience macros for generators (genawaiter)
-
ockam_transport_websocket
WebSocket Transport for the Ockam Routing Protocol
-
tower-redis
A Tower service for asynchronous Redis request/response performed over a managed, multplexed connection
-
linux-io-uring-sys
The
io_uringbindings for Rust -
aldrin
Message bus for service-oriented RPC and interprocess communication
-
futures-stream-reader
Convert an [AsyncRead] into a [Stream] of byte chunks
-
fs4
No libc, pure Rust cross-platform file locks. Original fs2, now supports async and replace libc by rustix.
-
fil_actors_runtime_v10
System actors for the Filecoin protocol
-
waitlist
Keep track of an ordered list of Wakers to wake
-
async-trait-ext
a procedural macro for async traits
-
busybody
Service Container and Dependency injector crate
-
jstream-ext
adds some extra extensions to futures Stream traits
-
async-cuda-core
Async CUDA streams and buffers for Rust
-
tabs
A collection of asynchronous task abstractions, based on tokio
-
cf-pty-process-alpha
the tab multiplexer fork of tokio-pty-process. Interact with a child process through a pseudo-TTY, asynchronously using Tokio
-
common-multipart-rfc7578
multipart/form-data (RFC7578)
-
async-tick
tick clock
-
airlock
no_std async communication
-
async_main
Runtime-agnostic async main proc macro
-
tokio-task-manager
Allow an async Tokio application to gracefully shutdown, waiting for all tasks to finish
-
vesper-macros
Procedural macros used by Zephyrus
-
async-global-executor-trait
executor-trait implementation for async-global-executor
-
photonio
A runtime for asynchronous applications
-
alzheimer
Async implementation of brainfuck interpreter
-
nature
development support platform, it separates data definition from code, so it decouple the data from business system
-
tokio-beanstalkd
Asynchronous client library for interacting with Beanstalkd work queue
-
async-diesel
Integrate Diesel into async-std cleanly and efficiently
-
puddle
object pool implementation that uses asynchronous synchronization primitives only
-
form-data
AsyncRead/AsyncWrite/Stream
multipart/form-data -
dd-tracing-layer
Send your logs to Datadog
-
hooch-macro
Procedural macros for the hooch async runtime
-
compio-signal
Signal handling for compio
-
agner-init-ack
An actor toolkit inspired by Erlang/OTP (init-ack)
-
async-stream-packed
Asynchronous stream packed
-
rotor
The mio-based framework for doing I/O in simple and composable way
-
completeq-rs
An alternative to passing messages between asynchronous tasks
-
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) -
minimal-executor
A minimal executor for asynchronous tasks based on the futures-rs library
-
ruchei-callback
Callback traits for ruchei
-
its_ok_to_be_block_on
A minimal implementation of block_on, to execute futures in a syncronous context
-
aligne
A small crate using tokio to synchronize asynchronous request/response with Ids
-
casus
containing a handful of event-based async primitives
-
xml-macro
A convenience macro for quick-xml
-
vmc
Virtual Motion Capture protocol for virtual avatar tracking
-
fastcgi-client
Fastcgi client implemented for Rust
-
thetvdb
API async client
-
async-reactor-trait
reactor-trait implementation for async-io
-
file-descriptors
Wrapper around the common kinds of (mostly Linux) file descriptors, including sockets, pipes, FIFOs, terminals, serial ports, character devices, epoll, POSIX message queues, timerfd…
-
edge-dhcp
Async +
no_std+ no-alloc implementation of the DHCP protocol -
edge-nal
Hosts a bunch of traits which are not yet available in the embedded-nal-async crate
-
num_stream
that provides a Stream that yields incrementing numbers at a specified interval
-
retry-if-macro
A tokio-compatible attribute-macro for decorating methods and functions with an exponential backoff
-
mio-timerfd
mio support for linux's timerfd
-
task_yield
Executor-independent task yielding
-
lucia-apis
A set of API collections based on the lucia framework
-
fred
An async client for Redis and Valkey
-
libp2p-swarm
The libp2p swarm
-
winit-runtime
Async winit runtime
-
tower-timeout
Apply a timeout to requests, ensuring completion within a fixed time duration
-
reqwest-eventsource
Helper to build an Eventsource using reqwest
-
rdbc-rs
Futures base Rust DataBase Connectivity (RDBC) library
-
futurify
Convert your sync functions into non-blocking thread futures
-
improv
Actor microframework
-
rabble
creating location transparent actor based systems
-
tokio-dbus
Pure Rust D-Bus implementation for Tokio
-
jarust_rt
A janus client SDK in Rust
-
wtr-watcher
Filesystem watcher. Works anywhere. Simple, efficient and friendly.
-
async-core
A standard for async runtimes
-
gidle_future
A future executor for the glib main loop idle time
-
tower-async-bridge
Bridges a
tower-asyncServiceto be used within atower(classic) environment, and also the other way around -
waker-set
waker set
-
tasktrace
Logical 'backtraces' of async tasks
-
kyansel
Cancellable future. Provide a future as argument and the current future will cancel if the provided future resolves first
-
async-priority-queue
An async-aware priority queue
-
delay
A collection of trait and classes to make your thread wait (and timeout)
-
sendgrid-async
An async-std based client for sending emails with SendGrid
-
evermore
allowing you to run an fixed number of asynchronous task repeatedly until a shutdown signal is sent out
-
async-mesos
An asynchronous client for Mesos HTTP scheduler API
-
noosphere-storage
Pluggable backing storage for the Rust Noosphere implementation
-
ockam_transport_uds
Unix Domain Socket (UDS) Transport for the Ockam Routing Protocol
-
holly
A simplistic actor model library using futures
-
misskey-util
High-level API for the misskey-rs library
-
tokio-utils
Tools for asynchronous programming in Tokio applications
-
deadpool-fantoccini
Dead simple async session pool for fantoccini
-
waker-waiter
async runtimes interoperate with arbitrary futures
-
compio-io
IO traits for completion based async IO
-
async-component
Zero overhead reactive programming
-
librdkafka-sys
Native bindings to the librdkafka library
-
aktrs
An actor model framework for Rust
-
specta-jsdoc
Export your Rust types to JSDoc
-
agency
A small async actor framework
-
carrot-cake
An a-peeling pub/sub framework
-
tls-async
TLS support for AsyncRead/AsyncWrite using native-tls
-
aral-runtime-async-std
Aral Runtime for async-std
-
vexide-async
The async executor at the core of vexide
-
bytes-stream
functions to work with stream of bytes
-
workflow-async-trait
Type erasure for async trait methods (customized, see README.md notes)
-
mysql_async_uu
Tokio based asynchronous MySql client library
-
multipart-rs
zero-allocation, streaming, async multipart reader & writer for Rust
-
elfo-dumper
Dumps messages of the elfo system on disk
-
mobc-lapin
RabbitMQ support for the async mobc connection pool
-
switch-resume
Delimited async continuations
-
streaming-platform
Data streaming platform and message broker with concurrent data transfer capabilities
-
lazy-queue
Futures-driven lazy queue processing
-
backstage
A framework for building data-driven distributed systems
-
edge-nal-std
A STD implementation of edge-nal based on
async-io -
future-bool
A bool one can await the changes
-
async-graphql-warp
async-graphql for warp
-
eventbuzz_core
The core submodule of eventbuzz project
-
monolake
High Performance Proxy base on Monoio
-
libp2p-perf
libp2p perf protocol implementation
-
http-lib
High-level, asynchronous API for ureq, a safe HTTP client
-
chokepoint
Generic stream transformer to simulate traffic / network congestion
-
heim-net
Cross-platform network information
-
aredis
Redis client implemented in Rust
-
actix-codec
Codec utilities for working with framed protocols
-
async-zmq-types
Types and traits to create a generic interface over asynchronous zmq implementations
-
fil_actors_runtime_v8
System actors for the Filecoin protocol
-
toy-rpc
An async RPC that mimics golang net/rpc's usage and supports both async-std and tokio
-
manual-executor
Async executor with manual waking
-
seal_rs
Set of classic asynchronous primitives (Actors, Executors, Futures / Promises)
-
tower-sessions-moka-store
Moka session store for
tower-sessions -
memstore
An in-memory implementation of the
async-raft::RaftStoragetrait -
windows-async
async executor for windows application using windows crate
-
uring-fs
Truly asynchronous file operations using io-uring. Supports any async runtime. Linux only.
-
socketioxide-parser-common
Common parser for the socketioxide protocol
-
async-imap-lite
Asynchronous imap
-
switchyard
Real-time compute focused async executor
-
tor-events
A typed event broadcasting framework for Arti
-
scoped_spawn
Full structured concurrency for asynchronous programming
-
rosey-actors
Actor framework
-
logimesh
RPC Microservice 2.0 framework
-
await_macros
Macros that expand to
(expr).await -
actix-storage-dashmap
actix-storage based on dashmap
-
catalyzer-utils
development easier
-
bounded_join_set
A Concurrency-Limited JoinSet for Tokio
-
stream_multiplexer
Combines many streams into a few
-
axum-sessions
🥠 Cookie-based sessions for Axum via async-session
-
lspower
A lightweight framework for implementing LSP servers
-
taskwait
Runtime agnostic way to wait for a group of async tasks
-
volo
high-performance and strong-extensibility Rust RPC framework that helps developers build microservices
-
pin-cursor
!Unpin I/O backend for async-std
-
param
Param-style trait
-
mysql_async_wasi
Tokio based asynchronous MySql client library
-
async-macros
Macros for async-std
-
plctag
wrapper of libplctag, with rust style APIs and useful extensions
-
jackrabbit
Real-time Message Queue
-
framed_aio
allows performing async io operations in a framed manner
-
RobotS
Actor framework
-
irc
usable, async IRC for Rust
-
what-the-async
runtime
-
futures-enum
#[derive(Future, Stream, Sink, AsyncRead, AsyncWrite, AsyncSeek, AsyncBufRead)] for enums
-
socksv5_future
Socks v5 futures for Server and Client
-
build_async
Rust Macros to Unify Synchronous and Asynchronous Codebases
-
arta
Async runtime abstractions library
-
merge-io
Merge two separate
AsyncReadandAsyncWriteobjects into a single I/O stream -
tokio-io-compat
Compatibility wrapper around std io traits that implements tokio io traits
-
smartpoll
A 'Task' abstraction that simplifies polling futures
-
gwyh
sweet gossip library
-
mezzenger-channel
mezzenger transport over futures channels
-
motore-macros
Motore's proc macros
-
heim-runtime
Runtime shims for heim crate
-
spawns-core
Async runtime agnostic thread context task spawner for Rust
-
mfio-rt
mfio based async runtime
-
upc
USB packet channel (UPC): provides a reliable, packet-based transport over USB
-
throttled-reader
An io::Read proxy that limits calls to read()
-
causality
Event Driven Architecture Traits
-
embassy-futures
no-std, no-alloc utilities for working with futures
-
clia-ntex-files-mod
A mod to ntex-files, supporting '.' leading
-
asteroid-mq-sdk
Rust SDK for asteroid-mq
-
tokio-tasker
Lets you stop and join groups of Tokio tasks
-
ws_stream_wasm
A convenience library for using websockets in WASM
-
name_locker
interface for asynchronous name lockers, that can run an async task with lock on a given name
-
repeating_future
[RepeatingFuture] is a [Future] that can call an async function of an object over and over again
-
scambio
Safe and efficient value exchanges between endpoint pairs
-
geese_executor
Asynchronous executor with Geese event system integration
-
zonyitoo/coio
Coroutine scheduler with non-blocking I/O support
-
future_pubsub
A tokio based publish-subscibe channel
-
dmds-tokio-fs
Dmds I/O handler interacts with the filesystem using Tokio
-
relay
A lightweight oneshot Future channel
-
async-watch
Async watch channel
-
core-futures-stateless
Workaround for no_std async-await that doesn't store task contexts
-
absinthe
Are you an Actor & Async junkie? Then your app needs some Absinthe!
-
mio-misc
Miscellaneous components for use with Mio
-
async-transport
Asynchronous transports with ECN information
-
async-ucx
Asynchronous Rust bindings to UCX
-
celery-rs-core
Core utilities for a celery client and worker in rust
-
tower-make
Trait aliases for Services that produce specific types of Responses
-
tangle
Future implementation for Rust
-
async-ready
Async readiness traits
-
eventual
Future & Stream abstraction
-
task-stream
a global task executor, run in
no_std -
stream-map-any
Allows merging async Streams of different output type
-
actix-limitation
Rate limiter using a fixed window counter for arbitrary keys, backed by Redis for Actix Web
-
actor
Actors traits
-
async-stdin
Asynchronously read from stdin
-
pychan
A collection of channels for sending around items of type
pyo3::Py<T> -
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.
-
websocket_toolkit
A WebSocket toolkit for Rust, enabling efficient real-time communication with flexible reconnection and message handling capabilities
-
rupnp
An asynchronous library for finding UPnP control points, performing actions on them and reading their service descriptions
-
generic-api-client
A client for HTTP/HTTPS/WebSocket APIs
-
elfo-logger
Logs events of the elfo system
-
async_buf_reader_utils
Adds additional functionality to the async-std crate for BufReader
-
gloo-timers
Convenience crate for working with JavaScript timers
-
zephyrus-macros
Procedural macros used by Zephyrus
-
jarust_transport
A janus client SDK in Rust
-
mini-telnet
Asynchronous minimal telnet library
-
freestuffapi
Freestuffbot API
-
spawns-executor
Async executors for thread context task spawner
-
poem-grpc
GRPC support for Poem
-
thread-executor
Lightweight futures executor using std::thread::park
-
async-await
Just some macros to emulate the Async and Await :)
-
flo_binding
Declarative binding library for Rust
-
async-executor-trait
executor-trait implementation for async-std
-
async-graphql-rocket
async-graphql for Rocket.rs
-
pulz-executor
Abstractions of some async runtimes
-
sigfinn
Lifecycle manager for spawning tasks
-
compio-dispatcher
Multithreading dispatcher for compio
-
tower-retry
Retry failed requests
-
async-tun
Asynchronous allocation of TUN/TAP devices using async-std
-
futuresdr-remote
Remote interaction library for FutureSDR
-
shutdown-async
Asynchronous Shutdown
-
o5m-stream
streaming async o5m decoder
-
rxqlite-sqlx-common
A distributed sqlite database built upon
openraft,sqlxandsqlite -
skipdb-core
The core for
skipdbandasync-skipdbcrates -
ntex-rt
ntex runtime
-
marzban_api
async client which abstracts/simplifies the interactions with the Marzban panel API (https://github.com/Gozargah/Marzban)
-
async-utils
nothing to see here yet :)
-
gain-lep
Support for exposing Gain APIs via Lep
-
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.
-
nonblocking
stdin crate for Rust
-
drop-awaiter
that allows you to asynchronously wait for something to be dropped
-
libp2p-relay
Communications relaying for libp2p
-
elfo-telemeter
Collects and exposes metrics of the elfo system
-
ratchet_ext
WebSocket extensions for Ratchet
-
peace_item_sh_sync_cmd
Manages a synchronization shell command for the peace framework
-
turbocharger
Autogenerated async RPC bindings that instantly connect a JS frontend to a Rust backend service via WebSockets and WASM
-
intersession-layer-messaging
A metastable messenger that allows reliability between peers when peers go offline, are unreliable, and facing intermittent network conditions between sessions
-
fizyr-rpc
Native Rust implementation of the Fizyr RPC protocol
-
cyper
HTTP client library based on compio and hyper
-
supplicant
Bindings for wpa_supplicant
-
task-executor
A task executor
-
pingora-openssl
OpenSSL async APIs for Pingora
-
nephele
A high performance asynchronous programming runtime for Rust
-
futures-macro-await
Definition of the
await!macro for thefuturescrate -
madsim-tonic
The
tonicsimulator on madsim -
aiur
Single threaded async executor with structured concurrency
-
tokio-non-async
Helpers for dealing with tokio channels in non-async code
-
rspc-tauri
Tauri adapter for rspc
-
netbeam
a pure-rust asynchronous network synchronization crate (using tokio) that recreates familiar asynchronous paradigms but in a network context
-
peace_item_file_download
Manages downloading a file for the peace framework
-
async_io_crypto
handling AsyncRead with ciphering / deciphering
-
redeez
queueing system for Redis
-
tower-async-http
Tower Async middleware and utilities for HTTP clients and servers. An "Async Trait" fork from the original Tower Library
-
tonic-health
Health Checking module of
tonicgRPC implementation -
aio_event
A tokio event like asyncio event in python
-
tokio-dbus-macros
Pure Rust D-Bus implementation for Tokio
-
mio-byte-fifo
Concurrent non-blocking byte SPSC FIFO buffer intended for use in Mio poll
-
flv-future-aio
I/O futures for Fluvio project
-
aldrin-gen
Aldrin code generator
-
tower-sessions-deadpool-sqlite-store
deadpool-sqlite session store for
tower-sessions -
just-watch
Async watch channel
-
twitchchat
interface to the irc-side of twitch's chat system
-
light-magic
A lightweight, fast and easy-to-use implementation of a optionally encrypted/persistent in-memory database
-
async_channel_io
AsyncReadandAsyncWriteimplementations forasync_channel -
nostd_async
An asyncronous runtime for a single-threaded no_std environment
-
nb-sync
Non-blocking synchronization structures for bare-metal environments
-
tower
modular and reusable components for building robust clients and servers
-
ws-lite
Naive websocket server implemented using async / await
-
nodecraft
Crafting seamless node operations for distributed systems, which provides foundational traits for node identification and address resolution
-
tokio-buf
Asynchronous stream of byte buffers
-
yaar
asynchronous runtime optimized around configuration and no_std
-
async-std-test
Alternate implementation of the #[async_std::test] macro
-
tokio-periodic
Cross-platform, mostly-0-cost asynchronous periodic timers
-
d3
A framework for server development
-
constellation-internal
Common components for the
constellationframework -
tower-load-shed
Immediately reject requests if the inner service is not ready. This is also known as load-shedding.
-
ruchei-extra
Stream/Sink wrapper with extra data, as used by ruchei
-
somen
An asynchronous parser combinator
-
task_scheduler
easilty schedule an FnOnce to run in the future
-
mpool
A generic connection pool
-
axum-serveplus
High level server designed to be used with axum framework
-
swiftide-macros
Blazing fast, streaming pipeline library for AI applications
-
rseip-core
core module for rseip
-
liburing
Rust liburing#24bd087 raw bindings with basic tests
-
socketioxide-parser-msgpack
Msgpack parser for the socketioxide protocol
-
cqrs-core
Core types and traits for cqrs
-
async-ioutil
A collection of Rust asynchronous I/O utilities
-
nb-executor
Single-future, #![no_std] executor based on event bitmasks
-
psbus
Generic Publish / Subscribe model for application messaging
-
libp2p-webtransport-websys
WebTransport for libp2p under WASM environment
-
hydro
cooperative green tasks
-
tokio-blocking
A thin wrapper to provide a simple interface to insert blocking operations between non-blocking operations in the context of futures
-
aldrin-broker
Broker library of Aldrin, a message bus for service-oriented RPC and interprocess communication
-
tokio-channel
Channels for asynchronous communication using Tokio
-
logic-mesh
Control logic engine using event based and reactive blocks written in Rust
-
async-bincode
Asynchronous access to a bincode-encoded item stream
-
uasync
fast, safe, async executor
-
awaken
Coalescing cross-thread wakers for mio and io_uring
-
tokio-into-sink
convert a tokio::io::AsyncWrite into a futures::Sink for bytes
-
thespis_impl
Reference implementation for the thespis actor model
-
futures-macro-await-preview
Definition of the
await!macro for thefuturescrate -
feature-extension-for-wasm-bindgen-futures
Feature extension for wasm-bindgen-futures
-
tower-service
Trait representing an asynchronous, request / response based, client or server
-
async-watch2
Async watch channel
-
tokio01-test
Testing utilities for Tokio and futures-based code
-
tokio_safe_block_on
ability to execute async code from a sync context, without blocking a tokio core thread or busy looping the cpu
-
prefect
An embeddable task queue based on SQLite (renamed to effectum)
-
elfo-network
Distributed actors for elfo
-
ratchet_fixture
Ratchet fixture
-
actix-web-async-await
preview of Actix with async/await support
-
misanthropic
An async, ergonomic, client for Anthropic's Messages API
-
actm
Tiny async actors framework for rust
-
diath
light-weight library for communication between tokio async tasks
-
aurora-streams
managing publish-subscribe channels using Tokio message passing channels
-
stream-body
An HttpBody implementation with efficient streaming support for the Rust HTTP library hyper
-
dialectic-tokio-mpsc
A backend for the Dialectic crate using Tokio's MPSC channels
-
ruyi
An event-driven framework for non-blocking, asynchronous I/O in Rust
-
wasm_main_executor
Run futures from web workers on the main browser thread
-
axum-messages
🛎️ One-time notification messages for Axum
-
async-graphql-axum
async-graphql for axum
-
hop
Rust client library for the Api
-
batch
Distributed task queue library based on RabbitMQ
-
fmmap
A flexible and convenient high-level mmap for zero-copy file I/O
-
fieldset
Struct to enum derivation
-
actix-files
Static file serving for Actix Web
-
peace_cmd_rt
Runtime types for commands for the Peace framework
-
springtime
Dependency injection based application bootstrapping and execution crate
-
mercury
The official Rust client for the Mercury Parser
-
rustun
implementing STUN server and client asynchronously
-
libp2p-floodsub
Floodsub protocol for libp2p
-
mlg
An asynchronous Log for Rust
-
mirai
A Futures layer over Mio
-
prodash
A dashboard for visualizing progress of asynchronous and possibly blocking tasks
-
futures-executor-preview
Executors for asynchronous tasks based on the futures-rs library
-
completion-io
Core traits and types for asynchronous completion-based I/O
-
v_rusty_tarantool
Tarantul async client based on tokio framework
-
fmodel-rust
Accelerate development of compositional, safe, and ergonomic applications/information systems by effectively implementing Event Sourcing and CQRS patterns in Rust
-
jarust_interface
A janus client SDK in Rust
-
wombo
managing event loop threads
-
compio-process
Processes for compio
-
asynchronous
Promises Q style , async and event loops
-
pingora
A framework to build fast, reliable and programmable networked systems at Internet scale
-
mwc-libp2p-wasm-ext
Allows passing in an external transport in a WASM environment
-
shuller
Lib to get links to images for your favourite tags on rule34 and any
-
monoio-macros
Monoio proc macros
-
forkable
Fork-able iterators and asynchronous streams
-
task_scope
asynchronous runtime extension for supporting Structured Concurrency with task spawning
-
tower-worker
Tower layers focused on wrapping services with asynchronous worker tasks that may also make requests to the wrapped service
-
tower-http
Tower middleware and utilities for HTTP clients and servers
-
archflow
Create a streamable Zip archive
-
sendfile
wrapper around the sendfile(2) system call
-
rust-freely
An asynchronous wrapper for the WriteFreely/Write.as API
-
digtask
Dig is a YAML-defined, OS-level task orchestrator. It can 'dig into' a specifed task, or 'dig out' a desired output file
-
actix-service
Service trait and combinators for representing asynchronous request/response operations
-
async-graphql-parser
GraphQL query parser for async-graphql
-
async-mongodb-session
An async-session implementation for MongoDB
-
tonic-web
grpc-web protocol translation for tonic services
-
mai
A higher-level mio interface
-
openssh-sftp-protocol
Data format used to communicate with openssh mux server
-
smol-executor-trait
executor-trait implementation for smol
-
armature
An event-driven stateful actor framework for Rust
-
compio-macros
Proc macro of compio
-
tokio-fd
Non-blocking Read and Write a Linux File Descriptor
-
compio-log
Log of compio
-
wakerpool
lightweight object pool for lists of Wakers
-
async-timer-rs
Hashed timer wheel implementation compatible with asynchronous tasks, support async_std/tokio and other futures base framework
-
memberlist
A highly customable, adaptable, async runtime agnostic Gossip protocol which helps manage cluster membership and member failure detection
-
gloo-events
Convenience crate for working with DOM event listeners
-
juggle
Async task switching for cooperative multitasking in single thread environments with no_std support
-
vkteams-bot
VK Teams Bot API client
-
ntex-io
encoding and decoding frames
-
tokio-dbus-xml
Pure Rust D-Bus implementation for Tokio
-
ara
Async random access I/O traits
-
smol-axum
Integrations between
smolandaxum -
fil_actors_runtime_v11
System actors for the Filecoin protocol
-
sfu
WebRTC Selective Forwarding Unit (SFU) in Rust with Sans-IO
-
dialectic-null
A no-op backend for the Dialectic crate, intended for benchmarking and testing
-
tinyio
A tiny Rust concurrency runtime library
-
madsim-etcd-client
The etcd simulator on madsim
-
async-spawner
executor independent task spawner
-
specta-util
High-level utilities for working with Specta
-
extern_executor
Async executor which delegates futures polling to external event-loop
-
see-you-later
Delay and schedule async task
-
libp2p-dcutr
Direct connection upgrade through relay
-
diny
An asynchronous, alloc-free serialization framework
-
nostr-bot
Nostr bot library
-
verypoll
Very polling library
-
futuresdr-frontend
Web Frontend for an Experimental Async SDR Runtime for Heterogeneous Architectures
-
uring
Pure Rust library for io_uring
-
libp2p-uds
Unix domain sockets transport for libp2p
-
pollster-macro
Proc-macro crate for pollster
-
async-graphql-poem
async-graphql for poem
-
openssh-sftp-client-lowlevel
Lowlevel utilities to communicate with openssh sftp server
-
futures-mpsc
A futures aware, bounded, MPSC channel with back pressure support
-
libp2p-core
Core traits and structs of libp2p
-
madsim-tonic-build
Codegen module of
madsim-tonicsimulation implementation -
folo_proc_macros
Internal dependency of the 'folo' crate - do not reference directly
-
tokio-eventfd
Linux eventfd for tokio
-
tarpc-lib
An RPC framework for Rust with a focus on ease of use
-
variable-len-reader
reading/writing variable length data. Support AsyncRead/AsyncWrite in tokio.
-
rh2
An HTTP/2 client and server
-
multitask
An executor for running async tasks
-
holiday_event_api
The Official Holiday and Event API for Rust
-
misskey-core
Core traits and types in misskey-rs
-
async-backtrace
Efficient, logical 'backtraces' of async tasks
-
simcore
A generic discrete-event simulation framework
-
acton-macro
Acton Macro provides procedural macros that simplify the creation of messages and agents in the Acton framework, enabling more concise and expressive code
-
futures-glib
Spawn futures on the glib event loop
-
simple-async
Very simple async runtime for Rust
-
logged-stream
Logging of all read/write operations, errors and drop of underlying IO object
-
openraft-macros
Advanced Raft consensus
-
actix-postgres
PostgreSQL integration for Actix framework
-
netapp
A toolkit library for distributed software
-
libp2p-stream
Generic stream protocols for libp2p
-
peace_value_traits
Trait bounds for value types for the Peace framework
-
emitter-rs
📢 Emitter RS is a lightweight EventEmitter implementation for Rust and Wasm