Lib.rs

tokio

An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications

actix

Actor framework for Rust

async-std

Async version of the Rust standard library

futures

An implementation of futures and streams featuring zero allocations, composability, and iterator-like interfaces

rdkafka

Rust wrapper for librdkafka

mio

Lightweight non-blocking IO

fibers

A Rust library to execute a number of lightweight asynchronous tasks (a.k.a, fibers) based on futures and mio

tokio-rustls

Asynchronous TLS/SSL streams for Tokio using Rustls

futures-executor

Executors for asynchronous tasks based on the futures-rs library

stream-cancel

A library for interrupting asynchronous streams

tokio-fs

Filesystem API for Tokio

mio-serial

A serial port implementation for mio

redis-async

An asynchronous futures based Redis client for Rust using Tokio

mio-extras

Extra components for use with Mio

rio

GPL-3.0 nice bindings for io_uring. MIT/Apache-2.0 license is available for spacejam’s github sponsors.

fred

A Redis client for Rust built on Futures and Tokio

tokio-codec

Utilities for encoding and decoding frames

heim

Cross-platform framework for system information

mobc

A generic connection pool with async/await support

futures-intrusive

Futures based on intrusive data structures - for std and no-std environments

nb

Minimal non-blocking I/O layer

futures-retry

Retry your Futures and Streams!

telegram-bot

A library for creating Telegram bots

async-tls

Asynchronous TLS/SSL streams using Rustls

pharos

Observer pattern which generates a futures 0.3 stream of events

riker

Easily build fast, highly concurrent and resilient applications. An Actor Framework for Rust.

futures_codec

Utilities for encoding and decoding frames using async/await

mio-uds

Unix domain socket bindings for mio

futures-task

Tools for working with tasks

protobuf_codec

Encoders and decoders for Protocol Buffers based on bytecodec crate

dataloader

Rust implementation of Facebook’s DataLoader using async-await

async-log

Async tracing capabilities for the log crate

async-native-tls

Native TLS using futures

async-graphql

The GraphQL server library implemented by rust

tokio-signal

An implementation of an asynchronous Unix signal handling backed futures

cursive-async-view

A loading-screen wrapper for gyscos/cursive views

c-ares-resolver

An asynchronous DNS resolver, backed by c-ares

async-task

Task abstraction for building executors

futures-locks

Futures-aware lock primitives

futures-core

The core traits and types in for the futures library

tokio-serial

A serial port implementation for tokio

eventsourcing

Event Sourcing for Rust

tokio-zmq

Provides Futures abstractions for ZeroMQ on the Tokio event-loop

futures-signals

Zero cost FRP signals using the futures crate

bb8

r2d2, but for async tokio based connections

tower-ready-cache

Caches a set of services

xtra

A tiny actor framework

next-gen

Safe generators on stable Rust

tower-lsp

Language Server Protocol implementation based on Tower

etcd-rs

etcd client for rust

celery

Rust implementation of Celery

synchronized-writer

A tiny implement for synchronously writing data

tokio-dns-unofficial

Unofficial extension to tokio to provide asynchronous DNS resolution

tbot

Make cool Telegram bots with Rust easily

tokio-stdin-stdout

Thread- and future::sync::mpsc-based AsyncRead/AsyncWrite stdin/stdout with little buffering

actori

Actor framework for Rust

futures-async-stream

Async stream for Rust and the futures crate

thin_main_loop

Thin, cross-platform, main event loop. A building block for native GUI applications, among other use cases.

streamunordered

An efficient async stream multiplexer

async-codec

Utilities for creating async codecs

genawaiter

Stackless generators on stable Rust

async_executors

Implements Spawn, SpawnLocal and SpawnHandle for commonly used executors

tokio-pg-mapper

Proc-macro library used to map a tokio-postgres row to a Rust type (struct)

reool

An asynchrounous connection pool for Redis based on tokio and redis-rs

swayipc

A library for controlling sway through its IPC interface

background-jobs-core

Core types for implementing an asynchronous jobs processor

messagebird-async

Wrapper around the message bird SMS API

pinky-swear

Futures and async/await-ready Promises

unicycle

A scheduler for driving a large number of futures

tk-listen

A set of helper futures allowing to listen TCP (or unix) socket with resource limits and proper error handling

domain-resolv

An asynchronous DNS stub resolver

rxrust

A Rust implementation of Reactive Extensions

fastcgi-client

Fastcgi client implemented for Rust

async-scoped

Spawn scoped (non ’static) asynchronous futures using async_std runtime

stream_throttle

Provides a Stream combinator, to limit the rate at which items are produced

tokio-retry

Extensible, asynchronous retry behaviours for futures/tokio

async-mq

Zero-cost async-await abstraction of lapin AMQP client crate

deadpool-redis

Dead simple async pool for redis

stund

An SSH tunnel maintenance daemon

want

Detect when another Future wants a result

queen-io

I/O library for Rust

futures-rate

This library provides easy tools to help Rust applications guide critical resources or code paths from being overwhelmed

async-change-tracker

reactive change notifications using futures

ardop_interface

Interface to the Amateur Radio Digital Open Protocol (ARDOP)

automate

An asynchronous library to interact with Discord API and make bots

requiem

Actor framework for Rust

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.

tokio-async-std

An async-std that can fit into tokio ecosystem straight ahead

tari_pubsub

Single publisher with multiple subscribers to topic messages

heim-process

Cross-platform processes information

data-buffer

A simple low-level data buffer type useful for IO and in homogeneous collections

frappe

Functional Reactive Programming library for Rust

futures-await-await-macro

Definition of the await! macro for the futures-await crate

telegram-bot-fork

A library for creating Telegram bots

double-checked-cell-async

A thread-safe lazily initialized cell using double-checked locking

async_logger

Asyncronous logger allows writing arbitrary u8 slices to a memory buffer, which then processed by a writer in it’s own thread

thetvdb

TheTVDB API async client

sidekiq

Rust Sidekiq Client

ur20

Rust library for the Weidmüller u-remote IP20 system

futures-async-combinators

toy futures combinators

tokio-lk

Futures-aware lock-by-id primitives

keycloak

Keycloak Admin REST API

maybe-async

A procedure macro to unify SYNC and ASYNC implementation

scoped_spawn

Full structured concurrency for asynchronous programming

acteur

A safe actor system that just works. Simple, robust, fast, documented.

lua_actor

Lua Actor for Rust(sync/async)

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.

libzmq

A strict subset of ØMQ with a high level API

lib3h_zombie_actor

lib3h actor request tracking module

erkpht-tower

Tower is a library of modular and reusable components for building robust clients and servers

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…

seq_io

Fast FASTA and FASTQ readers

zeebest

An unofficial zeebe client for the future!

luis_sys

FFI bindings for Microsoft LUIS API

named-binary-tag

Format is used by minecraft for the various files in which it saves data

cqrs-core

Core types and traits for cqrs

tokio-io

Core I/O primitives for asynchronous I/O in Rust

panda

An async Rust library for Discord

persway

Sway IPC daemon

iobuffer

A simple memory-based buffer for IO reading and writing

promising-future

Implementation of Promise/Future pairs

pcap-async

Async/Stream Extensions for libpcap

capnp-futures

async serialization for Cap’n Proto messages

webhdfs

Hadoop WebHDFS client library

linked-futures

Link futures into a block, which stops all of the included futures when any of the futures complete

etcd-client

An etcd v3 API client

ert

A combinator to control future execution order

async-socks5

An async/.await SOCKS5 implementation

stakker

A lightweight low-level single-threaded actor runtime

backoff-futures

A retry and backoff mechanism for std::future::Future

wikidot-normalize

Simple library to provide Wikidot-compatible string normalization

rants

An async NATS client library

tokio-serde-cbor

Integration of serde_cbor into tokio-io, to allow sending CBOR encoded frames across network (and possibly through other transports)

tokio-reactor

Event loop that drives Tokio I/O resources

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

extreme

Extremely boring async function runner. MIT/Apache-2.0 license is available for spacejam’s github sponsors.

blocking-permit

Permits and a thread pool for blocking operations

ex-futures

An extension of futures

packet-ipc

Share packets between services using servo ipc

iou

io_uring bindings

mioco

Scalable, asynchronous IO coroutine-based handling (aka MIO COroutines)

dkregistry

A pure-Rust asynchronous library for Docker Registry API

tokio-diesel

Integrate Diesel into Tokio cleanly and efficiently

futurify

Convert your sync functions into non-blocking thread futures

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)…

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.

tokio-file

Asynchronous file I/O for Tokio

actix-raft

An implementation of the Raft distributed consensus protocol using the Actix actor framework

redis-asio

Asynchronous Redis driver based on tokio

amy

Polling and Registration abstractions around kqueue and epoll for multithreaded async network programming

tokio-io-pool

Alternative tokio thread pool for executing short, I/O-heavy futures efficiently

poolparty

Added functionality for the futures::executor::ThreadPool futures executor

nbchan

Highly optimized non-blocking communication channels

async-ready

Async readiness traits

component-future

implements the inner future protocol documented in the tokio docs

kompact-component-derive

A derive macro for Kompact component definitions

heim-cpu

Cross-platform CPU information

visiting_ref

Container types that asynchronously return ownership of a value to another context upon exiting scope

signals

A functional-reactive-like library for Rust that allows asynchronous chaining

bawawa

Opinionated set of tools to manage and compose process executions

rustracts

Rust crate for cancellable time based contracts in async/await

async-wakers

A container to register and notify task wakers

etcdv3client

a simple etcdv3 client

local-pool-with-id

A minor variation on a LocalPool executor which exposes unique IDs for tracking future completion

rmp-futures

Async Rust MessagePack and MessagePack-RPC

eventific

Eventific is a tool that gives you the needed building blocks for event sourcing

routerify

A lightweight router implementation with middleware support for the rust HTTP library hyper

actix-daemon-utils

Daemon Utilities by actix

signald-rust

A library to interface with Signald

async-macros

Macros for async-std

settimeout

Creates a std::future::Future implementation to be ready at some point

restartables

Future that restarts an inner future if it doesn’t meet a condition

async_zmq

Async version for ZeroMQ bindings

kf-protocol-transport

Transport frame encoder and decoder for Kakfa protocol

tokio-native-tls

An implementation of TLS/SSL streams for Tokio using native-tls giving an implementation of TLS for nonblocking I/O streams

poller

File I/O events library for Rust

proq

Idiomatic Async Prometheus Query (PromQL) Client for Rust

futuristic

Extensions to the futures crate

mio-signals

Crate for handling signals with Mio

side-futures

Send future for execution on the runtime that may be in a different thread

ws_stream_tungstenite

Provide AsyncRead/AsyncWrite over Tungstenite WebSockets

stage

An ergonomic, composable Actor Model, designed for painless concurrency

webex

Interface to Webex Teams REST and WebSocket APIs

futures-jsonrpc

Futures implementation for JSON-RPC

implicit-await

Implicitly await calls returning Future impls

winping

An easy-to-use ICMP Echo API for Windows programs without requiring elevated rights

fastlog

A high performance asynchronous logger

cute-async

Cute async utilities

futures-delay-queue

Async delay queue backed by async-std and futures-timer

epoxy_frp

The Reactive Glue for Frontend Applications

futures-option

Extension traits for dealing with optional futures and streams

strife

A lightweight library for the Discord API

leaves

Distributed ID Generation Service

futures-locks-pre

Futures-aware lock primitives. Fork using tokio 0.2.6.

yaar-reactor

Non-blocking IO abstractions for building executors

async-lease

Essentially a futures-oriented Arc<Mutex<Option>>

tokio-file-unix

Asynchronous support for epollable files via Tokio on Unix-like platforms

async_ctx

Asynchronous contexts

mpool

A generic connection pool

rustun

A library for implementing STUN server and client asynchronously

async_buf_reader_utils

Adds additional functionality to the async-std crate for BufReader

monzo-lib

async Monzo client in pure rust

futures-cputask

Turn synchronous CPU-bound tasks into futures

dapr-derive

Dapr SDK for Rust

async-graphql-actix-web

async-graphql for actix-web

async-thread

Futures version of std::thread

torut

torut is reasonable tor controller written in rust utilizing tokio for async communication

bb8-bolt

A bolt-client adaptor for the bb8 connection pool

railgun

A Discord API library written in Rust supporting native async/await

async-minecraft-ping

An async Rust client for the Minecraft ServerListPing protocol

async-await

Just some macros to emulate the Async and Await :)

handy_async

A handy library for describing asynchronous code declaratively

async-datagram

Async datagram traits

core-futures-tls

A libcore wrapper allowing async/await to be used from no_std crates

mio-st

Single threaded, lightweight non-blocking IO

rlua-async

Async support for rlua, via coroutines

stakker_mio

Mio I/O polling integration for the Stakker crate

futures-preview

An implementation of futures and streams featuring zero allocations, composability, and iterator-like interfaces

kayrx-macro

The Kayrx Framework

manual_future

A future that must be manually completed, similar to Java’s CompletableFuture

broadcast

A rustlang adapter for writing to multiple sources

tokio-either

Either for Tokio

async-ctrlc

Async wrapper of ctrlc

tempest-source-redis

Tempest source implementation for Redis Streams

boomerang

Rust implementation of “Reactors” Deterministic Actor Model

nsq-client

Rust client for the NSQ realtime message processing system

mio-timerfd

mio support for linux’s timerfd

instrumented-mpsc

Wrapper for futures mpsc unbounded providing Prometheus metrics

gen-stream

Generator-based streams for Rust and futures 0.3

aktrs

An actor model framework for Rust

waitlist

Keep track of an ordered list of Wakers to wake

bitreader_async

A reader that extends BufReader to allow per bit reads asynchronously

future-by-example

Examples of common patterns using Future

riker-default

Riker’s default Model and modules providing core services

rustmann

Rust/Tokio client for Riemann

tls-async

TLS support for AsyncRead/AsyncWrite using native-tls

reverse_io

A wrapper type allowing the reversing of std::io::{Read, Write, Seek}

lazy-queue

Futures-driven lazy queue processing

srmw

Asynchronous single-reader, multi-writer

futures-fs

A Futures implementation for File System operations

lsp-codec

Simple Tokio 0.1-based Codec implementation for Language Server Protocol

heim-runtime

Runtime shims for heim crate

async-pipe

Creates an asynchronous piped reader and writer pair using tokio.rs

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.

gj

Event loop and promises

vampirc-io

A library for asynchronous, non-blocking, UCI protocol–based communication between chess UIs and chess engines

telegrambot

Telegram bot api

shiori_hglobal

impl str for HGLOBAL{…}

remem

Thread-safe object reuse

back-to-the-future

Conversions between std::future::Future and futures::Future

io-synesthesist

ffi library of write(2) and lseek(2)/read(2)

deferred

Rust crate to help perform deferred execution of code logic

riker-cqrs

Provides Command Query Responsibility Separation for Riker applications

deadpool-lapin

Dead simple async pool for lapin

heim-host

Cross-platform host information

actori-testing

Actori testing utils

zomato

A simple crate for retrievig daily menu from zomato.com

handlers

A macro for generating systems of event handlers

intervalier

Interval events with handling notifications

futures_cbor_codec

A codec for framing an AsyncRead/AsyncWrite with cbor for all types that are serializable with serde

deepwell

Database management and migrations service

stream_multiplexer

Combines many streams into a few

kyansel

Cancellable future. Provide a future as argument and the current future will cancel if the provided future resolves first

await_macros

Macros that expand to (expr).await

tokio-ctrlc-error

Easy handling of keyboard interrupts with tokio

shs_async

Secret-handshake protocol (async)

future-bus

Futures based SPMC channel (bus)

greenthread-future

Convert closures to futures based on greenthread on bare-metal (no_std + no_alloc)

rados_hi

Opinionated high-level wrapper for librados (Ceph)

ciseaux_client

Just a Redis Pool implementation

hl7-mllp-codec

A Tokio codec for HL7 Minimal Lower Layer Message Transport protocol (MLLP)

one-of-futures

Future-aware Either-like type with multiple variants

gain-lep

Support for exposing Gain APIs via Lep

capella

An asynchronous StatsD clone

futures-stream-select-all-send

A futures library adapter for merging the output of several streams

ghost_actor

Actor System designed for ergonomic async request callbacks

waitout

Awaits the completion of multiple async tasks

tokio-pg-mapper-derive

Proc-macro library used to map a tokio-postgres row to a Rust type (struct)

futures_retrying

Runtime agnostic retry for futures

ruyi

An event-driven framework for non-blocking, asynchronous I/O in Rust

direct-executor

An executor that directly executes futures, suitable for embedded environments

tokio01-test

Testing utilities for Tokio and futures-based code

celery-rs-core

Core utilities for a celery client and worker in rust

tokio-qapi

QEMU QMP and Guest Agent API tokio adapter

future-utils

Extensions to Rust’s Future and Stream traits

telegram-bot-async

A library for creating Telegram bots

tokio-pty-process-stream

wraps tokio-pty-process in order to provide a simpler API as a single stream object

rotor-tools

Various utility things for comfortable writing of application and protocols using rotor library

retrio

Wrapper around readers and writers to retry on errors of kind Interrupted

wolfram_alpha

A library providing Rust bindings for the Wolfram|Alpha API

futures-cache

Futures-aware cache backed by sled

simpleio

A simple crate for file io that i use in my personal projects

tokio-uds-proto

Unix Domain sockets working with tokio-proto

threader

A performant multithreaded future executor and event loop

brawlhalla

An async Brawlhalla API Wrapper using tokio

tokio-lock

Access an object from a single Tokio task

rair-io

IO subsystem for RAIR

tokio-rpc

An RPC framework for Rust base on tokio

futures-prio

Combinator to set priority of Futures

plumbum

Conduit-like data processing library

futures-glib

Spawn futures on the glib event loop

deadqueue

Dead simple async queue

promises

Effective, simple, lightweight Javascript promises in Rust

tk-bufstream

A buffered stream backed by contiguous buffers (netbuf) for tokio

futures-cputask-derive

Internal crate to provide the async_task macro for futures-cputask

genawaiter-macro

Convenience macros for generators (genawaiter)

naja_async_runtime

A lightweight universal runtime for futures

fumio-utils

utils for fumio crates

futures-rustls

Asynchronous TLS/SSL streams for Future using Rustls

fs

A Futures implementation for File System operations

eventsourcing-derive

Custom derive macros for Eventsourcing components

parity-runtime

Tokio runtime wrapper

gio-2-0-sys

Import crate for Gio

stream-combinators

Additional stream combinators for futures-rs streams

sendfile

Sendfile is a wrapper around the sendfile(2) system call

mdo-future

Zero-cost futures support for rust-mdo

runtime-attributes

Proc Macro attributes for the Runtime crate

futures-async-stream-macro

Definition of the #[async_stream] macro for the futures-async-stream crate as well as a few other assorted macros

futures-zmq

Provides Futures abstractions for ZeroMQ on any futures executor

nb-sync

Non-blocking synchronization structures for bare-metal environments

mai

A higher-level mio interface

lz_shared_udp

Functionality for a shared UDP socket

kompact-actor-derive

A derive macro for Kompact Actors

tokio_kcp

A kcp implementation for tokio

mimo

Asynchronous backup

bitstream

Bit level IO

futures-stream-select-all

A futures library adapter for merging the output of several streams

packattack

A parser-combinator library for writing concise and safe binary parsers

rsevents-extra

Useful events built on top of rsevents. Includes countdown event.

tokio-utun

Utun bindings for Tokio

fluss

Stream processing framework

librdkafka-sys

Native bindings to the librdkafka library

syncthing

A Rust library for controlling syncthing file synchronization through its REST interface

mio-pidfd

mio support for Linux’s pidfd

libpool

A simple threadpool from The Rust Programming Language

tokio-util

Additional utilities for working with Tokio

must_future

A wrapper future marked must_use - mainly to wrap BoxFutures

async-coap

A flexible, asynchronous library for using and serving CoAP resources. Experimental.

alligator

Alligator is for getting the output value from a future

cancellable-timer

A timer that can be interrupted

streamify

Conversions from values to Stream

weighted-select

futures::stream::Select with weights

quickcheck_async

Runtime-agnostic attribute macros to use quickcheck with async tests

futures-shim

An adapter for futures-unaware components

xactor

Xactor is a rust actors framework based on async-std

futures_future

The Rust crate that converts the old style futures crate futures::Future into the new nightly async/await style std::future::Future so you can easily try out the new syntax

ostrich-core

Main utils for the ostrich project

futures-black-hole

Black hole implementation for futures

conio

Console input and output

async-diesel

Integrate Diesel into async-std cleanly and efficiently

futures-bufio

Buffered IO with futures on top of a threadpool for blocking IO

runtime-loop

Runtime loop for Rust

mdrv

Modular driver based on Mio for managing multiple connections over different protocols

tokio-terminal-resize

a stream of terminal resize events

mio-utun

Utun bindings for mio

socksv5_future

Socks v5 futures for Server and Client

pseudo-async-io

Simple (pseudo-) async wrappers around Read and Write

dapr

Dapr SDK for Rust

alzheimer

Async implementation of brainfuck interpreter

futures-shuttle

Futures-aware shuttle synchronization object

tokio-beanstalkd

Asynchronous client library for interacting with Beanstalkd work queue

async-graphql-derive

Macros for async-graphql

relay

A lightweight oneshot Future channel

async-attributes

Experimental language-level polyfills for Async Rust

tokio-lxi

LXI protocol abstractions for Tokio

tk-pool

Generic connection pool for tokio

tokio-kinetic

Kinetic protocol client library built on tokio-rs

tokio-resource-pool

A generic resource pool for the Tokio ecosystem

yaar

Yet another asynchronous runtime optimized around configuration and no_std

stund_protocol

The client/server protocol used by the “stund” program

futures-log

A simple logging wrapper around futures-rs Futures and Streams

io-block

Work with block devices and other block-like things in rust

futures-async-runtime-preview

Runtime for the async/await macros in the futures crate

adventure

Helps your great adventure for the various type of requests

backtalk

An asynchronous, streaming web server for JSON APIs

gw2rs

A Rust library for the Guild Wars 2 API

mirai

A Futures layer over Mio

reducer

A predictable reactive framework for Rust apps

enum_future

A simple macro for creating Future-implementing enums containing futures

heim-disk

Cross-platform disk information

future_pubsub

A tokio based publish-subscibe channel

vmap

Cross-platform library for fast and safe memory-mapped IO

holly

A simplistic actor model library using futures

dumb-exec

A very simple and dumb implementation of a futures executor that doesn’t allocate and can be used in no_std environments

tokio-scoped

Scoped Runtime for tokio

asyncnsq

async client for nsq

futures-enum

#[derive(Future, Stream, Sink, AsyncRead, AsyncWrite, AsyncSeek, AsyncBufRead)] for enums

tokio-cache

Non-blocking caches that can be used with Tokio

fourche

A simple task queue named after a lion with forked tail (queue fourché), works with Redis

notice-core

Traits and some implementations for notify/wait pattern

starstruck

A game building utility that is made to be simple to use while still providing great performance

actix-async-await

Experimental async/await support for Actix

slacker

Slacker server built on top of tokio

wombo

Utilities for managing event loop threads

mio-byte-fifo

Concurrent non-blocking byte SPSC FIFO buffer intended for use in Mio poll

netdb

Access to network-related name databases

eternal-macro

The Eternal Framework

runtime-raw

Traits to implement custom Runtimes

tangle

Future implementation for Rust

valuable_futures

Utils which allow writing futures::Future and futures::Stream by-value

batch

Distributed task queue library based on RabbitMQ

fg-uds

Asynchronous unix domain socket running on the futures-glib main loop

stop-handle

Convinient structure to terminate future execution

futures-await-async-macro

Definition of the #[async] macro for the futures-await crate as well as a few other assorted macros

noob

A WIP futures-based Discord bot library

tower-buffer

Buffer requests before dispatching to a Service

filebuffer

Fast and simple file reading

tokio-async-attributes

tokio-async-std’s proc macros

tk-easyloop

A thread local loop and other loop helpers

futures-await-test-macro-preview

Helper crate for futures-await-test-preview

faktory

API bindings for the language-agnostic Faktory work server

strawpoll

A wrapper to avoid spurious polling

tokio-mqttc

A mqttc client based on tokio-rs, this is still early stage prototoy

futures-await

Async/await syntax for Rust through a procedural macro. This crate defines the #[async] macro for functions, the await! macro for function bodies, and intends to be used with the futures crate on crates.io as well.

implicit-await-macro

#[implicit_await] procedural macro implementation

deepwell-core

Database management and migrations service

tokio-interceptor

An event-driven application framework built on tokio and futures

tokio-os-timer

Timer facilities for Tokio based on OS-level primitives

tokio-shared-udp-socket

Easily share a UDP socket between different futures in tokio

and-then2

An alternative to a traditional Future::and_then combinator

async-spawn

Asynchronous spawn

fumio-reactor

a std futures IO reactor

tempest

Realtime message handling framework inspired by Apache Storm and built with Actix

tokio-process

An implementation of an asynchronous process management backed futures

tokio-udp

UDP bindings for tokio

hydro

cooperative green tasks

async-zmq-types

Types and traits to create a generic interface over asynchronous zmq implementations

associated-async-io

Async IO traits that use futures instead of poll

async_io_stream

IntoAsyncRead on steriods

futures-backoff

Asynchronous retry strategies for futures

gjio

Asynchronous input and output

kompact

Kompact is a Rust implementation of the Kompics component model combined with the Actor model

genawaiter-proc-macro

procedural macro for generators (genawaiter)

tokio-sync

Synchronization utilities

heim-memory

Cross-platform memory information

tokio-buf

Asynchronous stream of byte buffers

fumio

a std futures runtime with IO and timers

futures-await-test-macro

Helper crate for futures-await-test

tower

Tower is a library of modular and reusable components for building robust clients and servers

rotor-dns

Asynchronous DNS resolver for rotor framework

tower-balance

Balance load across a set of uniform services

runtime-native

A cross-platform asynchronous runtime

handy_io

A handy pattern and futures based asynchronous I/O library

futures-async-runtime

Runtime for the async/await macros in the futures crate

async-option

Essentially an asynchronous Async<Mutex<Option>>

tokio-redis-pool

A Redis connection pool for the Tokio ecosystem

async-slot

An asynchronous (futures-based) channel that only preserves last value sent

xactor-derive