-
async-std
Async version of the Rust standard library
-
futures
An implementation of futures and streams featuring zero allocations, composability, and iterator-like interfaces
-
tokio
An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications
-
actix
Actor framework for Rust
-
rdkafka
Rust wrapper for librdkafka
-
tokio-rustls
Asynchronous TLS/SSL streams for Tokio using Rustls
-
futures-executor
Executors for asynchronous tasks based on the futures-rs library
-
mio
Lightweight non-blocking IO
-
mlua
High level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) with async/await features and support of writing native lua modules in Rust
-
mobc
A generic connection pool with async/await support
-
tokio-util
Additional utilities for working with Tokio
-
heim
Cross-platform framework for system information
-
redis-async
An asynchronous futures based Redis client for Rust using Tokio
-
rio
GPL-3.0 nice bindings for io_uring. MIT/Apache-2.0 license is available for spacejam’s github sponsors.
-
mio-uds
Unix domain socket bindings for mio
-
tokio-serial
A serial port implementation for tokio
-
async-graphql
A GraphQL server library implemented in Rust
-
fred
A Redis client for Rust built on Futures and Tokio
-
futures-retry
Retry your Futures and Streams!
-
futures_codec
Utilities for encoding and decoding frames using
async/await -
bb8
r2d2, but for async tokio based connections
-
ghost_actor
A simple, ergonomic, idiomatic, macro for generating the boilerplate to use rust futures tasks in a concurrent actor style
-
futures-task
Tools for working with tasks
-
smol
A small and fast async runtime
-
nb
Minimal non-blocking I/O layer
-
async-task
Task abstraction for building executors
-
async-log
Async tracing capabilities for the log crate
-
stream-cancel
A library for interrupting asynchronous streams
-
mio-extras
Extra components for use with Mio
-
futures-intrusive
Futures based on intrusive data structures - for std and no-std environments
-
dataloader
Rust implementation of Facebook’s DataLoader using async-await
-
xtra
A tiny actor framework
-
async_executors
Implements Spawn, SpawnLocal and SpawnHandle for commonly used executors
-
c-ares-resolver
An asynchronous DNS resolver, backed by c-ares
-
futures-locks
Futures-aware lock primitives
-
futures-core
The core traits and types in for the
futureslibrary -
tmq
ZeroMQ bindings for Tokio
-
protobuf_codec
Encoders and decoders for Protocol Buffers based on bytecodec crate
-
async-native-tls
Native TLS using futures
-
multer
An async parser for
multipart/form-datacontent-type in Rust -
cursive-async-view
A loading-screen wrapper for gyscos/cursive views
-
tower-lsp
Language Server Protocol implementation based on Tower
-
next-gen
Safe generators on stable Rust
-
eventsourcing
Event Sourcing for Rust
-
rants
An async NATS client library
-
tari_pubsub
Single publisher with multiple subscribers to topic messages
-
pasts
Minimal and simpler alternative to the futures crate
-
mio-serial
A serial port implementation for mio
-
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.
-
genawaiter
Stackless generators on stable Rust
-
swayipc
A library for controlling sway through its IPC interface
-
blocking
Block on async code or await blocking code
-
acteur
A safe actor system that just works. Simple, robust, fast, documented.
-
celery
Rust implementation of Celery
-
pinky-swear
Futures and async/await-ready Promises
-
unicycle
A scheduler for driving a large number of futures
-
futures-signals
Zero cost FRP signals using the futures crate
-
pharos
Observer pattern which generates a futures 0.3 stream of events
-
background-jobs
Background Jobs implemented with actix and futures
-
etcd-rs
etcd client for rust
-
tbot
Make cool Telegram bots with Rust easily
-
streamline
Reversible futures::Stream-based state machines
-
event-listener
Notify async tasks or threads
-
async_msp_cli
Async msp cli for iNav and BetaFlight
-
tokio-pg-mapper
Proc-macro library used to map a tokio-postgres row to a Rust type (struct)
-
libzmq
A strict subset of ØMQ with a high level API
-
synchronized-writer
A tiny implement for synchronously writing data
-
tower-ready-cache
Caches a set of services
-
etcd-client
An etcd v3 API client
-
streamunordered
An efficient async stream multiplexer
-
maybe-async
A procedure macro to unify SYNC and ASYNC implementation
-
reool
An asynchrounous connection pool for Redis based on tokio and redis-rs
-
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. -
async-graphql-actix-web
async-graphql for actix-web
-
rxrust
A Rust implementation of Reactive Extensions
-
domain-resolv
An asynchronous DNS stub resolver
-
stream_throttle
Provides a Stream combinator, to limit the rate at which items are produced
-
cb_fut
Call function that return value via callback without a callback
-
messagebird-async
Wrapper around the message bird SMS API
-
heim-process
Cross-platform processes information
-
async-scoped
Spawn scoped (non ’static) asynchronous futures using async_std runtime
-
smol-potat
Proc macro for smol runtime
-
scoped_spawn
Full structured concurrency for asynchronous programming
-
async-mq
Zero-cost async-await abstraction of lapin AMQP client crate
-
panda
An async Rust library for Discord
-
pcap-async
Async/Stream Extensions for libpcap
-
packet-ipc
Share packets between services using servo ipc
-
riker
Easily build fast, highly concurrent and resilient applications. An Actor Framework for Rust.
-
thin_main_loop
Thin, cross-platform, main event loop. A building block for native GUI applications, among other use cases.
-
keycloak
Keycloak Admin REST API
-
quicksink
Create a Sink from some value and a closure returning a Future
-
conch-runtime
A library for evaluating/executing programs written in the shell programming language
-
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)…
-
async-tls
Asynchronous TLS/SSL streams using Rustls
-
futures-rate
This library provides easy tools to help Rust applications guide critical resources or code paths from being overwhelmed
-
fibers
A Rust library to execute a number of lightweight asynchronous tasks (a.k.a, fibers) based on futures and mio
-
async_logger
Asyncronous logger allows writing arbitrary slices to a memory buffer, which then processed by a writer in it’s own thread
-
sidekiq
Rust Sidekiq Client
-
vampirc-io
A library for asynchronous, non-blocking, UCI protocol–based communication between chess UIs and chess engines
-
triggered
Triggers for one time events between tasks and threads
-
again
wasm-compatible retry util for std library futures
-
thruster-async-await
An async await shim for the thruster web framework
-
backoff-futures
A retry and backoff mechanism for
std::future::Future -
automate
An asynchronous library to interact with Discord API and make bots
-
futures-await-await-macro
Definition of the
await!macro for thefutures-awaitcrate -
stream-body
An HttpBody implementation with efficient streaming support for the Rust HTTP library hyper
-
async-sse
Async Server Sent Event parser and encoder
-
nakadi-types
A connector for the Nakadi Event Broker
-
tokio-zmq
Provides Futures abstractions for ZeroMQ on the Tokio event-loop
-
extern_executor
Async executor which delegates futures polling to external event-loop
-
iou
io_uring bindings
-
dbus-async
Asynchronous DBus library
-
stund
An SSH tunnel maintenance daemon
-
stream_router
A Future aware router to dynamically route between Streams and Sinks
-
actori
Actor framework for Rust
-
data-buffer
A simple low-level data buffer type useful for IO and in homogeneous collections
-
wikidot-normalize
Simple library to provide Wikidot-compatible string normalization
-
pwner
Pwner is a Process Owner crate that allows ergonomic access to child processes
-
deadpool-redis
Dead simple async pool for redis
-
async-change-tracker
reactive change notifications using futures
-
want
Detect when another Future wants a result
-
tokio-lxi
LXI protocol abstractions for Tokio
-
ert
A combinator to control future execution order
-
async-ctrlc
Async wrapper of
ctrlc -
capnp-futures
async serialization for Cap’n Proto messages
-
named-binary-tag
Format is used by minecraft for the various files in which it saves data
-
ardop_interface
Interface to the Amateur Radio Digital Open Protocol (ARDOP)
-
monzo-lib
async Monzo client in pure rust
-
reqchan
This is a 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…
-
tokio-lk
Futures-aware lock-by-id primitives
-
erkpht-tower
Tower is a library of modular and reusable components for building robust clients and servers
-
webhdfs
Hadoop WebHDFS client library
-
cqrs-es
A lightweight, opinionated CQRS and event sourcing framework targetting serverless architectures
-
tg_botapi
Telegram Bot Api library
-
beeswax
An easy to use CRUD client for the Beeswax API
-
background-jobs-core
Core types for implementing an asynchronous jobs processor
-
wait-for-me
Async CountDownLatch
-
seq_io
Fast FASTA and FASTQ readers
-
async-codec
Utilities for creating async codecs
-
tokio-async-std
An async-std that can fit into tokio ecosystem straight ahead
-
one-of-futures
Future-aware Either-like type with multiple variants
-
leaves
Distributed ID Allocator
-
persway
Sway IPC daemon
-
async-socks5
An async/.await SOCKS5 implementation
-
extreme
Extremely boring async function runner. MIT/Apache-2.0 license is available for spacejam’s github sponsors.
-
mio-timerfd
mio support for linux’s timerfd
-
double-checked-cell-async
A thread-safe lazily initialized cell using double-checked locking
-
bb8-bolt
A bolt-client adaptor for the bb8 connection pool
-
async-trait-ext
a procedural macro for async traits
-
iobuffer
A simple memory-based buffer for IO reading and writing
-
kompact
Kompact is a Rust implementation of the Kompics component model combined with the Actor model
-
vmap
Cross-platform library for fast and safe memory-mapped IO
-
promising-future
Implementation of Promise/Future pairs
-
nbchan
Highly optimized non-blocking communication channels
-
torut
torut is reasonable tor controller written in rust utilizing tokio for async communication
-
stream-map-any
Allows merging async Streams of different output type
-
cqrs-core
Core types and traits for cqrs
-
revent
Event system for Rust
-
actix-raft
An implementation of the Raft distributed consensus protocol using the Actix actor framework
-
luis_sys
FFI bindings for Microsoft LUIS API
-
linemux
A library providing asynchronous, multiplexed tailing for (namely log) files
-
paypal-rs
A library that wraps the paypal api asynchronously
-
heim-cpu
Cross-platform CPU information
-
mobc-redis
Redis support for the mobc connection pool
-
demux-stream
(De)multiplexing for Rust’s streams
-
tokio-serde-cbor
Integration of serde_cbor into tokio-io, to allow sending CBOR encoded frames across network (and possibly through other transports)
-
lelet
golang like task executor
-
aktrs
An actor model framework for Rust
-
fastcgi-client
Fastcgi client implemented for Rust
-
tokio_safe_block_on
Provides the ability to execute async code from a sync context, without blocking a tokio core thread or busy looping the cpu
-
noob
A WIP futures-based Discord bot library
-
mio-signals
Crate for handling signals with Mio
-
poolparty
Added functionality for the
futures::executor::ThreadPoolfutures executor -
heim-runtime
Runtime shims for heim crate
-
etcdv3client
a simple etcdv3 client
-
frappe
Functional Reactive Programming library for Rust
-
ex-futures
An extension of
futures -
tokio-native-tls
An implementation of TLS/SSL streams for Tokio using native-tls giving an implementation of TLS for nonblocking I/O streams
-
eventually-postgres
Event Store implementation using PostgreSQL for the Eventually crate
-
futures-async-stream
Async stream for Rust and the futures crate
-
tokio-test
Testing utilities for Tokio- and futures-based code
-
stream-flatten-iters
Flattens a stream of iterators into one continuous stream
-
tokio-diesel
Integrate Diesel into Tokio cleanly and efficiently
-
tokio-file
Asynchronous file I/O for Tokio
-
signals
A functional-reactive-like library for Rust that allows asynchronous chaining
-
mioco
Scalable, asynchronous IO coroutine-based handling (aka MIO COroutines)
-
stl_io
STL input and output
-
async-minecraft-ping
An async Rust client for the Minecraft ServerListPing protocol
-
ipc-orchestrator
Orchestion of command line processes for local dev usage with IPC communication
-
tang-rs
A light weight asynchronous connection pool
-
signald-rust
A library to interface with Signald
-
futures-delay-queue
Async delay queue backed by async-std and futures-timer
-
tokio-pipe
Asynchronous pipe(2) library using tokio
-
tokio-dns-unofficial
Unofficial extension to tokio to provide asynchronous DNS resolution
-
dkregistry
A pure-Rust asynchronous library for Docker Registry API
-
requiem
Actor framework for Rust
-
message_plugins
A Message-Passing Oriented backbone for Rust plugins to Rust programs
-
restartables
Future that restarts an inner future if it doesn’t meet a condition
-
futures-mockstream
Minimal mockstream which implements futures async traits
-
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.
-
async_zmq
Async version for ZeroMQ bindings
-
futurify
Convert your sync functions into non-blocking thread futures
-
actix-daemon-utils
Daemon Utilities by actix
-
thetvdb
TheTVDB API async client
-
side-futures
Send future for execution on the runtime that may be in a different thread
-
webex
Interface to Webex Teams REST and WebSocket APIs
-
implicit-await
Implicitly await calls returning Future impls
-
stage
An ergonomic, composable Actor Model, designed for painless concurrency
-
tokio-compat
Compatibility between
tokio0.2 and legacy versions -
amy
Polling and Registration abstractions around kqueue and epoll for multithreaded async network programming
-
fastlog
A high performance asynchronous logger
-
skyblock-rs
A simple library to interact with Hypixel’s Skyblock API
-
actors-macros
Macro crate for Riker actor framework
-
poller
File I/O events library for Rust
-
visiting_ref
Container types that asynchronously return ownership of a value to another context upon exiting scope
-
async-graphql-warp
async-graphql for warp
-
rustracts
Rust crate for cancellable time based contracts in async/await
-
epoxy_frp
The Reactive Glue for Frontend Applications
-
nbd-async
Block device drivers in userspace
-
component-future
implements the inner future protocol documented in the tokio docs
-
futuristic
Extensions to the futures crate
-
linked-futures
Link futures into a block, which stops all of the included futures when any of the futures complete
-
stakker
A lightweight low-level single-threaded actor runtime
-
yaar-reactor
Non-blocking IO abstractions for building executors
-
core-futures-tls
A libcore wrapper allowing async/await to be used from no_std crates
-
rmp-futures
Async Rust MessagePack and MessagePack-RPC
-
stream_multiplexer
Combines many streams into a few
-
rustun
A library for implementing STUN server and client asynchronously
-
rlua-async
Async support for rlua, via coroutines
-
c3p0_common_async
A good friend for r2d2
-
sync-async-runner
Run async functions synchronously (like coroutines)
-
stakker_mio
Mio I/O polling integration for the Stakker crate
-
futures-locks-pre
Futures-aware lock primitives. Fork using tokio 0.2.6.
-
must_future
A wrapper future marked must_use - mainly to wrap BoxFutures
-
tokio-stdin-stdout
Thread- and future::sync::mpsc-based AsyncRead/AsyncWrite stdin/stdout with little buffering
-
futures-race
A way to poll two futures and get the output of the first one to complete
-
futures-jsonrpc
Futures implementation for JSON-RPC
-
async-await
Just some macros to emulate the Async and Await :)
-
async-thread
Futures version of std::thread
-
async-pipe
Creates an asynchronous piped reader and writer pair using tokio.rs
-
ws_stream_tungstenite
Provide AsyncRead/AsyncWrite over Tungstenite WebSockets
-
railgun
A Discord API library written in Rust supporting native async/await
-
ipify-async
A simple asynchronous library for obtaining your public IP
-
async_ctx
Asynchronous contexts
-
lib3h_zombie_actor
lib3h actor request tracking module
-
thunks
Asynchronous composer for Rust
-
eventific
Eventific is a tool that gives you the needed building blocks for event sourcing
-
cute-async
Cute async utilities
-
callback-future
Adapter between callbacks and futures
-
zeebest
An unofficial zeebe client for the future!
-
local-pool-with-id
A minor variation on a LocalPool executor which exposes unique IDs for tracking future completion
-
broadcast
A rustlang adapter for writing to multiple sources
-
mpool
A generic connection pool
-
futures-option
Extension traits for dealing with optional futures and streams
-
raii-counter-futures
RAII Counter that allows you to wait for a count of zero asynchronously
-
tk-listen
A set of helper futures allowing to listen TCP (or unix) socket with resource limits and proper error handling
-
rustmann
Rust/Tokio client for Riemann
-
dapr-derive
Dapr SDK for Rust
-
futures-async-combinators
toy futures combinators
-
strawpoll
A wrapper to avoid spurious polling
-
see-you-later
Delay and schedule async task
-
bawawa
Opinionated set of tools to manage and compose process executions
-
redis-asio
Asynchronous Redis driver based on tokio
-
zomato
A simple crate for retrievig daily menu from zomato.com
-
reverse_io
A wrapper type allowing the reversing of std::io::{Read, Write, Seek}
-
syncthing
A Rust library for controlling syncthing file synchronization through its REST interface
-
intervalier
Interval events with handling notifications
-
lazy-queue
Futures-driven lazy queue processing
-
actix-interop
Use async/await syntax with actix actors
-
smelling_salts
Start a thread to wake an async executor when the OS’s I/O event notifier discovers that the hardware is ready
-
gabelung
Branch an asynchronous stream of cloneable items into two
-
libaio-futures
Straightforward Linux AIO using Futures/async/await
-
kyansel
Cancellable future. Provide a future as argument and the current future will cancel if the provided future resolves first
-
blocking-permit
Permits and a thread pool for blocking operations
-
ferris-extensions
Extension macros for Rust
-
proq
Idiomatic Async Prometheus Query (PromQL) Client for Rust
-
shiori_hglobal
impl str for HGLOBAL{…}
-
futures-cputask
Turn synchronous CPU-bound tasks into futures
-
futures-net
The futures-net library
-
io-synesthesist
ffi library of write(2) and lseek(2)/read(2)
-
deferred
Rust crate to help perform deferred execution of code logic
-
futures-util-io-peek
AsyncPeek trait
-
async-lease
Essentially a futures-oriented Arc<Mutex<Option>>
-
async-dup
Duplicate an async I/O handle
-
positioned-io
Reading and writing at an offset
-
deepwell
Database management and migrations service
-
manual_future
A future that must be manually completed, similar to Java’s CompletableFuture
-
dbus-async-derive
Handler trait derive macro for dbus-async
-
gidle_future
A future executor for the glib main loop idle time
-
back-to-the-future
Conversions between std::future::Future and futures::Future
-
tranquility
A Rust library for the Reddit API
-
mio-st
Single threaded, lightweight non-blocking IO
-
futures-async-runtime-preview
Runtime for the async/await macros in the
futurescrate -
tokio-file-unix
Asynchronous support for epollable files via Tokio on Unix-like platforms
-
futures-enum
#[derive(Future, Stream, Sink, AsyncRead, AsyncWrite, AsyncSeek, AsyncBufRead)] for enums
-
pollster
A minimal async executor that lets you block on a future
-
tower-buffer
Buffer requests before dispatching to a
Service -
spaad
Zero boilerplate actor systems with xtra
-
waitlist
Keep track of an ordered list of Wakers to wake
-
lua_actor
Lua Actor for Rust(sync/async)
-
tokio-pg-mapper-derive
Proc-macro library used to map a tokio-postgres row to a Rust type (struct)
-
handlers
A macro for generating systems of event handlers
-
tokio-beanstalkd
Asynchronous client library for interacting with Beanstalkd work queue
-
async-ready
Async readiness traits
-
lsp-codec
Simple Tokio 0.1-based Codec implementation for Language Server Protocol
-
capella
An asynchronous StatsD clone
-
instrumented-mpsc
Wrapper for futures mpsc unbounded providing Prometheus metrics
-
deadpool-lapin
Dead simple async pool for lapin
-
heim-host
Cross-platform host information
-
bitreader_async
A reader that extends BufReader to allow per bit reads asynchronously
-
tokio-either
Either for Tokio
-
ruyi
An event-driven framework for non-blocking, asynchronous I/O in Rust
-
stream-reduce
Fold a stream without an initial value
-
tokio-retry
Extensible, asynchronous retry behaviours for futures/tokio
-
bottle
Actor model framework for Rust
-
crate-index
A small library for managing a Cargo crate index
-
brawlhalla
An async Brawlhalla API Wrapper using tokio
-
actori-testing
Actori testing utils
-
celery-rs-core
Core utilities for a celery client and worker in rust
-
tokio-signal
An implementation of an asynchronous Unix signal handling backed futures
-
relay
A lightweight oneshot Future channel
-
gain-lep
Support for exposing Gain APIs via Lep
-
remem
Thread-safe object reuse
-
hl7-mllp-codec
A Tokio codec for HL7 Minimal Lower Layer Message Transport protocol (MLLP)
-
settimeout
Creates a std::future::Future implementation to be ready at some point
-
srmw
Asynchronous single-reader, multi-writer
-
future-by-example
Examples of common patterns using Future
-
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. -
num_stream
Rust crate that provides a Stream that yields incrementing numbers at a specified interval
-
mio-pipe
Crate for using Unix pipes with Mio
-
tangle
Future implementation for Rust
-
retrio
Wrapper around readers and writers to retry on errors of kind Interrupted
-
tokio-postponable-delay
A tokio Delay that can be pushed back without instantiating new delays
-
rados_hi
Opinionated high-level wrapper for librados (Ceph)
-
wolfram_alpha
A library providing Rust bindings for the Wolfram|Alpha API
-
tempest-source-redis
Tempest source implementation for Redis Streams
-
tokio01-test
Testing utilities for Tokio and futures-based code
-
tls-async
TLS support for AsyncRead/AsyncWrite using native-tls
-
quickcheck_async
Runtime-agnostic attribute macros to use quickcheck with async tests
-
futures-stream-select-all
A futures library adapter for merging the output of several streams
-
waitout
Awaits the completion of multiple async tasks
-
genawaiter-macro
Convenience macros for generators (genawaiter)
-
async-io
Async I/O and timers
-
stream_generator
Allows to easily generate streams with async/await
-
tokio-uds-proto
Unix Domain sockets working with tokio-proto
-
gen-stream
Generator-based streams for Rust and futures 0.3
-
mai
A higher-level mio interface
-
parity-runtime
Tokio runtime wrapper
-
tokio-ctrlc-error
Easy handling of keyboard interrupts with tokio
-
tokio-rpc
An RPC framework for Rust base on tokio
-
future-bus
Futures based SPMC channel (bus)
-
greenthread-future
Convert closures to futures based on greenthread on bare-metal (no_std + no_alloc)
-
async-datagram
Async datagram traits
-
plumbum
Conduit-like data processing library
-
await_macros
Macros that expand to
(expr).await -
futures_cbor_codec
A codec for framing an AsyncRead/AsyncWrite with cbor for all types that are serializable with serde
-
gio-2-0-sys
Import crate for Gio
-
scambio
Safe and efficient value exchanges between endpoint pairs
-
eventum
Asynchronous I/O Event manager
-
rust_transit
A broker-agnostic asynchronous event library
-
async_buf_reader_utils
Adds additional functionality to the async-std crate for BufReader
-
strife
A lightweight library for the Discord API
-
promises
Effective, simple, lightweight Javascript promises in Rust
-
futures-cache
Futures-aware cache backed by sled
-
stream-combinators
Additional stream combinators for
futures-rsstreams -
cancellable-timer
A timer that can be interrupted
-
tokio-macros
Tokio’s proc macros
-
bitstream
Bit level IO
-
mio-pidfd
mio support for Linux’s pidfd
-
tokio-qapi
QEMU QMP and Guest Agent API tokio adapter
-
nb-sync
Non-blocking synchronization structures for bare-metal environments
-
rsevents-extra
Useful events built on top of rsevents. Includes countdown event.
-
futures-fs
A Futures implementation for File System operations
-
librdkafka-sys
Native bindings to the librdkafka library
-
mdo-future
Zero-cost futures support for rust-mdo
-
puddle
A simple object pool implementation that uses asynchronous synchronization primitives only
-
alligator
Alligator is for getting the output value from a future
-
tokio-pty-process-stream
wraps tokio-pty-process in order to provide a simpler API as a single stream object
-
async-coap
A flexible, asynchronous library for using and serving CoAP resources. Experimental.
-
futures-prio
Combinator to set priority of Futures
-
sgx_core_futures
Rust SGX SDK provides the ability to write Intel SGX applications in Rust Programming Language
-
shs_async
Secret-handshake protocol (async)
-
conio
Console input and output
-
tokio_kcp
A kcp implementation for tokio
-
tokio-lock
Access an object from a single Tokio task
-
async-diesel
Integrate Diesel into async-std cleanly and efficiently
-
async-graphql-parser
GraphQL query parser for async-graphql
-
runtime-loop
Runtime loop for Rust
-
weighted-select
futures::stream::Select with weights
-
futures_future
The Rust crate that converts the old style futures crate
futures::Futureinto the new nightly async/await stylestd::future::Futureso you can easily try out the new syntax -
futures-shim
An adapter for futures-unaware components
-
deadqueue
Dead simple async queue
-
future-utils
Extensions to Rust’s Future and Stream traits
-
primal-tokio
An interface to primal using tokio’s streams. This allows the worker to stop once the receiver is dropped, for example.
-
ostrich-core
Main utils for the ostrich project
-
eventsourcing-derive
Custom derive macros for Eventsourcing components
-
mimo
Asynchronous backup
-
futures_retrying
Runtime agnostic retry for futures
-
libpool
A simple threadpool from The Rust Programming Language
-
packattack
A parser-combinator library for writing concise and safe binary parsers
-
tokio-kinetic
Kinetic protocol client library built on tokio-rs
-
futures-stream-select-all-send
A futures library adapter for merging the output of several streams
-
async-attributes
Experimental language-level polyfills for Async Rust
-
rair-io
IO subsystem for RAIR
-
riker-default
Riker’s default Model and modules providing core services
-
valuable_futures
Utils which allow writing futures::Future and futures::Stream by-value
-
direct-executor
An executor that directly executes futures, suitable for embedded environments
-
fg-uds
Asynchronous unix domain socket running on the futures-glib main loop
-
handy_async
A handy library for describing asynchronous code declaratively
-
futures-error-chain
A workaround until futures-rs and error-chain crates works out-of-box with each other
-
simpleio
A simple crate for file io that i use in my personal projects
-
futures-shuttle
Futures-aware shuttle synchronization object
-
eternal-macro
The Eternal Framework
-
reducer
A predictable reactive framework for Rust apps
-
mirai
A Futures layer over Mio
-
async_msp_lib
Async msp library for iNav and BetaFlight
-
futures-rustls
Asynchronous TLS/SSL streams for Future using Rustls
-
queen-io
I/O library for Rust
-
io-block
Work with block devices and other block-like things in rust
-
rotor-tools
Various utility things for comfortable writing of application and protocols using rotor library
-
fs
A Futures implementation for File System operations
-
socksv5_future
Socks v5 futures for Server and Client
-
heim-net
Cross-platform network information
-
mdrv
Modular driver based on Mio for managing multiple connections over different protocols
-
futures-log
A simple logging wrapper around
futures-rsFutures andStreams -
dapr
Dapr SDK for Rust
-
ur20
Rust library for the Weidmüller u-remote IP20 system
-
yaar
Yet another asynchronous runtime optimized around configuration and no_std
-
adventure
Helps your great adventure for the various type of requests
-
async-trait
Type erasure for async trait methods
-
futures-zmq
Provides Futures abstractions for ZeroMQ on any futures executor
-
fumio-utils
utils for fumio crates
-
backtalk
An asynchronous, streaming web server for JSON APIs
-
kompact-component-derive
A derive macro for Kompact component definitions
-
gw2rs
A Rust library for the Guild Wars 2 API
-
lz_shared_udp
Functionality for a shared UDP socket
-
naja_async_runtime
A lightweight universal runtime for futures
-
tokio-utun
Utun bindings for Tokio
-
futures-bufio
Buffered IO with futures on top of a threadpool for blocking IO
-
futures-cputask-derive
Internal crate to provide the async_task macro for futures-cputask
-
tokio-i2c
I²C API for Tokio
-
future_pubsub
A tokio based publish-subscibe channel
-
tk-pool
Generic connection pool for tokio
-
tio
Yet another async io solution
-
mio-utun
Utun bindings for mio
-
threader
A performant multithreaded future executor and event loop
-
starstruck
A game building utility that is made to be simple to use while still providing great performance
-
momentum
A simple wrapper for the Momentum API
-
rotary-encoder
Interpret rotary encoder signals as rotation direction
-
tokio-scoped
Scoped Runtime for tokio
-
tokio-terminal-resize
a stream of terminal resize events
-
stund_protocol
The client/server protocol used by the “stund” program
-
event_rust
Lightweight non-blocking IO support windows and linux
-
dumb-exec
A very simple and dumb implementation of a futures executor that doesn’t allocate and can be used in no_std environments
-
recon-link
Persistent tcp connections
-
async-stm32f1xx
Abstractions for asynchronous programming on the STM32F1xx family of microcontrollers
-
nsq-client
Rust client for the NSQ realtime message processing system
-
slacker
Slacker server built on top of tokio
-
wombo
Utilities for managing event loop threads
-
faktory
API bindings for the language-agnostic Faktory work server
-
notice-core
Traits and some implementations for notify/wait pattern
-
smol-timeout
A way to poll a future until it or a ‘smol::Timer’ completes
-
futures-black-hole
Black hole implementation for futures
-
pseudo-async-io
Simple (pseudo-) async wrappers around Read and Write
-
tower
Tower is a library of modular and reusable components for building robust clients and servers
-
tokio-async-io
Port of the
smol::Asyncto tokio 0.2 -
futures-checkout
A library for mediating full ownership of a single object across multiple futures
-
task-compat
Utility crate to compat futures 0.1 and futures 0.3 tasks
-
enum_future
A simple macro for creating
Future-implementing enums containing futures -
futures-await-async-macro
Definition of the
#[async]macro for thefutures-awaitcrate as well as a few other assorted macros -
async-local-bounded-channel
A same-producer, same-consumer bounded channel, for a single async task
-
asyncnsq
async client for nsq
-
actix_derive
Actor framework for Rust
-
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.)
-
riker-macros
Macro crate for Riker actor framework
-
tokio-cache
Non-blocking caches that can be used with Tokio
-
batch
Distributed task queue library based on RabbitMQ
-
tokio-reactor
Event loop that drives Tokio I/O resources
-
futures-diagnose
Wraps around a Spawn and provides lots of diagnostics
-
redis_tang
A light weight asynchronous connection pool for redis-rs
-
fluss
Stream processing framework
-
event_dispatcher
A simple library to register listeners (with priority) for specific events inspired by rust-emitter
-
stop-handle
Convinient structure to terminate future execution
-
futures-after
A stream combinator that buffers a number of elements before yielding them
-
streamify
Conversions from values to Stream
-
implicit-await-macro
#[implicit_await] procedural macro implementation
-
deepwell-core
Database management and migrations service
-
tokio-resource-pool
A generic resource pool for the Tokio ecosystem
-
filebuffer
Fast and simple file reading
-
gj
Event loop and promises
-
netdb
Access to network-related name databases
-
alzheimer
Async implementation of brainfuck interpreter
-
tokio-shared-udp-socket
Easily share a UDP socket between different futures in tokio
-
mio-byte-fifo
Concurrent non-blocking byte SPSC FIFO buffer intended for use in Mio poll
-
tokio-mqttc
A mqttc client based on tokio-rs, this is still early stage prototoy
-
tower-balance
Balance load across a set of uniform services
-
mpart-async
Asynchronous (Futures-Base) Multipart Requests for Rust
-
fourche
A simple task queue named after a lion with forked tail (queue fourché), works with Redis
-
rust_transit_kafka
Kafka support for rust_transit
-
and-then2
An alternative to a traditional
Future::and_thencombinator -
xactor
Xactor is a rust actors framework based on async-std
-
futures-await-test-macro-preview
Helper crate for futures-await-test-preview
-
async-graphql-tide
async-graphql for tide
-
async_io_stream
IntoAsyncRead on steriods
-
async-http-client
Asynchronous HTTP client
-
async-macros
Macros for async-std
-
lazy_async_pool
An asyncronous object pool that generates objects on the fly
-
futures-backoff
Asynchronous retry strategies for futures
-
hydro
cooperative green tasks
-
heim-memory
Cross-platform memory information
-
tokio-async-attributes
tokio-async-std’s proc macros
-
futures-net-macro
The futures-net library
-
kompact-actor-derive
A derive macro for Kompact Actors
-
async-slot
An asynchronous (futures-based) channel that only preserves last value sent
-
gjio
Asynchronous input and output
-
sendfile
Sendfile is a wrapper around the sendfile(2) system call
-
multitask
An executor for running async tasks
-
tempest
Realtime message handling framework inspired by Apache Storm and built with Actix
-
async-spawn
Asynchronous spawn
-
duplexify
Combine a reader + writer into a duplex of Read + Write
-
boomerang
Rust implementation of “Reactors” Deterministic Actor Model
-
heim-disk
Cross-platform disk information
-
async-zmq-types
Types and traits to create a generic interface over asynchronous zmq implementations
-
runtime-attributes
Proc Macro attributes for the Runtime crate
-
fumio-reactor
a std futures IO reactor
-
associated-async-io
Async IO traits that use futures instead of poll
-
rotor-dns
Asynchronous DNS resolver for rotor framework
-
futures-async-runtime
Runtime for the async/await macros in the
futurescrate -
tower-retry
Retry failed requests
-
genawaiter-proc-macro
procedural macro for generators (genawaiter)
-
futures-glib
Spawn futures on the glib event loop
-
futures-await-test-macro
Helper crate for futures-await-test
-
tk-bufstream
A buffered stream backed by contiguous buffers (netbuf) for tokio
-
handy_io
A handy pattern and futures based asynchronous I/O library
-
async-graphql-derive
Macros for async-graphql
-
actix-async-await
Experimental async/await support for Actix
-
tower-timeout
Apply a timeout to requests, ensuring completion within a fixed time duration
-
async-option
Essentially an asynchronous Async<Mutex<Option>>
-
holly
A simplistic actor model library using futures
-
tokio-buf
Asynchronous stream of byte buffers
-
hyper_lua_actor
Binding of lua_actor & hyper
-
futures-dagtask
DAG-based Task Queue
-
tk-easyloop
A thread local loop and other loop helpers
-
futures-await
Async/await syntax for Rust through a procedural macro. This crate defines the
#[async]macro for functions, theawait!macro for function bodies, and intends to be used with thefuturescrate on crates.io as well. -
futures-io
The
AsyncRead,AsyncWrite,AsyncSeek, andAsyncBufReadtraits for the futures-rs library -
heim-sensors
Cross-platform sensors information
-
tokio-udp
UDP bindings for tokio
-
runtime-raw
Traits to implement custom Runtimes
-
tokio-redis-pool
A Redis connection pool for the Tokio ecosystem
-
rust_transit_rabbit
RabbitMQ support for rust_transit