-
mio
轻量级非阻塞 I/O
-
tokio
一个用于编写异步 I/O 支持应用程序的事件驱动、非阻塞 I/O 平台
-
mlua
对 Lua 5.4/5.3/5.2/5.1（包括 LuaJIT）和 Roblox Luau 的高级绑定，具有 async/await 功能，并支持在 Rust 中编写原生 Lua 模块
-
tokio-rustls
使用 Rustls 的 Tokio 异步 TLS/SSL 流
-
blocking
用于在异步程序中隔离阻塞 I/O 的线程池
-
rdkafka
librdkafka 的 Rust 封装
-
async-std
Rust 标准库的异步版本
-
futures
具有零分配、可组合性和迭代器接口的流
-
async-task
构建执行器时的任务抽象
-
bb8
功能齐全的异步（基于tokio）连接池（类似r2d2）
-
polling
epoll、kqueue、事件端口和IOCP的可移植接口
-
neon
Node.js的安全抽象层
-
cucumber
Rust的测试框架，支持异步。完全原生，无外部测试运行器或依赖项。
-
futures-timer
对futures的定时器
-
suppaftp
一个用于Rust的超级FTP/FTPS客户端库
-
tokio-serial
tokio的串行端口实现
-
multer
Rust中
multipart/form-data内容类型的异步解析器 -
futures-concurrency
异步Rust的结构化并发操作
-
paho-mqtt
官方Eclipse Paho MQTT Rust客户端库。这是一个基于Paho C库的封装
-
minus
Rust的异步数据可馈送终端分页库
-
async-process
异步处理进程的接口
-
ractor
Rust的actor框架
-
async_zip
异步ZIP存档读写crate
-
pollster
同步阻塞线程，直到future完成
-
keycloak
管理REST API
-
monoio
基于 iouring 的每个核心一个线程的运行时
-
event-listener
通知异步任务或线程
-
futures-signals
使用 futures crate 的零成本 FRP 信号
-
want
检测其他 Future 是否需要结果
-
juniper
GraphQL 服务器库
-
remoc
🦑 远程多路复用对象、通道、可观察集合和 RPC，使远程交互无缝。提供多个远程通道和通过 TCP、TLS 或任何其他传输的 RPC。
-
openraft
高级 Raft 一致性算法
-
redis-async
基于异步将来的 Redis 客户端，使用 Tokio 构建
-
apalis
Rust 的可扩展多线程后台作业处理
-
async-scoped
为 async_std 和 tokio 运行时创建范围（非 'static）异步将来
-
tower-sessions
🥠 作为
tower和axum中间件的会话 -
csv-async
异步的 CSV 解析
-
async-recursion
异步函数的递归
-
failsafe
断路器实现
-
stream-cancel
中断异步流
-
calloop
基于回调的事件循环
-
futures-locks
支持Futures的锁原语
-
async-native-tls
使用futures的本地TLS
-
eyeball
为您的Rust类型添加可观察性！
-
tokio-pipe
使用tokio的异步pipe(2)库
-
motore
用于构建强大客户端和服务器模块化和可重用组件。Motore深受Tower的启发。
-
unicycle
用于驱动大量futures的调度器
-
rsmq_async
异步RSMQ的Rust端口。RSMQ是一个简单的redis队列系统，适用于任何redis v2.4+。它包含与原始系统相同的方法，见https://github.com/smrchy/rsmq
-
madsim
分布式系统的确定性模拟器
-
tor-rpcbase
Arti RPC服务的底层功能
-
tokio-stream
与
Stream和tokio一起工作 -
方
Rust 的后台作业处理库
-
triple_buffer
三重缓冲，用于在线程之间共享频繁更新的数据
-
futures-buffered
侧重于性能和低内存使用的未来并发原语
-
esrs
一个具有 Prima.it 观点的库，用于实现 cqrs/es
-
async-shutdown
异步优雅关闭的一站式解决方案
-
rxrust
响应式扩展
-
futures-lite
Futures、流和异步 I/O 组合器
-
io-uring
Rust 的低级
io_uring用户空间接口 -
tokio-zookeeper
用于与 Apache ZooKeeper 交互的异步客户端库
-
gix-actor
识别 git 动作的方式
-
hypercore
安全、分布式、只追加日志
-
pharos
生成未来0.3事件流的观察者模式
-
zookeeper-client
ZooKeeper 异步客户端
-
async-event
用于无锁算法的高效异步条件变量
-
celery
Celery 的 Rust 实现
-
service-async
类似于 tower 的异步服务
-
fluvio-future
Fluvio 项目中的 I/O 未来
-
nb
最小化非阻塞 I/O 层
-
tokio-io-timeout
对 IO 操作应用超时的 Tokio 包装器
-
apis
反应式、面向会话的、异步进程计算框架
-
kdbplus
为API构建共享库和IPC客户端的双q/kdb+接口
-
async-walkdir
Rust的异步目录遍历
-
c-ares-resolver
基于c-ares的异步DNS解析器
-
tokio-retry
为futures/tokio提供可扩展的异步重试行为
-
asynchronous-codec
使用
async/await进行帧的编码和解码 -
containerd-shim
containerd的shim扩展
-
tokio_schedule
在tokio运行时中安排任务
-
automerge
一种类似JSON的数据结构（CRDT），可以由不同的用户并发修改，并自动合并
-
tokio_wasi
一个用于编写异步 I/O 支持应用程序的事件驱动、非阻塞 I/O 平台
-
tor-rtcompat
异步运行时兼容层，由Tor使用
-
actix
Rust的Actor框架
-
futures-rustls
使用Rustls的futures异步TLS/SSL流
-
async-ssh2-lite
异步ssh2
-
cassette
用于构建状态机的单future、非阻塞执行器
-
kafka
Rust客户端用于Apache Kafka
-
tokio-graceful
用于tokio应用程序优雅关闭的工具
-
reactive-mutiny
具有高级和优化容器（通道）和流执行器的异步事件驱动反应式库
-
triggered
任务和线程之间一次性事件的触发器
-
page-turner
带有分页功能的API的通用抽象
-
lazy-pool
实验性懒对象池
-
cancel-safe-futures
更关注取消操作的替代futures适配器
-
tokio-graceful-shutdown
在基于Tokio的服务上执行优雅关闭
-
wg
Rust 同步/异步的 Golang like WaitGroup 实现
-
wasm-bindgen-futures
连接 Rust Futures 和 JavaScript Promises 的桥梁
-
mangadex-desktop-api2
用于从 Mangadex 下载漫画、章节、封面等的 Actix 服务器
-
fn_graph
动态管理的函数图执行
-
lamellar
在 RUST 中开发的针对 HPC 系统的异步任务运行时
-
rust-parallel
在 rust/tokio 中以并行方式运行命令的快速命令行应用程序。与 GNU parallel 或 xargs 具有相似的界面。
-
async-io
异步 I/O 和定时器
-
factorio-mlua
针对 Lua 5.4/5.3/5.2/5.1 (包括 LuaJIT) 和 Roblox Luau 的高级绑定，具有 async/await 功能，并支持在 Rust 中编写原生 Lua 模块。增加了 Factorio Lua 支持的分支
-
delay_timer
延迟任务的时间管理器。类似于 crontab，但支持同步异步任务，并支持动态添加/取消/删除。
-
lcode
终端刷力扣应用
-
海报
用Rust编写的MQTTv5客户端库
-
krecik
使用行业标准库：Curl、ngHTTP2和OpenSSL的异步、并行外部服务检查器（及报告器）
-
async-speed-limit
异步限制多个字节流的速度
-
poll-promise
在即时模式GUI中轮询异步操作的结果
-
mpart-async
Rust的异步（Futures-Base）多部分请求
-
tokio-rustls-acme
使用rustls自动管理TLS证书
-
pi-async-rt
基于future（MVP），一个通用的异步运行时和工具，用于为外界提供基础
-
exponential-backoff
带抖动的指数退避生成器
-
async-socks5
异步的/.await SOCKS5 实现方案
-
pijul
分布式版本控制系统
-
a10
io_uring 库
-
miow
专注于 IOCP 和异步 I/O 抽象的 Windows 零开销 I/O 库
-
partial-io
用于测试部分、中断和可能阻塞的 I/O 操作的帮助程序，支持通过 proptest 和 quickcheck 进行属性测试
-
ipc-queue
用于异步用户调用的 fortanix-sgx-abi 中描述的 FIFO 队列
-
nuclei
主动 I/O 和运行时系统
-
ws_stream_tungstenite
通过 Tungstenite WebSockets 提供 AsyncRead/AsyncWrite
-
crosstown_bus
带有 RabbitMQ 的 Rust 事件总线
-
filebuffer
快速简单的文件读取
-
stakker
轻量级的单线程actor运行时
-
stream_throttle
流组合器，用于限制生成项的速率
-
ghost_actor
GhostActor使得使用Actor模型实现异步/并发代码变得简单、直观且符合语言习惯
-
async-dropper
作为派生宏的AsyncDrop的最差实现
-
async-tempfile
自动删除异步I/O临时文件
-
swiftide-indexing
专为AI应用设计的快速流式管道库
-
interruptible
在被打断时停止future生产者或流产生值
-
tokio-io-utility
一些tokio::io的辅助函数
-
pinky-swear
准备好Futures和async/await的Promises
-
swiftide
专为AI应用设计的快速流式管道库
-
fvm_shared
Filecoin虚拟机共享类型和函数
-
glommio
按核心线程设计的crate，使得Rust开发者更容易编写高度并行的异步应用程序
-
aqueue
快速线程安全的异步执行队列
-
tiny-tokio-actor
基于tokio的微型actor库
-
kcpserver
快速kcp服务器框架
-
twilight-http-ratelimiting
Twilight生态系统中的Discord REST API限速器实现
-
actix-casbin
Actix actor用于casbin
-
tokio-uring
为Tokio异步运行时提供io-uring支持
-
local-waker
线程局部任务唤醒的同步原语
-
trait-variant
在Rust中使用impl traits
-
mio-serial
mio的串行端口实现
-
genawaiter
在稳定版Rust上实现的堆栈式生成器
-
messagebus
允许模块间通过消息进行通信
-
ferrisgram
Telegram Bot API的优雅Rust客户端
-
debounced
构建延迟的
Future和防抖的Stream，在输出最新项之前等待指定的时间 -
blockstore
能够按CID索引任意数据的IPLD块存储
-
get_chunk
支持自动或手动选择块大小的文件迭代器或流
-
ya-gcp
用于使用Google Cloud Platform服务的API
-
hypercore-protocol
Hypercore feed的复制协议
-
effectum
基于SQLite的可嵌入任务队列
-
rio
为io_uring提供的GPL-3.0优秀绑定。spacejam的github赞助者可用MIT/Apache-2.0许可证。
-
mail-message
一款从命令行发送邮件的简单、快速、容错程序
-
rocketmq-store
Apache RocketMQ 的非官方 Rust 实现
-
基于轮次的
MPC 协议的驱动程序
-
kube-coordinate
使用 coordination.k8s.io API 进行 Kubernetes 领导选举
-
hannibal
一个小型 actor 库
-
futuresdr
用于异构架构的实验性异步 SDR 运行时
-
hirun
基于事件驱动、非阻塞 I/O 机制的异步编程并发框架
-
webex
Webex Teams REST 和 WebSocket API 的接口
-
certsd
自动、异步的 LE 证书颁发者
-
lemmy_db_views_actor
fediverse 的链接聚合器
-
minior
人体工学Minio客户端
-
conogram
Telegram Bot API的异步包装器
-
countio
从futures和tokio的std::io::{Read, Write, Seek}及其异步变体进行字节计数的工具
-
tokio-test
基于Tokio和futures的代码的测试实用工具
-
async_io_stream
加强版的IntoAsyncRead
-
rxr
事件驱动应用程序的反应式扩展
-
multishot
用于向异步任务发送单个值的异步、无锁、可重用通道
-
etcdv3client
etcdv3客户端
-
mobc
支持async/await的通用连接池
-
mini_exercism
与Exercism.org API交互的最小Rust库
-
rabbit-auto
lapin 发布者和消费者的包装器
-
daktronics-allsport-5000
Daktronics All Sport 5000 的串行输出解码器
-
ocpp-client
OCPP 客户端实现。使用此库来实现一个 OCPP 充电桩
-
monzo-lib
纯 Rust 编写的异步 Monzo 客户端
-
b2_backblaze
上传小文件到 Backblaze b2 服务的异步基本库
-
tokio-scheduler-rs
使用 tokio 运行时编写的 JobScheduler，支持自动重试、钩子和自定义存储
-
scoped-futures
对 Future 生命周期设置上限
-
hedwig
Rust 的消息总线
-
pasts
与 futures crate 相比，更简单、更小的替代品
-
irelia
原生 LoL API 的包装器
-
tor-rtmock
测试tor-rtcomapt的模拟支持
-
zookeeper-async
异步ZooKeeper客户端
-
mio_wasi
轻量级非阻塞IO
-
kube-lease-manager
使用Kubernetes Lease API进行高效且可靠的领导者选举
-
pptr
类型驱动的异步Actor运行时
-
stopper
异步流和未来停止机制
-
synchronized-writer
同步写入数据的小型实现
-
coerce-redis
Coerce的Redis actor持久化提供程序。支持事件溯源和快照
-
c-ares
c-ares库的包装，用于异步DNS请求
-
pty-process
在pty上启动命令
-
tmq
为Tokio提供的ZeroMQ绑定
-
futures-executor
基于futures-rs库的异步任务执行器
-
duplicate-checker
重复文件检查器
-
async_smux
异步smux复用库
-
async_cache
异步刷新缓存
-
postage
异步通道库
-
netidx-protocols
基于netidx构建的协议
-
sn_sdkg
安全网络同步分布式密钥生成：实现无经销商部分密钥生成
-
tokactor
围绕tokio构建的actor模型框架
-
async-global-executor
基于async-executor和async-io构建的全局执行器
-
tokio-rusqlite
rusqlite库的异步处理程序
-
vesper
一个用于与 twilight 一起使用的斜杠命令框架
-
containerd-shim-protos
containerd shim 接口的 TTRPC 绑定
-
pubnub
Rust 的 SDK
-
async-change-tracker
使用 futures 的反应式更改通知
-
fvm_actor_utils
为 Filecoin 虚拟机编写原生演员的实用工具
-
mio-aio
mio 的 POSIX AIO 绑定
-
etcd-rs
rust 的 etcd 客户端
-
deduplicate
缓存、异步、请求去重
-
actix-rt
为 Actix 生态系统提供的基于 Tokio 的单线程异步运行时
-
awak
Rust 的小型异步运行时
-
enfync
环保的异步实用工具
-
ntex-grpc
GRPC 客户端/服务器框架
-
another-rxrust
一个比
rxRust更易于使用的ReactiveX在Rust中的实现 -
decoyssh
一个紧凑且便携的SSH陷阱服务器
-
graceful-shutdown
异步代码的优雅关闭
-
async-tensorrt
Rust 的异步 TensorRT
-
termusix
一个基于 Rust 的、用户友好的终端音乐播放器，具有终端用户界面
-
unkey
Unkey API 的异步 Rust SDK
-
elfo
您的下一个演员系统
-
runtimelib
Jupyter 运行时库
-
eventbuzz
基于 tokio(async) 的安全、快速、并发的事件发布/订阅系统，受 Spring 事件启发
-
apalis-sql
apalis 的 SQL 存储库。使用 sqlite、postgres 和 mysql 进行后台作业处理
-
z_osmf
z/OSMF 客户端
-
keen-retry
-- 强大而高效 -- 错误处理和恢复的无成本抽象和零拷贝库
-
apocalypse
Rust 的actor框架
-
drop-stream
一个流，它使用一个闭包封装另一个流，当它被丢弃时调用该闭包
-
wgpu-async
将一些 WGPU 回调方法转换为异步方法
-
tower-fallback
一个 Tower 服务组合器，它首先将请求发送到第一个服务，如果第一个服务出现错误，则尝试在第二个回退服务上处理
-
xan-actor
Akka actor
-
winctx
Windows 上 Rust 的最小窗口上下文
-
booru-dl
从 booru 下载图片和标签 txt 的命令行工具
-
xtra
一个小型 actor 框架
-
kapacitor-udf
创建 Kapacitor 用户定义函数（UDFs）
-
nominatim
绑定到由 openstreetmap 提供的反向地理编码 API
-
luring
使用 tokio 的 AsyncFd 进行 io-uring 抽象
-
woddle
一个异步、同步、数据库支持的 Rust 作业调度器
-
async-event-emitter
轻量级的 AsyncEventEmitter
-
mailfred
作为 HTTP 服务器处理电子邮件
-
quick-protobuf-codec
使用 asynchronous-codec、unsigned-varint 和 quick-protobuf 进行 Protobuf 结构的异步编解码
-
ads_client
异步、非阻塞的 ADS 客户端
-
napi_ext
扩展 napi-rs 以运行本地 futures
-
sacs
为 Tokio 的异步 Cron 调度器
-
fama
管道管理器
-
scoped-stream-sink
创建流和汇的简单方法
-
syslog-rs
glibc/libc syslog的原生Rust实现
-
mikrotik-rs
与MikroTik路由器交互的异步Rust库
-
s3tui
多s3账户操作的用户界面应用程序
-
eventuals
最终一致性的值
-
popol
最小化非阻塞I/O
-
hass-rs
Home Assistant的异步WebSocket客户端
-
mapped_futures
基于FuturesUnordered的一系列futures，支持通过键插入、删除和修改futures
-
girlboss
具有进度跟踪的异步作业管理器
-
moro-local
为异步Rust提供类似trio的nurseries的实验性结构化并发支持。与稳定Rust上的非Send futures一起工作。
-
EasyDist
构建简单分布式项目的非阻塞IO和易于使用的Rust crate。该crate包含多个构建块，可用于构建分布式系统程序。
-
libmqm-sys
IBM® MQ接口（MQI）和MQ管理接口（MQAI）的本地绑定
-
retry-if
一个用于装饰方法和支持指数退避的tokio兼容属性宏
-
spawns-compat
线程上下文任务创建器的异步运行时检测
-
peace_resources
peace自动化框架的运行时资源
-
rexecutor
一个健壮的作业处理库
-
discro
异步功能响应式编程（FRP）的DISCRete可观察者
-
rust-utils
我在编写的rust程序中使用的各种实用程序
-
ultra-batch
基于Tokio的库，用于批量缓存数据库查询或其他数据查找
-
tokio-io-rewind
重置tokio::io::AsyncRead和tokio::io::AsyncWrite流
-
coc-rs
Clash of Clans公共API的包装器
-
futures-bounded
在大小和时间上限制futures
-
rust-multipart-rfc7578_2
multipart/form-data (RFC7578)
-
actix-web-flash-messages
为actix-web应用提供Flash消息
-
persway
Sway IPC守护进程
-
timeout-iterator
TimeoutIterator是一个任何迭代器的包装器，它添加了peek_timeout和next_timeout函数。典型用途是解析多行自由格式记录（如跟踪日志文件）...
-
compio
基于完成的异步运行时
-
mobc-lapin
为异步mobc连接池提供RabbitMQ支持
-
process-lib
跨平台、异步Rust库，用于在管道中运行命令
-
fundamentum-edge-daemon
从Linux设备访问Fundamentum生态系统的支持方式
-
stressed
适用于竞技编程的通用CLI压力测试器
-
futures-retry
重试你的Futures和Streams！
-
dptree
Rust 的异步事件分发机制
-
wayrs-utils
为 wayrs-client 提供的一系列工具和抽象
-
parquet_opendal
Apache OpenDAL 的 parquet 集成
-
async-blocking-stdio
异步版本的 std::io::std{in(), out(), err()}
-
gasket
阶段式事件驱动架构 (SEDA) 框架
-
async-shared-timeout
可重置和共享的异步超时
-
kafka-threadpool
用于通过 SSL (mTLS) 或 PLAINTEXT 协议向 Kafka 发布消息的异步 Rust 线程池
-
hydra-websockets
用于 hydra 框架的 WebSocket 服务器
-
rdkafka-sys
对 librdkafka 库的本地绑定
-
resident-utils
常驻程序库
-
tokio-tower
弥合Tokio和Tower之间的协议差距
-
async-lsp
基于tower的异步语言服务器协议(LSP)框架
-
rs-event-emitter
为rust模拟promise实现
-
lighthouse-client
Lighthouse项目的客户端SDK
-
monoio-rustls
基于Rustls的Monoio异步TLS流包装器
-
async-fuse
异步计算的融合辅助工具
-
rseip
纯Rust实现的Ethernet/IP (CIP)客户端
-
swiftide-integrations
专为AI应用设计的快速流式管道库
-
zookeeper-cache
ZooKeeper客户端缓存
-
madsim-real-tokio
一个用于编写异步 I/O 支持应用程序的事件驱动、非阻塞 I/O 平台
-
deferred-future
模仿jQuery.Deferred()，允许从Future实现类实例的外部对正在pending的Future对象进行resolve或reject处理。
-
rustygram
Rust 编写的最小化且速度极快的 Telegram 通知框架
-
async-unsync
异步、非同步（线程局部）通道和信号量
-
async_zmq
ZeroMQ 绑定的异步版本
-
iroh-io
异步本地 I/O
-
vkapi2
为 Rust 编写的 vk API 封装器
-
tower-sessions-redis-store
为
tower-sessions提供的 Redis 会话存储 -
simpl_actor
tokio actors
-
embedded-runtime
用于嵌入式设备的微型异步运行时
-
deadqueue
极其简单的异步队列
-
signal-hook-tokio
对 signal-hook 的 Tokio 支持
-
tokio_gen_server
在 Tokio 运行时上的 Elixir/Erlang-GenServer 类型的 actor
-
tower-batch-control
Tower 批量请求处理中间件
-
tokio-js-set-interval
允许您在
tokio运行时内部使用与 JavaScript 中的相同的方式使用setInterval(callback, ms)和setTimeout(callback, ms)。该库提供了宏set_interval!(callback, ms)和set_timeout!(callback, ms) -
async-transmit
异步向对等节点传输数据的特质
-
wiremock_logical_matchers
与 wiremock 一起使用的逻辑匹配器
-
corcovado
非阻塞 IO 库
-
kuska-handshake
安全 Scuttlebutt 握手 + boxstream 库
-
debouncer
Rust 的简单防抖器
-
actix-mqtt-client
基于 actix 框架的 MQTT 客户端
-
rocketmq-common
Apache rocketmq 公共组件
-
tokio-i3ipc
为 i3 和 tokio 提供的绑定，允许异步应用程序通过其 IPC 接口与 i3 进行通信。包含 futures 实现，以及方便与 i3 一起工作的函数。
-
monoio-codec
为Monoio编解码器
-
act_rs
Act.rs 是一个与标准库和 Tokio 一起使用的 actor 库
-
knien
异步 Rust 的类型化 RabbitMQ 接口
-
retainer
支持键过期功能的 Rust 最小异步缓存
-
llm_client
LLMs：结构化文本、决策、分类和基准。一个用户友好的接口，用于一次编写并在任何本地或 API 模型上运行。
-
futures-util
futures-rs 库的常用实用工具和扩展特质
-
warnings
定义仅调试运行时警告并提供退出方式
-
vmcircbuffer
双映射循环缓冲区
-
infect
意图/效果/任务 - 模型视图意图（MVI）和状态行为模型（SAM）范式的变体
-
borrow_mutex
无需包装目标结构的异步Rust互斥锁
-
tros
将tarantool TX线程的tros转换为tokio(以及其他！)
-
patharg
将"-"（连字符/破折号）参数视为stdin/stdout
-
taskline
Rust的分布式任务队列
-
kafka-rs
基于kafka-protocol-rs和Tokio的本地Rust Kafka客户端
-
speare
在tokio::task和flume通道上提供类似actor的薄抽象
-
agnostic
想要编写对异步运行时无关的crate的用户
-
dataloader
使用async-await的Facebook DataLoader
-
future-queue
管理具有不同权重的futures队列的适配器
-
aws-parameters-and-secrets-lambda
在您的AWS Lambda函数中缓存AWS Secrets Manager的秘密
-
crossword_generator
从提供的单词生成填字游戏
-
busstop
一个命令和查询总线
-
futures-finally
在完成未来或流之后执行未来的函数，无论其值或结果如何
-
async-ffi
FFI 兼容的
Futures -
ractor_actors
使用 Ractor 构建的演员
-
tipsy
为 Tokio 提供的跨平台 IPC
-
mal-api
Rust 的异步 MyAnimeList (MAL) API 库
-
php-tokio
在 PHP 中使用任何异步 Rust 库！
-
discern
实现命令查询责任分离（CQRS）模式
-
space-traders
Rust 的异步 SpaceTraders API 客户端
-
anchor-chain
用于构建基于 LLM 应用程序的静态类型异步框架
-
async-select
select!同时多路复用异步未来 -
rustix-uring
Rust 的低级
io_uring用户空间接口 -
futures-ticker
异步的周期性时间事件
-
streamcatcher
线程安全、共享（异步）、几乎无锁的流缓冲区
-
async_executors
实现了Spawn、SpawnLocal和SpawnHandle以用于常用执行器
-
simple-git
适用于异步上下文的gix git接口（使用tokio）
-
fb_futures_ext
future crate扩展
-
moeval
玩具解释器
-
fil_actors_runtime
Filecoin协议的系统演员
-
constellation-rs
Constellation是一个用于Rust（nightly）的框架，有助于分布式程序的编写、调试和部署
-
async-dispatcher
基于可插拔调度器的异步运行时
-
cache_loader_async
基于tokio的线程安全缓存加载，具有异步加载函数。
-
futures-batch
一个将元素分块并在超时或缓冲区满后刷新的适配器。（以前称为tokio-batch。）
-
crossmist
高效且无缝的跨进程通信，同步和异步都适用。
-
tools_interface
多个与Wikipedia/Wikimedia/Wikidata相关的工具的抽象。
-
dwn
去中心化网络节点。
-
overclock
用于构建数据驱动分布式系统的框架。
-
acts
一个快速、小巧、可扩展的工作流引擎。
-
io-tether
用于定义I/O对象的特质，在失败时自动重新连接。
-
madsim-rdkafka
madsim上的rdkafka模拟器。
-
serial-thread
使用mpsc::cjhannels或async-channels进行高效数据处理的异步、多线程串行端口通信库。
-
makepad-futures-legacy
Makepad 旧版未来
-
probe
静态工具探针
-
passivized_vault_client
Vault 客户端 - 初始化和监控 HashiCorp Vault 节点
-
surrealdb-async-graphql-axum
axum 的异步 GraphQL
-
splaycast
特定流的广播通道
-
zeroconf-tokio
基于 Tokio 的 zeroconf crate 包装器，提供 mDNS 服务发现和注册功能
-
async-rdma
RDMA ibvers lib 的异步包装器
-
linemux
提供异步、多路复用文件（特别是日志文件）的尾随功能
-
async-defer
异步延迟调用
-
libctp-sys
Rust 对 CTP API 的绑定
-
wasmcloud-interface-factorial
为wasmcloud factorial能力提供的接口库，wasmcloud:example:factorial
-
mpi-sys
Rust的消息传递接口绑定
-
stop-token
为异步Rust提供的实验性协作取消功能
-
irondash_run_loop
提供一致、平台无关的系统运行循环接口
-
ipc-rpc
在servo/ipc-channel之上提供了一个提供许多高级特性的包装器
-
delouse
将暴露适用于基于tokio的异步程序的最有用的调试存根
-
bus_queue
无锁的有限非阻塞发布-订阅队列
-
actix-multipart-rfc7578
为Actix提供的multipart/form-data (RFC7578)
-
async-broadcast
异步广播通道
-
async-cron-scheduler
支持cron表达式的无运行时感知异步任务调度器
-
async-pidfd-next
Linux的进程文件描述符（pidfd）
-
merge-streams
将多个流合并为一个
-
hyperbee
点对点B树
-
scylla-rs
基于actor模型框架构建的异步ScyllaDB驱动程序
-
cancellation-token
C#的CancellationToken API
-
mlua-luau-scheduler
基于Luau的异步调度器，使用mlua和async-executor
-
truba
Rust的最小tokio运行时基于actors
-
ng-repo
NextGraph的仓库库，NextGraph是基于语义网和CRDTs的分散式、安全且本地优先的Web 3.0生态系统
-
ref_count
为实时和嵌入式系统提供高效、底层的异步同步
-
async-codec
创建异步编解码器
-
async-raft-ext
基于Raft分布式一致性协议的异步实现。增强了raft的功能，同时保持rnacos的访问接口不变
-
deluge
一个高度并发的流库，驱动底层未来（future）同时并发或并行处理流操作，尽可能快速
-
read_until_slice
AsyncBufRead::read_until 扩展，接受一个切片作为分隔符，而不是单个 u8
-
smol-potat
smol 运行时的过程宏（Proc macro）
-
light-magic
一个轻量级、快速且易于使用的持久内存数据库实现
-
tokio-send-fd
tokio::net::UnixStream 的包装器，用于发送文件描述符
-
replay-channel
一个新的接收者接收新消息之前，会重新播放所有过去消息的广播频道
-
tcpclient
基于 aqueue 代理的异步 tcpclient
-
async-native-tls-2
使用futures的本地TLS
-
ts3
TeamSpeak3 查询库
-
pegy
基于 derive 的解析器生成器
-
rust-concurrent
在 rust/tokio 中以并行方式运行命令的快速命令行应用程序。与 GNU parallel 或 xargs 具有相似的界面。
-
wired_handler
Wired的处理库
-
fundamentum-sdk-mqtt
针对Fundamentum物联网MQTT代理的MQTT客户端
-
async-pipes
构建并发数据处理管道
-
ctf-pwn
Rust的Pwn实用工具
-
springtime-di
基于自动组件发现和运行时自动装配的依赖注入框架
-
arm-pl011-rs
PL011 UART驱动程序
-
swimos_future
SwimOS Future实用工具
-
retrier
适用于futures的wasm兼容的重试库
-
sodium
FRP（功能响应式编程）
-
decrypt-cookies
解密浏览器crate
-
sonor
控制Sonos扬声器
-
async-utf8-decoder
将AsyncRead转换为增量UTF8字符串流
-
singleflight-async
异步风格的Singleflight
-
tokio-muxt
用于有限事件的计时器，通过单个tokio Sleep实例进行多路复用
-
ticks
Rust的TickTick Open API的优雅包装器
-
tokio-rayon
使用Tokio + Rayon混合异步代码和CPU密集型线程池
-
hollywood
actor框架
-
tigerbeetle-unofficial
对tigerbeetle客户端库的安全的异步高级绑定
-
mio-extras
用于Mio的额外组件
-
interthread
Actor模型的自自动实现
-
lookit
异步连接到设备
-
tokio_based
基于Tokio的单线程执行调度器
-
pierport
Urbit pier导入协议实现
-
agnostik
一个无执念的执行器运行时，可以运行您喜欢的执行器中的未来任务
-
ordered-stream
相对于外部事件的有序流
-
background-jobs-tokio
基于Tokio的进程内作业处理器
-
futures-ratelimit
对futures' FuturesUnordered和FuturesOrdered进行限制的版本
-
futures-boring
基于BoringSSL的Futures SSL流
-
csnmp
基于社区的异步（Tokio）SNMP客户端库
-
conva_ai
用于使用CONVA AI Copilots的Rust SDK
-
sfio-tokio-ffi
用于在FFI环境中使用Tokio的oo-bindgen模型
-
remote_config
灵活的crate，用于异步地从远程源加载配置，具有缓存和自动重新验证功能
-
jni-utils
Rust中JNI的额外实用工具
-
mfio
灵活的完成I/O原语
-
taskalicious
常用的Rust任务工作者
-
slimproto
构建Slim协议客户端
-
tokio-util
与Tokio一起使用的附加工具
-
piscina
支持同步和异步的通用池
-
axum-limit
使用令牌桶进行速率限制的库，围绕基于提取器的异步Web应用的限制
-
streamline
基于futures::Stream的可逆状态机
-
safina-timer
安全的异步定时器
-
thread-waker
使用当前线程令牌的Waker实现
-
state_machine_future
轻松从状态机创建类型安全的
Future，无需样板代码 -
sparkle-convenience
Twilight的包装器，旨在使其更易于使用
-
async-fs
异步文件系统原语
-
kompact
将Kompics组件模型与Actor模型相结合
-
v-common-v8
veda平台通用部分
-
par-stream
类似于rayon的异步并行流
-
stream-reconnect
自动从潜在的断开/中断中恢复的Stream封装特性/结构体
-
suppaftp-cli
基于suppaftp的FTP命令行客户端
-
batch-channel
一次读取和写入多个值以减少开销的异步通道
-
airlock
无需std的异步通信
-
proxy-scraper
用于抓取代理信息的命令行工具
-
bsky-cli
使用ATrium API的Bluesky CLI应用程序
-
git-next-server-actor
git-next（基于分支的开发管理器）的服务器actor
-
disintegrate
构建事件源应用程序
-
twilight-standby
等待 Twilight 生态系统中的过滤事件
-
async-rate-limit
异步环境中速率限制的常见特性和实现
-
tower-fallthrough-filter
Tower 中间件，当过滤器匹配时控制定义的服务，否则降级到内部服务
-
gneiss-mqtt-aws
AWS IoT Core 专用的异步和线程 MQTT 客户端构建器
-
kapacitor-multi-indicator-stream-udf
Kapacitor 的多指标流 UDF
-
send-future
针对 https://github.com/rust-lang/rust/issues/96865 的舒适且性能良好的修复
-
txn
一个通用的乐观事务管理器，ACID，与 SSI（可序列化快照隔离）并发
-
reactor-trait
一组特质，用于定义跨反应器的公共接口
-
cbsk_socket_tokio
tokio 的套接字回调工具
-
swimos_trigger
SwimOS 异步触发器
-
agner
受 Erlang/OTP 启发的actor工具包
-
nolocal-block-on
futures_lite::future::block_on 无需使用线程局部变量即可运行
-
slings
基于 io-uring 的 Rust 异步运行时
-
pi_async
基于future（MVP），一个通用的异步运行时和工具，用于为外界提供基础
-
stackfuture
围绕 futures 的包装器，将包装的未来存储在调用者提供的空间中
-
danube-client
用于 Danube Pub/Sub 消息平台的异步客户端
-
baildon
B+树库
-
datacake
用于构建容错分布式数据系统的完整框架
-
rabbit_borough
通过绕过模板、配置和复杂的弹性逻辑，以最小的努力创建 RabbitMQ 消费者项目
-
pausable_future
可暂停和恢复的未来，在后台任务中很有用
-
tokio-shared
在动态库之间共享 tokio 运行时
-
zephyrus
一个用于与 twilight 一起使用的斜杠命令框架
-
rspack_futures
rspack futures
-
nature
开发支持平台，它将数据定义与代码分离，因此将数据从业务系统中解耦
-
upstox-rust-sdk
SDK用于以编程方式访问Upstox的Uplink v2 API
-
async_counter
实现等待特定值的future的计数器
-
future-local-storage
为线程局部值提供一次初始化的future单元格
-
gcp_access_token
纯Rust实现，用于获取具有服务帐户凭据的服务器的Google Cloud访问令牌
-
slacktor
非常快速、基础、开销低、无管理员的actor库
-
tokio-tasks
tokio的任务管理
-
kioto-serial
使用tokio提供串行端口I/O
-
napmap
异步哈希表，在请求的数据可访问之前暂停请求者的任务
-
minos
授权库
-
sched-callback
异步回调调度
-
tub
异步池
-
handle
异步上下文管道特质
-
emit_batcher
emit的批量处理基础设施
-
async-time-mock-smol
用于异步运行时的可模拟时间（与smol兼容）
-
ticque
为资源获取队列
-
fastcgi-client
Rust实现的Fastcgi客户端
-
next-gen
在稳定Rust上的安全生成器
-
lightspeed_logger
LightSpeed
-
batch-renamer
用于交互式重命名大量潜在文件框架和命令行工具
-
pistones
Piston代码执行引擎的包装器
-
pi_async_file
异步文件工具库
-
async-notify
通用版本的异步通知，类似于
tokioNotify，但可以与任何异步运行时一起工作 -
lending-stream
Stream的借用版本
-
par_io
一个无依赖项、控制内存使用的并行、异步文件I/O库
-
asyncified
一个小型库，用于在异步上下文中操作长期存在的同步值
-
apalis-cron
用于Rust的cron-like作业调度可扩展库
-
stakker_mio
Stakker crate的Mio I/O轮询集成
-
atticus
用于创建异步actors的简洁API
-
async-compat
tokio和futures之间的兼容性适配器
-
streamunordered
高效的异步流多路复用器
-
rx_rust_mp
使用消息传递方法实现的ReactiveX API的Rust原型实现
-
async_cell
可以await的Cell＜Option＜T＞＞
-
stdout-channel
将stdout写入异步队列
-
event-source
零成本异步立即事件分发
-
async-injector
Rust的响应式依赖注入
-
yield-progress
组合进度报告和协作任务让出
-
futures-scopes
运行时无关、可嵌套的用于生成非静态future的作用域
-
tokio-stomp
异步流STOMP客户端
-
future-iter
futures的迭代器工具
-
futures-io
为futures-rs库提供
AsyncRead、AsyncWrite、AsyncSeek和AsyncBufRead特质 -
rasi-mio
基于 mio 的 rasi 驱动程序实现
-
rusty_tarantool
基于 tokio 框架的 Tarantul 异步客户端
-
felicia
用于访问和共享不良行为者列表的服务
-
maelstrom-node
Maelstrom Rust 节点框架
-
sigio
基于信号异步 I/O
-
selectme
为异步 Rust 提供的一个快速且公平的选择宏
-
pwner
允许以优雅方式访问子进程的进程所有者 crate
-
readwrite
将读取和写入合并为单个 Read+Write 对象
-
slim-futures
旨在减小二进制大小的异步工具
-
selecting
跨平台的 select 包装器
-
peace_rt_model_native
Peace 自动化框架的运行时数据类型
-
pipebuf_websocket
PipeBuf对WebSocket的支持
-
kioto-uring-executor
tokio-uring的多线程包装器
-
tbot
用Rust轻松制作酷炫的Telegram机器人
-
raccoon_broker
消息代理实现
-
hala-io
hala异步IO编程原语类型
-
aiven_rs
与aiven-cloud api交互的SDK
-
spin_on
低效的Future执行器
-
nodecraft
为分布式系统提供节点标识和地址解析的基础特质的无缝节点操作
-
eyeball-im
基于
imcrate的可观察集合 -
tokio-lxi
为Tokio提供LXI协议抽象
-
rspl
一种流处理语言
-
islabtech-upw-sensor-v1
Rust客户端库，用于远程控制ISLabTech UPW传感器v1
-
fibers
基于futures和mio执行多个轻量级异步任务（又称纤程）
-
interprocess-docfix
进程间通信工具包。文档已修复。
-
futures_ringbuf
用于测试和示例的模拟类型，实现AsyncRead/AsyncWrite
-
izihawa-common-multipart
multipart/form-data
-
rw-deno_core
使用V8、Rust和Tokio构建的现代JavaScript/TypeScript运行时
-
capp
构建用于网络爬虫的Rust CLI工具常用的通用功能
-
openaction
为OpenAction API创建插件
-
memoverlay
在某个字节流上放置一个可写层的字节
-
async-compatibility-layer
用于同时使用async-std和tokio的抽象层
-
callback-result
帮助将回调函数获取结果的方法转换为await方法
-
tokio_delayed_queue
为Tokio运行时提供的异步延迟队列
-
noosphere-collections
满足 Noosphere IPLD 数据结构高效实现所需的数据类型集合
-
cbsk_run
异步池工具
-
lua_actor
Rust 的 Lua Actor（同步/异步）
-
async-raft
Raft 分布式一致性协议的异步实现
-
spaad
使用 xtra 的零样板actor系统
-
verge
一个实验性的actor库
-
openraft-memstore
实现了
openraft::RaftStorage特性的内存实现 -
parallel-future
流畅的异步任务实验
-
thin_main_loop
轻量级、跨平台的主事件循环。适用于原生GUI应用等多个用例的构建块。
-
rocketmq-rust
Apache RocketMQ 的非官方 Rust 实现
-
ruchei
处理多个流
-
egui_inbox
从异步函数、回调等发送消息到egui视图，无需使用内部可变性。
-
prometheus-utils
基于prometheus crate构建
-
async-cuda
Rust的异步CUDA
-
actix-daemon-utils
由actix提供的守护进程实用工具
-
aa-sms
使用Andrews & Arnold的SMS API发送消息
-
puteketeke
基于smol构建的异步运行时
-
terminal-wait-exit
等待用户退出终端，如Ctrl+C
-
tokio-stomp-rs
异步流STOMP客户端分支
-
maily
简单、快捷、容错的电子邮件发送
-
signalfut
类似于tokio::signal::unix::Signal的future，但可用于所有运行时
-
lutetium
基于tokio的简单actor库
-
stream-broadcast
运行时独立的广播，仅在无待处理数据时才轮询其底层流
-
prokio
一个与 WebAssembly 和非 WebAssembly 目标兼容的异步运行时
-
didcomm-rs
DIDComm 消息 v2 规范实现：https://identity.foundation/didcomm-messaging/spec/
-
containerd-client
containerd API 的 GRPC 绑定
-
stund
一个 SSH 隧道维护守护进程
-
channels-io
异步无关/同步 IO 及缓冲区管理抽象
-
peace-performance
osu! pp & stars 计算。和平版
-
cocoro
Rust 无栈协程的更类型安全的方法
-
async_zip_futures
使用 futures-rs 的异步 ZIP 归档读写 crate
-
flurx
创建反应式异步数据流
-
stream-ext
为 Streams 提供各种方便组合函数的扩展特质
-
taskmanager
管理后台任务组
-
backie
Rust应用程序的Tokio、Diesel和PostgreSQL后台任务处理
-
fundamentum-sdk-api
针对Fundamentum物联网设备的RestAPI的HTTP客户端
-
futures-waitmap
基于future的并发事件等待哈希表
-
craftio-rs
读取和写入mcproto-rs中定义的包到I/O接收器/发送器
-
scipio
一套工具，允许编写每个核心一个线程的应用程序
-
wrtc
webrtc-rs库的包装，专注于开发者体验
-
peekable
增强网络编程体验的读取器和异步读取器
-
ruva
基于事件的消息处理
-
async_progress
在异步任务间创建同步点
-
actix-signal
使用其地址管理actix演员的生命周期
-
plumbing
异步抽象，通过通道管道请求
-
无服务器
Rust中的actor模型，类似于actix
-
queen
消息队列
-
pingora-timeout
针对Tokio运行时的效率极高的异步定时器和超时系统
-
akinator-rs
围绕未记录的Akinator API的包装器
-
multi-readers
组合多个读取器
-
async-waitgroup
类似于Golang的WaitGroup实现，支持同步和异步Rust
-
mini-c-ares-resolver
基于mini-c-ares的异步DNS解析器
-
napi_async_local
扩展 napi-rs 以运行本地 futures
-
ianaio-dialogs
用于在浏览器中处理对话框的便利库
-
event_iterator
异步借贷迭代器
-
iroh-test
支持iroh测试的内部工具
-
deadpool-lapin
Dead simple async pool for lapin
-
nyantrack-common
为NyanTrack提供常见数据类型和功能
-
monoio-thrift
为Monoio提供的Thrift
-
screeps-async
为Screeps提供的tick感知异步运行时
-
tower-sessions-moka-store
为
tower-sessions提供的Moka会话存储 -
async-rustbus
基于rustbus的DBus协议的异步实现
-
gritlab
Gitlab Rust API SDK
-
async-nats-tokio-rustls-deps
使用Rustls的Tokio异步TLS/SSL流的分叉
-
ipc_channel_adapter
快速跨进程通信
-
negahban
🧐 一个简单的文件监视器，基于
notify，设计用于快速、易于使用且异步友好 -
serio
提供使用基于 serde 的格式无关序列化构建的 typed IO 特性和实用工具
-
abort-on-drop
Tokio 的 JoinHandle 的包装器，当任务被丢弃时终止任务，同时仍然允许它被等待以进行连接
-
futures-core
futures库的核心特性和类型 -
charred
字符检查
-
xactor
基于 async-std 的 actors 框架
-
xjbutil
为我自己的使用创建的 xjbly 实用库
-
syndicate
为 Rust 提供的代理 Actor 模型，包括网络通信和 Dataspaces
-
tor-log-ratelim
Arti 中限制日志消息速率的设施
-
starbase_events
异步和可变的事件系统
-
adventure
您的伟大冒险，针对各种类型请求
-
acu
构建异步 actors
-
rt-local
与平台特定的事件循环协同工作的线程局部异步运行时
-
极端
极无聊的异步函数运行器。MIT/Apache-2.0 许可证适用于 spacejam 的 GitHub 赞助商。
-
aral
异步运行聚合层
-
async_tasks_recorder
用于记录异步任务执行状态的异步方法结构体
-
futures-test
用于测试基于 futures-rs 构建的组件的通用工具
-
miau
异步感知的可扩展分层配置系统
-
textmode
基于真实终端解析器的终端交互库
-
sc2
星际争霸 II 客户端 API
-
async-rayon
使用 Futures + Rayon 将异步代码与 CPU 重的线程池混合
-
zookeeper-cache-rust
ZooKeeper客户端缓存
-
erl_dist
Erlang 分布协议
-
smolscale
高性能异步任务调度器
-
terminusdm
Terminus下载管理器。下载文件，恢复中断的下载，并在终端UI中保留下载历史。
-
async-http1-lite
异步http1流
-
情境
持续运行闭包，直到成功或超时
-
passivized_docker_engine_client
Docker引擎客户端 - 管理和运行容器、镜像和卷
-
swiftide-query
专为AI应用设计的快速流式管道库
-
peachy
异步任务管理器，类似于线程池但更酷，适用于结构体
-
goods
异步资源系统
-
livekit-runtime
LiveKit的异步运行时兼容层
-
curseforge
CurseForge核心API的简单异步包装。公共API在1.0.0之前可能会更改。
-
fil_builtin_actors_builder
内置Filecoin角色的WASM构建器
-
eventastic_postgres
为eventastic提供的一个示例PostgreSQL事件存储
-
redis-work-queue
一个基于Redis数据库的工作队列，支持Python、Rust、Go、Node.js（TypeScript）和Dotnet（C#）的实现
-
clia-rcproxy
使用Rust编写的轻量级、快速且强大的Redis集群代理
-
circulate
支持同步和异步的轻量级PubSub框架
-
fluke-io-uring-async
在io-uring之上的抽象
-
reusable-box-future
一个可重用的
Pin<Box<dyn Future<Output = T> + Send>> -
libuio
为Linux上高性能网络设计的一个基于io_uring的异步框架
-
tokio-task-manager
允许异步Tokio应用程序优雅地关闭，等待所有任务完成
-
yield-now
唤醒当前任务，并返回Poll::Pending一次
-
background-jobs-sled
background-jobs的后端存储，使用Sled
-
luis_sys
Microsoft LUIS API 的 FFI 绑定
-
tokio-stomp-2
异步流 STOMP 客户端的非官方后续版本
-
xitca-io
异步网络 I/O 类型和方法
-
moxie
交互式软件的增量运行时
-
swait
在 Future 上阻塞
-
tokio-zmq
在 Tokio 事件循环上对 ZeroMQ 的 Future 抽象
-
this-state
以线程安全的方式存储状态的方法，以及异步等待状态变化的方法
-
async-minecraft-ping
Minecraft ServerListPing 协议的异步 Rust 客户端
-
tokio-socketcan
使用 tokio 的异步 Linux SocketCAN 套接字
-
handy_async
描述异步代码的便捷库
-
cb_fut
通过回调函数返回值而不使用回调函数调用的函数
-
liteapi
litestorm 创建 REST API 的服务
-
二氮烯
Rust 的 Actor (使用 Tokio)
-
栈式
同步和异步之间的桥梁
-
async-gate
由 Tokio 驱动的异步门（类似于标志，并高度受到 Python 的
asyncio.Event的启发，但也等待变为 'false'） -
ruw
读取-更新-写入
-
tokio-stomp-rs-rs
异步流STOMP客户端分支
-
spawns
Rust 的异步运行时无关的线程上下文任务生成器
-
tokio-file
为 Tokio 提供的异步文件 I/O
-
kumoko
基于 tokio 的异步服务器/客户端 crate，易于双向流
-
zeebest
未来非官方的 zeebe 客户端！
-
async-recorder
在不等待您的持久化后端的情况下存储记录
-
flo_stream
为 Rust futures 提供的 pubsub 和相关流
-
saas-zmq
使用发布-联盟的 ZeroMQ 工具
-
monoio-native-tls
基于NativeTLS的Monoio异步TLS流包装器
-
tk-listen
一组辅助future，允许在资源限制和适当的错误处理下监听TCP（或Unix）套接字
-
tokio-serde-cbor
将serde_cbor集成到tokio-io中，允许在网络（可能通过其他传输）中发送CBOR编码的帧
-
aide-de-camp
无后端延迟作业队列
-
async-priority-channel
一个异步通道，其中待处理消息按优先级顺序交付
-
tracing-orchestra
给我更多的工具！
-
futures-stream-ext
为futures(-core) crate提供的异步流扩展
-
callbag
响应式/可迭代编程规范
-
bean_factory
bean工厂，支持注入引用bean
-
nsq-client
Rust客户端用于NSQ实时消息处理系统
-
abstract-ns
用于futures（和tokio）的抽象名称服务trait
-
dabus
动态应用程序控制总线 - 一个异步、基于事件的模块系统，适用于那些想要快速移动且不破坏事物的人
-
uid-mux
异步多路复用库，提供用户自定义的流ID
-
stream-guard
Stream的RAII包装器，在释放时调用自定义操作
-
tokio-bitstream-io
bitstream-io的Tokio端口：用于在大小端格式中从/到流读取/写入未对齐值的库
-
arangoq
为Rust提供的AQL查询构建层和ArangoDb客户端
-
async-sleep
异步睡眠
-
foreback
用于在后台运行额外工作的Future适配器
-
async-send-fd
异步UnixStream的包装器，用于发送文件描述符
-
pick_action_from_image
从图像中选取操作
-
monoio-compat
为monoio提供的兼容包装器
-
bb8-lapin
r2d2-lapin，但适用于基于异步Tokio的连接
-
lazy_async_pool
一个动态生成对象的异步对象池
-
futures-delay-queue
基于async-std和futures-timer的异步延迟队列
-
io_tee
将Tee Read、BufRead和Seek实例写入到写入器
-
fbinit-tokio
fbinit crate的详细信息
-
delimiter-slice
分割分隔符流的数据流类型
-
tower-sessions-rusqlite-store
(tokio-)rusqlite会话存储库，用于
tower-sessions -
hikvision-rs
使用PTZ API控制Hikvision相机的异步高级库
-
lifeline
适用于异步基于消息的应用的依赖注入库
-
shutdown-handler
允许应用程序的所有部分触发关闭的关闭处理程序
-
async-variadic
使用trait bounds的Rust异步可变函数
-
flo-state
轻量级actor库
-
constellation-internal
constellation框架的通用组件
-
futwaiter
能够一次性完成所有 Future 的容器
-
async_msp_cli
用于 iNav 和 BetaFlight 的异步 msp 命令行工具
-
paperless-rs
用于 Paperless-ngx 文档管理器的异步 Rust 库
-
ilgda-ipc
用于 ilgda 的 IPC 标准
-
smelling_salts
异步设备唤醒的 OS API 抽象
-
nextgraph
客户端库。Nextgraph 是基于语义网和 CRDTs 的去中心化、安全且以本地为中心的 Web 3.0 生态系统
-
tourniquet
用于远程服务的异步原生化轮询管理器
-
libaio-futures
使用 Futures/async/await 的简单 Linux AIO
-
taps
taps（Tokio 异步发布/订阅）是一个进程内异步消息代理，可用于在派生的 tokio 任务之间进行消息传递
-
linkd
受 Elixir 生态系统中的 OTP 启发的actor模型框架
-
arta-tokio
为Tokio提供的异步抽象实现
-
msft-runtime
Windows异步辅助工具
-
onetime
(又称oneshot) 异步 spsc 通道
-
hypixel_api
hypixel api的通用包装器（客户端自动限速）
-
makepad-futures
Makepad futures
-
glib-signal
GObject 信号绑定
-
dialectic
Rust的传输多态、异步会话类型
-
streams
缺失在
futurescrate 中的流扩展集合 -
heph
基于异步函数的actor框架
-
Agentic-rs
agents包提供了一组创建和管理能够处理文本并根据指定角色执行指定任务代理的工具。它利用异步... -
future-utils
Rust的Future和Stream特质的扩展
-
dioxus-v04-optional-hooks
Dioxus 0.4.0-0.4.3 中的可选未来
-
async-observable
用于保持多个异步任务/线程部分同步的异步和响应式同步模型
-
libsync
包含通道和其他同步对象实现
-
orsomafo
事件分发器库
-
gw2api-rs
官方《Guild Wars 2》API 的异步包装器
-
wasmcloud-test-util
wasmcloud 的测试工具和实用程序
-
cntrlr
异步嵌入式框架
-
hls_lfcd_lds_driver
Rust 驱动程序，用于 ROBOTIS HLDS HLS-LFCD-LDS (LDS-01)
-
msq
旧版主服务器查询协议
-
cbsk_socket_rayon
rayon 的套接字回调工具
-
dmds-tokio-fs
Dmds I/O 处理器通过 Tokio 与文件系统交互
-
runtime-winit
异步的 winit 运行时
-
waitgroup
异步 waitgroup 用于等待一组任务完成
-
tokio-graceful-shutdown-without-anyhow
在基于Tokio的服务上执行优雅关闭
-
tokio-stdin-stdout
基于线程和 future::sync::mpsc 的 AsyncRead/AsyncWrite stdin/stdout，具有少量缓冲
-
io_uring_buf_ring
帮助用户创建和管理 io-uring 缓冲区环
-
uring-fs
使用 io-uring 的真正异步文件操作。支持任何异步运行时。仅限 Linux。
-
xilinx-dma
用户空间的 Xilinx AXI DMA 接口
-
stream_router
一个感知 Future 的路由器，用于在 Streams 和 Sinks 之间动态路由
-
oneshot-handshake
提供一种对称的一次性使用通道类型
-
uringy
基于 io_uring 的 Rust 单线程并发运行时
-
susync
一个通过句柄完成 futures 的实用程序 crate。其主要目的是在异步 Rust 和基于回调的 API 之间建立桥梁。
-
side-futures
将未来发送到可能在不同线程上运行的运行时执行
-
async-result
基于futures-channel的单次通道，提供了一个方便的方式等待结果
-
rendezvous
简化线程同步的会合通道
-
cannyls_rpc
用于从远程节点操作cannyls设备的RPC库
-
notify-future
支持异步通知完成未来
-
rust-rsm
RSM：实时软件中间件框架。异步、事件驱动框架
-
linked-futures
将未来链接成一个块，当任何一个未来完成时，停止所有包含的未来
-
prevayler-rs
在rust中的系统普遍性
-
message-sink
为AsyncRead + AsyncWrite提供消息封装
-
tokio-socks
为Rust提供异步SOCKS代理支持
-
openai-api
OpenAI API的Rust库
-
fluvio-async-tls
使用Rustls的异步TLS/SSL流
-
随机访问存储
实现随机访问实例的抽象接口
-
kapacitor-multi-indicator-batch-udf
Kapacitor的多指标批处理UDF
-
rabbit_mqr
极简RabbitMQ客户端
-
async-mavlink
mavlink连接的异步适配器
-
evdev-shortcut
使用evdev的全局快捷键
-
swarm-commander
异步管理大量命令
-
awaitable
具有输入和输出且可存储在容器中的类型
-
bufstream
用于流的缓冲I/O，其中每个读写半部分分别缓冲
-
task-group
管理tokio任务组
-
radix-router
httprouter的Rust端口
-
async-lazy
在首次访问时初始化的值，使用异步函数
-
rlua-async
通过协程为rlua提供异步支持
-
nu-stream
Nushell流
-
rust_howto
Rust语言及其生态系统的文档摘要和片段汇编。所有日常Rust编码所需的一切，都在一个地方。
-
peermerge
使用点对点协议，通过多个作者管理类似JSON的文档，无需中央权威机构
-
viaduct
使用无名管道在父进程和子进程之间建立双向通信通道
-
packet-ipc
使用servo ipc在服务之间共享数据包
-
epicenter
Rust的同步和异步事件调度器
-
qbit-api-rs
qBittorrent Web API的异步Rust包装器
-
read-progress-stream
跟踪读取的字节数的流读取器包装器
-
async-xml
异步反序列化XML数据
-
cxx-async
C++协程与异步Rust的互操作性
-
peace_cmd
Peace框架的命令结构
-
async_singleflight
异步单次飞行
-
murray
使用Tokio的极简actor定义宏
-
tokio-stream_wasi
与
Stream和tokio一起工作 -
ruchei-route
具有路由的汇流
-
vents
事件系统
-
automerge_repo
automerge-repo
-
tokio-async-drop
在tokio多线程运行时启用异步丢弃的宏
-
async_monad
Rust的异步monad
-
futuristic
对futures crate的扩展
-
reception
创建提供模型抽象层的TCP监听器
-
fork_stream
克隆任何流
S，其中<S as Stream>::Item: Clone -
blec
基于btleplug的跨平台ble客户端库
-
any-mpsc
允许任意类型通过的多生产者单消费者（mpsc）
-
visiting_ref
容器类型，在退出作用域时异步将值的所有权返回给另一个上下文
-
bonsaimq
基于bonsaidb的消息/作业队列，类似于sqlxmq
-
pirates
异步RPC库
-
piston_rs
Piston代码执行引擎的异步包装器
-
untokio
自动创建tokio运行时
-
parity-runtime
Tokio运行时包装器
-
tokio-libtls
LibreSSL的libtls的Tokio绑定
-
tokiactor
基于tokio的Actor框架
-
lichess-api
Lichess API v2.0.0的客户端
-
multiqueue2
快速的多生产者多消费者广播队列
-
libevent
Rust 对 libevent 异步 I/O 框架的绑定
-
in-keys
在方便的
Terminal构造中利用流 -
completion
编写基于 completion 的异步代码
-
async-executor
异步执行器
-
proxycurl-linkedin-rs
Proxycurl LinkedIn API 的客户端
-
minimal-executor
基于 futures-rs 库的最小执行器，用于异步任务
-
egui_task_manager
轻松管理异步任务
-
async-usercalls
SGX enclaves 中异步用户调用的接口。这是一个仅适用于 SGX 的 crate，您应该使用
x86_64-fortanix-unknown-sgx目标进行编译 -
stow
Rust 的云存储抽象包
-
ractor_cluster
Ractor actors 的分布式集群环境
-
mias_channel
通过包装其他方式支持双向通道
-
loading-bytes
从本地和WASM上的路径加载字节
-
agent_rt
代理调度
-
amqp-lapin-helper
rust lapin 辅助工具
-
paho-mqtt-sys
低级、不安全的Rust包装器，用于Paho MQTT C客户端库。这是官方Eclipse Paho Rust客户端库的一部分
-
alan-runtime
Rust运行时，用于运行AGC或Alan Graphcode，alan的字节码格式
-
tokio-lk
Future感知的按ID锁定原语
-
handoff
一个无缓冲的、异步的、单生产者/单消费者通道
-
blocker
阻塞Rust futures以创建异步API的同步包装器
-
wasmflow-packet
封装通过Wasmflow组件发送的消息包
-
libublk
在用户空间构建Linux块设备
-
app_ctx
Rust中的AppCtx实现，类似于SpringBoot中的ApplicationContext
-
auto-future
通过异步函数快速将结构体转换为future
-
webhttp
-
mediator
Rust中的模式
-
killswitch
用于广播关闭请求
-
cs-utils
通用工具
-
hds_console-api
测试crate，请勿使用
-
tiny_future
Condvar基于的future，支持自动取消 -
roux-stream
roux Reddit客户端的流式API
-
rumpsteak
多方异步通信的会话类型
-
cancellable
提供通用的可取消工具
-
limitation
使用基于固定窗口计数器的速率限制器，用于任意键，由Redis支持
-
tidy-browser
整理浏览器信息
-
quick_crawler
QuickCrawler 是一个 Rust 库，提供完全异步、声明式的网络爬虫，内置了特定领域的请求速率限制。
-
async-graphql-derive
为 async-graphql 提供宏
-
futures_cbor_codec
为使用 serde 可序列化的所有类型，使用 cbor 对 AsyncRead/AsyncWrite 进行封帧的编解码器
-
elegant-departure
简化优雅关闭
-
async-copy-progress
带有进度回调的异步复制
-
tracing-actix
允许在 actix 中跟踪 actor futures
-
specta
轻松将 Rust 类型导出到其他语言
-
zellij-utils
Zellij 客户端和服务器
-
async_closure
利用 nightly-only 特性 async_fn_in_trait 来模仿异步闭包
-
newsblur_api
NewsBlur-API
-
tokio-executor-trait
为 tokio 实现executor-trait
-
heph-inbox
设计为actor邮箱使用的有界容量通道。也支持一次性通道。
-
coachman
基于tokio框架构建的Rust异步任务管理器
-
mak
但让它更快
-
async-tls
使用Rustls的异步TLS/SSL流
-
simple-scheduler
异步运行周期性任务
-
catalyzer
HTTP服务器框架
-
foxhole-api
Foxhole War API的包装器
-
tokio-tar
异步TAR文件读写器。此库目前不处理压缩，但它抽象了所有I/O读取器和写入器。此外，还采取了极大的努力以确保整个……
-
dyn-future
为Rust提供方便且快速的动态Futures
-
fb_futures_01_ext
future 0.1存储库的扩展
-
jittr
基于二叉堆的抖动缓冲区实现，用于零延迟udp/rtp流
-
compio驱动程序
compio的低级驱动程序
-
tokio-util_wasi
与Tokio一起使用的附加工具
-
wasmer-wit-bindgen-rust
wit-bindgen-gen-c
-
rio_rt
一个最小的异步运行时，具有实验性的便携性和互操作性异步运行时目标
-
pakr-fsm
实现有限状态机的模板
-
quickwit-actors
quickwit使用的actor框架
-
tauri-specta
完全类型安全的Tauri命令
-
futures-signals-ext
futures-signals的扩展：具有组合器、启动、由谓词驱动的从SignalVec中选择的选择
-
tokio-easy-timer
一个基于tokio的任务调度器，具有用户友好的API
-
tokio-udev
对udev设备事件的非阻塞/异步Tokio支持
-
fluffici_clamav-client
ClamAV客户端库
-
futures-async-stream
Rust 和 futures crate 的异步流
-
slog-scope-futures
为
Future设计的slog-scope -
awesome-operates
包含许多常用代码工具的仓库
-
futures-timeout
为 futures 和 streams 提供超时功能
-
speedracer
比较 futures 的速度并排名结果
-
raft-lite
Raft 一致性算法的易懂实现
-
nonblock
从文件描述符读取可用数据而不阻塞（例如套接字、流、子进程标准输出、命名管道）
-
strawpoll
一个包装器，用于避免虚假轮询
-
tokio-process-stream
将 tokio::process 包装成 tokio::stream
-
rexecutor-sqlx
一个健壮的作业处理库
-
tokio-duplex
将单独的
AsyncRead和AsyncWrite类型合并为一个单一的AsyncRead + AsyncWrite类型 -
streammap-ext
基于Tokio的StreamMap，修改了
next，当流被丢弃时返回 -
trillium-tokio
trillium.rs的tokio运行时适配器
-
futures_codec
使用
async/await进行帧的编码和解码 -
tokio-shutdown
在多个线程中等待停止信号
-
safina-threadpool
安全线程池
-
mini-c-ares
基于rust-c-ares的c-ares库的最小Rust包装器，用于异步DNS请求
-
terrars-integrations-github
预生成的Terrars Github绑定
-
awaitgroup
等待一组异步任务完成
-
teloxide-core
teloxide库的核心部分 - 电信机器人API客户端 -
async-ctrlc
ctrlc的异步包装器 -
eyeball-im-util
eyeball-im -
gentian
将生成器转换为状态机的 proc macro
-
try-again
重试同步和异步操作
-
alopecosa
基于 tokio 的纯 Rust 异步 Tarantool 1.6+ 连接器
-
deferred
帮助执行代码逻辑的延迟执行
-
heim-cpu
跨平台 CPU 信息
-
sparkle-impostor
Twilight 的第三方 crate，用于执行 Discord webhooks 以克隆现有消息
-
agreed
async-raft 的分支，基于 Tokio 的 Raft 协议的 Rust 实现
-
peace_rt_model
Peace 自动化框架的运行时数据类型
-
async-sse
异步服务器发送事件解析器和编码器
-
js-sys-futures
与 futures 和 js-sys crate 一起工作
-
tokio-socketcan-bcm
使用 tokio 的异步 Linux SocketCAN - 广播管理器支持 (BCM)
-
aktors
derive-aktor 的驱动程序
-
enstream
从Future到Stream的转换
-
swimos_byte_channel
SwimOS 字节通道
-
wait-for-me
异步计数信号量
-
split-stream-by
将Stream按照谓词分割的Stream扩展crate
-
rust-with-kafka-tls
使用自签名TLS资产加密的Rust消息与Strimzi Kafka集群，使用mTLS进行客户端身份验证
-
stellwerksim
StellwerkSim的Rust SDK
-
hala-future
hala异步编程的原始类型
-
async-scgi
异步SCGI客户端和服务器
-
dstream
延迟流 - 延迟项目并在给定间隔内删除相同的项目
-
switchboard
通过队列和唤醒器启用进程间通信
-
async-read-progress
用于检查
AsyncRead进度的扩展特质 -
to_bytcp
一个用于在TCP流中发送消息的小型库
-
spawn_groups
用Rust编写的结构化并发构造，适用于Rustaceans
-
bastor
一个包装器，有助于使用Bastion实现actor，并具有自实现的state
-
simple-middleware
通用中间件crate
-
rtbase
异步运行时基础代码
-
raftlog
基于Raft算法的分布式复制日志
-
io-tubes
类似于pwntools tube的异步io功能，用于Rust
-
async-io-converse
可以与任何与serde兼容的类型进行AsyncRead或AsyncWrite类型的会话
-
must_future
标记为must_use的包装器future - 主要用于包装BoxFutures
-
asyncs
与异步运行时不相关的设施
-
async_wasm_task
管理WebAssembly Rust中异步任务的并发性
-
buffer-unordered-weighted
Stream::buffer_unordered，其中每个future可以有不同的权重
-
histlog
hdrhistogram crate，提供离线程序列化 HdrHistogram 间隔日志到文件
-
dialectic-compiler
Dialectic crate 的会话类型宏编译器
-
futures-time
异步时间组合器
-
async_async_io
AsyncRead，AsyncWritetraits 但具有async fn方法 -
arti-rpcserver
Arti RPC 服务的后端功能
-
co_managed
创建管理子协程。父进程退出时，管理子协程将被取消
-
pi_async_buffer
异步缓冲区用于 IO
-
madsim-tokio
madsim 上的
tokio模拟器 -
bp3d-threads
旨在简化 BP3D 中并发的线程库
-
async-object-pool
仅使用异步同步原语实现的对象池
-
happyeyeballs
在 Tokio 中实现 Happy Eyeballs（目前不符合 RFC 规范）
-
pantry
可能衰减值的临时存储
-
futures-io-preview
为 futures-rs 库提供的
AsyncRead和AsyncWrite特性 -
mysql_async
基于 Tokio 的异步 MySql 客户端库
-
tokio-childstream
将 tokio::process::Child 转换为用于 stdout、stderr 和退出事件的 Stream
-
pipebuf_mio
为
mio字节流提供 PipeBuf 支持 -
poolparty
为 futures executor 的
futures::executor::ThreadPool添加功能 -
agner-actors
受 Erlang/OTP (actors) 启发的 actor 工具包
-
gossip-relay-picker
用于 gossip 的 nostr 中继选择器
-
bb8-bolt
bb8 连接池的 bolt-client 适配器
-
viz-utils
可视化工具
-
gcs-rsync
比 gsutil rsync 性能更高的 gcs rsync 支持
-
maybe-future
可以是 None 的 Future
-
xtra-addons
为 crate xtra 提供的附加功能（代理，注册表）
-
rants
异步 NATS 客户端库
-
stream-kmerge
流的多路归并
-
tokio-extra-macros
Tokio 的额外 proc 宏
-
rocketmq-runtime
Apache RocketMQ 的非官方 Rust 实现
-
acril-rt
Acril 实现的轻量级单线程运行时
-
axiom
实现了基于 Erlang / Elixir 和 Akka 的最佳实践的 Rust 高度可扩展和易于使用的actor系统
-
dialtone_common
Dialtone 通用代码
-
async-file-lock
支持自动锁定和自动查找的异步文件锁定
-
webrocket
一个以闭包为核心的 WebSocket 服务器实现
-
contained-actors
contained 是一个研究项目，实现了用于编排云原生系统的建议的谐波运行时
-
bytes-stream
处理字节流的功能
-
laizy
惰性值的稳定且线程安全实现
-
ebus
基本事件总线实现
-
pochta
可寻址通道注册表
-
geph4-aioutils
geph4
-
async-select-all
用于选择多个未来的未来库适配器
-
git-event
针对远程Git仓库更新可定制的事件处理器
-
async_tasks_state_map
用于记录异步任务执行状态的异步方法结构体
-
plctag-async
libplctag的异步包装器
-
event-listener-strategy
轻松阻塞或轮询事件监听器
-
xtor
Rust的异步Actor框架，速度快且稳定可靠
-
tokio_interval
基于Tokio实现了setInterval(callback, ms)和setTimeout(callback, ms)，类似于JavaScript的API
-
spekt
基于std::future::Future和Result的测试特质，用于管理有状态异步测试的生命周期
-
salvia
将增量计算带到异步Rust
-
compio-buf
基于完成异步IO的缓冲区特性和
-
riker-cqrs
Riker应用程序的命令查询职责分离
-
async-rx
异步响应式编程函数
-
multiqueue
快速的多生产者多消费者广播队列
-
pi_futures
功能选择
-
tcp-channel-client
基于 aqueue 代理的异步 tcpclient
-
async_message_dispatcher
简化将消息分配给异步处理器的过程
-
futures-net
futures-net 库
-
clap-and-async-test
使用 clap 与 tokio 和 futures 的示例，如何在循环中并发运行一些函数
-
dwbhk
dwbhk-rs 是一个用于处理 Discord Webhooks 的库
-
russh-agent
异步 ssh-agent 客户端
-
fs-mel
Mélodium 核心文件系统交互库
-
rotor
使用 mio 进行 I/O 操作的简单且可组合的框架
-
rad
使用 ceph-rust 的底层 C 绑定提供的类型安全、高级接口访问 librados
-
ksoft
使用纯 Rust 编写的 KSoft.SI api 包装器
-
retry_future
重试 future 机制
-
sidekiq-rs
Rust 中的 Sidekiq 兼容服务器
-
fut_rwlock
通过 Futures 实现的读写锁
-
service-io
快速、轻松地构建你的服务服务器（无需托管！）
-
eventador
提供同步和异步 API 的无锁 pub/sub 事件总线
-
async_io_crypto
处理带有加密/解密的异步读取
-
rmw_ttlmap
支持键过期功能的 Rust 最小异步缓存
-
tower-actor
通过将消息传递给演员创建
Service的tower中间件 -
tezaursapi
tezaurs.lv 的 api 包装器
-
select-next-any
select_next_some 的替代方案，返回 None 变体
-
amqp
AMQP/RabbitMQ 协议客户端
-
async-log
为 log crate 提供异步跟踪功能
-
qp
Quick Pool：高性能异步通用池
-
tigermq
Rust 的消息队列和批量处理
-
simple_futures
用于异步操作的 futures
-
smol
一个小而快的异步运行时
-
blockz-futures
为 tokio 堆栈使用 futures
-
gabelung
将可克隆项的异步流分支为两个
-
streamtools
额外的流组合器
-
tokio-switching-sleep
具有可切换状态的 tokio Sleep
-
named-retry
重试可失败异步操作
-
xo-api-client
通过其API访问Xen Orchestra的非官方crate
-
rsdns
DNS客户端库
-
rqlite-ha421
rqlite客户端的异步实现
-
crate-test-xxx
测试crate
-
reactive-messaging
面向高性能的反应式客户端/服务器通信
-
abcperf-minbft
将MinBFT集成到ABCperf中
-
futures-diagnose
围绕Spawn提供大量诊断信息
-
future-clicker
不使用
futures不稳定版本的manual_future重实现 -
unsend
为线程不安全的人提供的线程不安全运行时
-
elfo-test
elfo系统的测试工具
-
async-refresh
创建在给定时间后自动异步刷新的值
-
framed_aio
允许以封装方式执行异步I/O操作
-
tag_nominatim
绑定到由 openstreetmap 提供的反向地理编码 API
-
mio-uds
为 mio 提供 Unix 域套接字绑定
-
async-spin-sleep
使用自旋睡眠在一个线程中为多个异步任务提供高度精确的异步定时器
-
toy-async-runtime
Toy 库，用于开始使用 async rust，为鲁莽的人构建！
-
flv-future-aio
Fluvio 项目中的 I/O 未来
-
eventsource-stream
构建基于字节数据流的 Eventsource 的基本构建块
-
async_object
异步对象包装器
-
ianaio-file
用于处理 JavaScript 文件和 blob 的便捷 crate
-
merge-io
将两个独立的
AsyncRead和AsyncWrite对象合并为一个 I/O 流 -
tokio-global
全局 tokio 运行时
-
tower-util
使用
Service -
scd4x-rs
通过 I²C 查询 SCD4x 传感器
-
reactors
专注于性能的跨平台异步 IO 实现
-
interval_future
将同步、无唤醒者的轮询函数包装在基于间隔的未来中
-
telegram-bot-ars
创建 Telegram 机器人
-
andiskaz
TUI 中编写游戏和其他应用的便利库
-
tokio-netstring-trait
一个 trait，用于 tokios AsyncRead 从流中轻松读取 netstrings
-
intercomm
异步组件间通信库
-
sender-sink
用于处理 tokio UnboundedSender 和 Sink trait 的类
-
ert
控制未来执行顺序的 combinator
-
rust-stream-ext-concurrent
任何 futures::stream::Stream 对象的并发行为扩展
-
zeebe
用于定义、编排和监控跨微服务的业务流程的 Zeebe 客户端
-
simple-async-pipe
旨在为异步代码提供简单的管道功能
-
asynciter
异步迭代器
-
async-handle
一个引用计数的异步RwLock
-
agner-sup
受Erlang/OTP（supervisors）启发的actor工具包
-
crb-core
CRB | 可组合运行时块 | 核心模块
-
sched-clock
任务调度定时器
-
italo-api
Rust对Italo API的绑定
-
rs-copier
异步复制和移动文件
-
async-consul
基于Tokio的Rust Consul客户端
-
futures-rate
易于使用的工具，帮助Rust应用程序引导关键资源或代码路径免受过度负载
-
mlua_actor
Rust 的 Lua Actor（同步/异步）
-
waitlist
跟踪要唤醒的有序Wakers列表
-
rustpub
Activitypub类型
-
snarc
可发送的非原子引用计数
-
felixs-tower-lsp
基于Tower的Language Server Protocol实现
-
task-stream
一个全局任务执行器，在
no_std中运行 -
pseudoterminal
具有异步支持的跨平台伪终端实现
-
tokio-scoped
tokio的Scope运行时
-
openai-api-fork
OpenAI API的Rust库
-
fb-api
为异步Rust提供的Facebook API抽象
-
requiem
Rust的Actor框架
-
cooper
进程内、异步Actor库，用于Rust
-
unblock
用于隔离异步程序中阻塞的线程池
-
async-anyhow-logger
一个简单crate，用于从异步函数中捕获anyhow错误，并将它们传递到您的日志记录器
-
eventsourcing
Rust的事件源
-
dbus-async
异步DBus库
-
async-timers
异步定时器原语
-
async-ringbuffer
具有固定容量的非阻塞 spsc 环形缓冲区
-
broadcaster
广播 futures mpmc 通道
-
async-jobs
Rust 的异步工作编排
-
sntpc
发送 SNTP 请求
-
f189ctrl
Fluke 189 数字万用表的通信库
-
riker-patterns
Riker 的常见 actor 模式的集合
-
tokio-uring-rustls
将 rustls 集成到 tokio-uring 中
-
async_chanx
为某些通道实现实现
Sink -
futures-zmq
在任何 futures 执行器上对 ZeroMQ 的未来抽象
-
one_for_one
监督生成的异步任务
-
async-macros
async-std 的宏
-
type-toppings
对标准类型的有意见的扩展
-
future-combinator-params
用于在future组合器Then/AndThen之间注入额外参数的函数
-
c_mcai_worker_sdk
用于监听和处理消息的AMQP Worker
-
actix-postgres
Actix框架的PostgreSQL集成
-
gcp_auth
使用默认和自定义服务账户进行Google云平台（GCP）身份验证
-
promise
rust的future/promise库
-
safina-executor
安全的异步运行时
-
change_stream
只有当值不同时才发出值的流
-
eventific
提供事件源所需构建块的工具
-
blocking-permit
用于阻塞操作的许可和线程池
-
lib3h_zombie_actor
lib3h actor 请求跟踪模块
-
stateful_async_worker
可作为futures使用的异步有状态工作线程
-
reqchan
请求和接收数据的通道。每个通道只有一个请求端，但可以有多个响应端。对于实现工作共享很有用。两端...
-
volo-macros
Volo的进程宏
-
broker-tokio
为代理使用tokio
-
medea-reactive
反应式可变数据容器
-
scoped_async_spawn
创建非静态future
-
async-native-tls-alpn
使用futures的本地TLS
-
alligator
从future获取输出值
-
rivulet
异步连续内存流
-
termion-input-tokio
将termion的输入和键事件迭代器公开为异步流的适配器
-
medina
异步网络爬虫引擎
-
coerce-k8s
Kubernetes发现提供者，基于可配置的pod选择标签自动发现托管在Kubernetes中的集群对等体
-
futures-test-preview
用于测试基于 futures-rs 构建的组件的通用工具
-
futures-util-either
futures_util::future::Either Ext
-
mailbox_processor
受FSharp Mailbox Processor启发的轻量级actor抽象，后者又受erlang启发
-
embedded-hal-async
嵌入式系统的异步硬件抽象层（HAL）
-
messagebird-async
对message bird SMS API的包装
-
mrwei
实现了基于std future的通用promise原语
-
future_handles
通过句柄完成futures
-
heim-common
heim项目crates间共享的通用功能
-
async-lease
基本上是一个面向futures的Arc
-
crown
rust库的宝石
-
tourniquet-celery
远程服务的异步原生轮询管理器。celery集成。
-
tokio-uds-proto
与tokio-proto一起工作的Unix域套接字
-
anotify
异步iNotify文件系统监视器
-
tokio-rustls-wasi
使用 Rustls 的 Tokio 异步 TLS/SSL 流
-
manual_future
必须手动完成的future，类似于Java的CompletableFuture
-
tokio-nsq
基于Tokio构建的NSQ客户端。Tokio NSQ旨在成为一个功能完整的NSQ客户端实现。
-
actix-storage-sled
基于sled的actix-storage
-
futures-sink
为futures-rs库提供的异步
Sinktrait -
kythera-fvm
Kythera FVM的核心实现
-
rexer
rust的异步I/O复用库
-
tokio_telegraf
基于Tokio的最小异步rust包装器，用于telegraf/influxdb协议
-
bluest
跨平台的低功耗蓝牙（BLE）库
-
yaanhyy_rust
cargo mod示例
-
appliance
一个轻量级的框架，用于使用基于消息的交互构建异步友好的组件
-
hermod
基于futures的RSS/Atom库
-
wakerpool
轻量级Waker列表对象池
-
swimos_runtime
SwimOS代理及下行运行时
-
act-zero
人体工程学actor系统
-
eventually-postgres
使用PostgreSQL实现Event Store的 Eventually crate
-
gnostr-core
Hypercore feed的复制协议
-
async-gen
使用async/await的稳定Rust异步生成器
-
async-gcode
为no_std目标异步gcode解析器
-
mikrotik_api
& 与Mikrotik RouterOS API连接和交互的最小客户端，通常在端口8728暴露
-
north-config
North配置是作为North微服务框架的一部分设计的多源配置crate
-
unsync
为异步Rust提供未同步的同步原语
-
wookie
包括单步执行器的异步测试/基准工具包。兼容 no-std。
-
tokio-agent
代理是对状态的简单抽象，灵感来自 Elixir 的代理
-
hydrolink
使用 tokio 独立于 Discord 库制作的 Lavalink 客户端，由 Hydrogen 在生产中使用
-
todc-net
消息传递（HTTP）分布式系统的算法
-
ardop_interface
Amateur Radio Digital Open Protocol (ARDOP) 接口
-
async_msp_lib
iNav 和 BetaFlight 的异步 msp 库
-
tokio-io-compat
实现了 tokio io 特性的 std io 特性的兼容包装器
-
containerd-snapshots
containerd 的远程快照扩展
-
arta
异步运行时抽象库
-
relaxed_channel
异步通道的包装器，在重管道上性能更优
-
mqttc
MQTT 协议的客户端
-
bevy_flurx
允许您编写涉及延迟、用户输入和其他等待过程的顺序描述
-
process-stream
对[tokio::process]的轻量级封装，使其可流式传输
-
gen-stream
基于生成器的Rust和futures 0.3流
-
stream-utils
额外的流组合器
-
dyn-timeout
动态超时，取消，在回调执行前添加和删除时间
-
tokio-reactor-trait
tokio的reactor-trait实现
-
set_timeout
允许在延迟后高效执行future
-
async-cuda-npp
Rust的异步NVIDIA性能原语
-
ak
利用std futures的actor库
-
futura
处理futures的帮助器
-
agnostic-lite
agnostic-lite是agnostic的轻量级版本，适用于希望编写异步运行时无关crate的用户，它对WASM友好 -
repsheet_etl
为repsheet的ETL工具
-
basu
具有同步和异步功能的Eventbus软件包
-
try_future
基于
futures的函数提前返回的便捷简写 -
cloudflare_dyndns
Cloudflare的DynDNS客户端
-
gandi-v5-livedns-api
Gandi LiveDNS API
-
tower-pipeline
一种将两个服务“管道化”的Tower服务组合器
-
tokio-context
使用tokio取消异步任务的上下文
-
async-raft2
Raft 分布式一致性协议的异步实现
-
allochronic-util
allochronic和khonsulabs的私有实用软件包
-
joyent-tokio-zookeeper
用于与 Apache ZooKeeper 交互的异步客户端库
-
yrs
Yjs CRDT的高性能实现
-
rusty-gql
Rust的Schema-first GraphQL库
-
af-core
Rust应用程序的核心库和异步运行时
-
async_io_utilities
由
tokio驱动的异步IO工具包 -
rfm69-async
rfm69无线收发器的异步驱动程序
-
parallel-stream
为async-std提供数据并行主义的库
-
tokio-task-queue
按顺序在一个Tokio任务中执行流中的futures
-
wgp
等待组实现
-
connection-utils
与连接相关的工具
-
async-signal
异步信号处理
-
starstruck
一个简单易用且提供良好性能的游戏构建工具
-
icanhazdadjoke-sdk
用于与icanhazdadjoke Dad Jokes API交互的SDK
-
simple-tokio-watchdog
非常简单但坚固的看门狗演员
-
baildon-store
B+树CLI
-
encrypted-dns
一个现代加密DNS服务器（DNSCrypt v2，匿名化DNSCrypt，DoH）
-
stream-download
将流媒体内容传输到本地文件缓存
-
euklid
CRDT
-
app-queue
用于异步作业的本地持久队列
-
nakadion
Nakadi事件代理的交互类型
-
troupe
使用actors模拟Rust应用程序
-
rasi-spec
官方RASI规范测试套件
-
scoped_tasks_prototype
快速实现Rust中作用域任务的尝试
-
mofo
多持续未来对象 - 一个用于轻松管理持续子任务的未来抽象
-
uds
支持抽象地址、fd传递和seqpacket套接字的Unix域套接字crate
-
tl-async-runtime
仅用于教育目的的糟糕运行时实现
-
salvo-oapi
Salvo Web框架的OpenApi支持
-
releez
安全运行应用程序发布检查清单
-
batchloader
基于Facebook的dataloader的异步请求数据批量器
-
futures-mockstream
实现futures async traits的最小mockstream
-
rseip-cip
rseip的通用行业协议
-
pingora-runtime
支持禁用工作窃取的多线程Tokio运行时
-
mwmr
一个通用的乐观事务管理器，ACID，与 SSI（可序列化快照隔离）并发
-
tokio-pty-process-stream
将tokio-pty-process包装起来，以提供一个更简单的API作为单个流对象
-
tower-make
为产生特定类型响应的服务提供特性别名
-
oc-wasm-futures
允许在OC-Wasm中使用async/await以获得更舒适的体验的Futures
-
scuttlebutt
kubernetes事件的接口
-
futures-cache
由sled支持的Futures感知缓存
-
hash_events
一个支持自定义事件的MPMC事件系统。事件通过负载发射，该事件的订阅者是负载流。对于每个事件，所有订阅者都会被触发。
-
arti-bench
Arti 的基准测试工具
-
serenity_ctrlc
serenity 的 Ctrl+C 处理器
-
callback-future
回调和未来之间的适配器
-
wasmflow-streams
封装通过Wasmflow组件发送的消息包
-
asyncs-sync
异步运行时无关的同步实用工具
-
atcoder
Rust 项目的模板
-
idb
基于未来的 crate，用于通过 WebAssembly 在浏览器中与 IndexedDB 交互
-
kvarn-tokio-uring
临时 Kvarn 分支：为 Tokio 异步运行时提供 io-uring 支持
-
jsonrpc-rs
基于未来的 jsonrpc 服务器/客户端框架
-
browser-window
可选的异步，可选的线程安全，类似于 Electron 的 Rust 浏览器工具包
-
wag
类似于 Go 的 sync.WaitGroup 实现，在 Rust 中（同步/异步）
-
image_search
设计用于根据提供的参数搜索 Google 图片
-
zellij-client
Zellij 的客户端库
-
indexed_db_futures
通过web_sys为IndexedDB提供的Future绑定
-
openraft-rocksstore
基于rocksdb的
openraft::RaftStoragetrait的实现 -
jarust
Rust中的janus客户端SDK
-
tokio-named-pipes
为tokio提供的Windows命名管道绑定
-
dtbh_interface
自动化扫描器的接口库
-
promises
Rust中有效的、简单的、轻量级的JavaScript promises
-
tokio-tun
使用tokio异步分配TUN/TAP设备
-
prost-codec
使用异步-codec、unsigned-varint和prost进行Protobuf结构体的异步编解码
-
iou
io_uring绑定
-
actix-interop
使用async/await语法与actix actors一起使用
-
compio-net
compio的网络IO
-
可变长度读取器
读取/写入可变长度数据。支持tokio中的异步读取/异步写入。
-
tokio-anon-pipe
Windows的异步匿名管道
-
zipit
实时创建和流式传输zip存档
-
yew-interop
在yew中使用JavaScript和CSS进行异步操作
-
pw-telegram-bot-fork
创建 Telegram 机器人
-
futures-task
处理任务的工具
-
discord_api
从您的shell中与Discord API交互
-
stream-operators
为Rust标准Stream选择的一组Rxjs运算符
-
fsdr-blocks
为SDR和实时DSP的FutureSDR信号处理库构建模块
-
sync_stream
通过按顺序轮询流项目来聚合多个流，保持多个流的消耗同步
-
lemmy_apub_lib
fediverse 的链接聚合器
-
projections
因为为什么不使用宏，所以是免宏的引脚投影
-
mqtt_actor
用于与 Actix Actors 一起使用的 MQTT 适配器（从端口和适配器）
-
egg-mode-extras
为 egg-mode 提供速率限制流和其他辅助工具
-
whorl
被创建来教你 Rust 中的异步执行器是如何工作的
-
rusty_falcon
CrowdStrike Falcon API 的 Rust 绑定
-
django-query
用于模拟 Django 风格端点的工具
-
lunatic-distributed
节点到节点的通信
-
name-it
为异步 fn 返回类型命名
-
futures-loco-protocol
为 futures 提供异步 Loco 协议流
-
spin_future
将同步函数转换为有效但效率低下的 futures
-
taos
TDengine（一个时序数据库和分析平台）的驱动程序
-
rmp-futures
异步 Rust MessagePack 和 MessagePack-RPC
-
async-zeroconf
用于与 Tokio 一起使用的异步 Zeroconf 库
-
rexa
GraphQL MongoDB API 构建器
-
tinkoffpay
tinkoff 集成（卖家接收付款表单的链接并将买家重定向到该链接）；注意：使用回调方法
-
tokio-into-sink
将 tokio::io::AsyncWrite 转换为 futures::Sink 以处理字节
-
enjoin
强大的语法级异步连接宏
-
dynamodb-mutex
使用 DynamoDB 锁库
-
back-to-the-future
在 std::future::Future 和 futures::Future 之间进行转换
-
execution-engine
使用 Futures 和 async/await 实现的 Toca 执行引擎
-
money2
用于存储和异步在 (ISO-4217 的一部分) 货币之间进行转换
-
tokio-smoltcp
smoltcp 的异步包装器
-
kompact-component-derive
用于 Kompact 组件定义的 derive 宏
-
serial-io
串行端口实现
-
async-openai
OpenAI
-
fg-uds
在 futures-glib 主循环上运行的异步 Unix 域套接字
-
heim-sensors
跨平台传感器信息
-
noosphere-core
Rust Noosphere实现的内核数据类型
-
lsp-codec
适用于语言服务器协议的Tokio兼容编解码器实现
-
osaka
无需噪音的异步Rust
-
pinarcmutex
PinArcMutex类型，用于对固定数据的共享可变访问 -
june
通过actix和canary实现的人体工程学远程演员
-
tinyio
一个小型Rust并发运行时库
-
elfo-configurer
在elfo系统中加载和分配配置
-
retry_async
重试，特别支持Rust的Azure SDK（cf. https://github.com/Azure/azure-sdk-for-rust）。
-
spmc-logger
单生产者多消费者持久日志记录器
-
hl7-mllp-codec
适用于HL7最小底层消息传输协议（MLLP）的Tokio编解码器
-
amqprs
RabbitMQ 的 AMQP 0-9-1 客户端实现
-
asygnal
[WIP] 异步优先信号处理，例如 ctrl-c
-
actix-raft
使用 Actix actor 框架实现的 Raft 分布式一致性协议
-
atrium-cli
使用 ATrium API 的 AT 协议 CLI 应用程序
-
futures-state-stream
futures crate 的 Stream 版本，在完成时返回状态
-
blocking_pool
用于在异步应用程序中运行同步 I/O 的线程池
-
future-by-example
使用 Future 的常见模式示例
-
tokio-pty-process
通过伪 TTY 与子进程交互，使用 Tokio 异步操作
-
ate
具有强加密和身份验证功能的分布式不可变数据存储
-
tokio-xmpp
使用 tokio 的 Rust 异步 XMPP
-
tus_async_client
用于与 *tus* 启用的端点交互的本地异步客户端库
-
intervalier
具有处理通知的间隔事件
-
async-hid
用于与HID设备交互的异步库
-
async-ioutil
一组Rust异步I/O实用工具
-
vss
一个简单的库，允许轻松重用关闭信号处理
-
rust-runc
在Rust应用程序中消耗runc二进制文件
-
gpiocdev
使用GPIO字符设备在Linux上访问GPIO线路
-
worst-executor
一个类似自旋循环的异步执行器
-
futures-await-test
通过过程宏为Rust提供异步测试支持。此crate定义了
#[async_test]属性，以简化使用async/await编写的测试。 -
dbus-async-derive
dbus-async的处理trait派生宏
-
gmf
使用Glommio和Tonic的RPC库。注意：此包仅在Linux上工作。
-
duplexify
将读取器和写入器合并成一个双向的读取+写入
-
gritea
Gitea API SDK
-
quicksink
从一个值和一个返回 Future 的闭包创建一个 Sink
-
epoxy_frp
前端应用程序的响应式胶水
-
jenner
用于与生成器一起工作的工具，可以与迭代器和流一起工作
-
async-graphql
用 Rust 实现的 GraphQL 服务器库
-
limited-join
提供一个具有有限并发性的 join future 的零依赖包
-
aggligator
将多个链接（TCP 或类似）聚合到一个具有它们总带宽的单个连接中，并提供了对单个链接故障的弹性
-
async-drop-guard
提供可以锁定单个条目的哈希表和缓存数据结构
-
otdb
一个开放Trivia数据库API包装器
-
hash_cons
一个类型安全的哈希 cons 库
-
futuresdr-types
适用于异构架构实验性异步SDR运行时的多态类型
-
retry-strategy
基于Tokio的更好的异步重试工具
-
paranoid-hash
针对那些对安全性有偏执的哈希库
-
peace_rt
peace自动化库的运行时逻辑
-
heim-disk
跨平台磁盘信息
-
gearbox
针对Rust的过度工具，提升生产力和操作
-
araft
基于tokio + tonic的异步raft实现
-
safina
安全的异步运行时
-
nasu
命令行实用程序，定期轮询远程地址以执行状态检查
-
alicemq
amqprs rabbitMQ库的包装器
-
bipe
异步I/O管道
-
component-future
实现了 tokio 文档中记录的内部 future 协议
-
message_worker
Message Worker 是一个为 Rust 编写的低级别库，用于使用 futures 和 streams 创建事件监听器。值得注意的是，MW 在监听器内支持非同步和非发送（即非线程安全）的上下文。
-
makiko
纯 Rust 编写的异步 SSH 客户端库
-
tokio-snappy
将 rust-snappy 封装为 tokio 中的异步流
-
rustmark
可扩展的基于 Markdown 的 Web 应用程序，用于提供服务
-
tk-easyloop
线程本地循环和其他循环辅助工具
-
neo-email
使用 Rust 构建电子邮件服务的现代方式
-
tracing-layer-slack
将筛选后的跟踪事件发送到 Slack
-
async_dag
异步任务调度实用工具
-
fates
创建响应式声明
-
fibers_inotify
为 fibers crate 提供一个 futures 友好的 inotify 封装器
-
srmw
异步单读多写
-
background-jobs-core
异步作业处理器核心类型
-
lagoinha
使用巴西邮政编码（CEP）通过公共API获取地址的包。此包同时调用所有支持的API并返回第一个结果。
-
hakuban
数据对象共享库
-
ssip-client-async
语音分配器客户端API
-
async-hofs
提供异步高阶函数的各种扩展特性
-
transform-stream
轻量级异步流包装器
-
vkteams-bot-cli
VK Teams Bot API CLI
-
rxqlite-common
基于
openraft、sqlx和sqlite构建的分布式sqlite数据库 -
stream-rate-limiter
Tokio流速率限制器
-
actor-interfaces
我只将此上传到crates.io，因为我遇到了与本地依赖项交叉编译的问题。如果有人想用这个名称做一些实际有用的事情，请在github上联系我
-
thread_runner
并行执行任务
-
asyncio-utils
支持在AsyncRead traits上限制、跳过
-
tower-limit
将最大请求速率限制到
Service -
log-tracing-layer
构建自己的自定义跟踪层
-
sync-async-runner
同步运行异步函数（如协程）
-
syncthing
通过其REST接口控制syncthing文件同步
-
faktory
为语言无关的Faktory工作服务器提供API绑定
-
yaaf
Actor框架
-
oneshot-broadcast
一次广播一个值而不进行克隆的通道
-
actix-ogn
基于actix的OpenGliderNetwork客户端
-
itla
ITLA (微激光) 非阻塞控制库，使用 embedded-hal
-
interprocess
通信工具包
-
async-io-traits
异步版本的 io 特性
-
amqp-manager
Lapin 包装器，封装了连接/通道的使用以及 amqp 对象的创建
-
runtime-loop
Rust 的运行时循环
-
hypixel
Rust 对 Hypixel 公共 API 的包装器
-
actix-broker
Actix actor 框架的消息代理
-
medusa-zip
一个命令行界面，用于执行常见 zip 文件操作的高性能并行实现
-
vru-cancel
取消 tokio 流
-
async-http-body
为 Agit init HttpBody 提供异步表达式支持
-
async-task-ffi
构建执行器时的任务抽象
-
safe-vk
创建自己的 vk 机器人进行对话
-
o5m-stream
streaming async o5m 解码器
-
async-mq
lapin AMQP 客户端 crate 的零成本异步 await 抽象
-
tripwire
使 futures 可抢占
-
dummy-waker
获取一个
core::task::Waker，它什么也不做 -
async-graphql-relay
为 async-graphql 提供Relay 支持
-
epics-ca
EPICS Channel Access 协议的客户端库
-
vampirc-io
异步、非阻塞的 UCI 协议，在棋盘用户界面和棋力引擎之间的通信
-
rama
模块化服务框架
-
vino-packet
封装 Vino 组件间发送的消息包
-
futures-cputask
将同步 CPU 密集型任务转换为 futures
-
monoio-rustls-fork-shadow-tls
基于Rustls的Monoio异步TLS流包装器
-
gmqtt-client
MQTTv5 客户端
-
hitbox-actix
Actix的异步缓存框架
-
svix
Svix webhook API 客户端和 webhook 验证库
-
async-instrumenter
future 的包装器，允许测量 future 执行所需的时间
-
hyper-futures
用于与 hyper 一起使用 AsyncRead 和 AsyncWrite 特性的 futures 兼容层
-
rillrate-system
RillRate 系统监控代理
-
bevy-tokio-tasks
将 Tokio 运行时集成到 Bevy 应用中以进行后台处理
-
iterstream
将 Iterator 转换为真正的异步 Stream
-
akinator-py
akinator-rs 的 Python 绑定
-
ector
开源的嵌入式设备异步、无分配 actor 框架
-
bacon-ls
Bacon 语言服务器
-
tokio-async-write-utility
为实现了 AsyncWrite 类型的类型提供一些辅助函数
-
tokio-lock
从单个 Tokio 任务访问对象
-
lunatic-messaging-api
Lunatic 消息发送的主机函数
-
tokio-shared-udp-socket
在 tokio 中轻松共享 UDP 套接字
-
and-then-concurrent
Rust 流的并发 and-then 组合器
-
fundamentum-edge-pfwd
edge 守护进程的端口转发工具
-
tokio-rustls-fork-shadow-tls
基于 Rustls 的 Tokio 异步 TLS 流包装器
-
lnd_grpc_rust
通过 tonic_openssl 和 prost 实现的 LND RPC 异步库
-
parsec
异步、可靠、安全且高效的共识协议
-
bevy-wasm-tasks
将 WASM 任务集成到 Bevy 应用中进行后台处理
-
kay
Rust 的实验性高性能 actor 系统框架
-
starpu-sys
对StarPU运行时的底层绑定
-
swimos_sync
SwimOS 同步通道
-
suspend
一种用于挂起线程或Future直到通知的通用机制
-
manual-executor
具有手动唤醒的异步执行器
-
bleasy
高级BLE通信库
-
completeio
基于完成状态的IO驱动程序和异步运行时
-
embassy-time
适用于嵌入式无标准系统的即时和Duration，支持异步定时器
-
coasys_juniper
GraphQL 服务器库
-
async-codec-lite
使用futures从AsyncRead/AsyncWrite适配到Stream/Sink
-
volo-grpc
volo的gRPC框架实现
-
rust-gpt
与Completion/Chat OpenAI API的交互
-
openrazer
异步绑定到 OpenRazer 守护进程
-
fure
使用不同策略重试未来
-
bawawa
一套具有观点的工具，用于管理和编排流程执行
-
rustls-acme
使用 rustls 进行 TLS 证书管理和提供
-
rocketmq-filter
Apache RocketMQ 的非官方 Rust 实现
-
streamify
值到流的转换
-
mio-misc
Mio 使用的杂项组件
-
lwactors
使用 futures-rs 的 Rust 轻量级演员
-
futures-promises
用于未来的承诺和监视变量
-
deadpool-bolt
deadpool 连接池的 bolt-client 管理器
-
futures-util-io-peek
AsyncPeek 特征
-
gdext_coroutines
在 Godot 4.2+ 中运行 Rust 异步函数和协程（通过 GDExtension），灵感来源于 Unity 的协程设计
-
crossbus
无平台、无运行时 Actor 计算模型
-
compio-fs
为 compio 提供文件系统 I/O
-
bottle
Rust 的 Actor 模型框架
-
logged-stream
记录所有读取/写入操作、错误以及底层 IO 对象的释放
-
mutex-extra
RefMutex<T>类似于Mutex<T>，即使T不是Send，也是Sync和Send -
fred
Redis 和 Valkey 的异步客户端
-
zusammen
并行下载文件
-
stomp
完整的 STOMP 1.2 客户端实现。允许程序与 ActiveMQ 和 RabbitMQ 等消息队列服务交互。
-
ruchei-callback
ruchei 的回调特质
-
cute-async
Cute 异步工具库
-
callysto-avro
为 Callysto 流处理框架提供的 Avro 序列化/反序列化工具
-
arta-async-std
为 async-std 实现的异步抽象
-
client-util
通过几个扩展特质，帮助您构建请求并处理响应！
-
atomic-waker
任务唤醒的同步原语
-
async-read-util
用于处理 AsyncRead 的工具集合
-
zonyitoo/coio
具有非阻塞 I/O 支持的协程调度器
-
tokio-resource-pool
为 Tokio 生态系统提供的通用资源池
-
assets
异步资源管理
-
cucumber-codegen
为
cucumber包提供代码生成 -
client-handle
当使用多线程/异步代码时，生成客户端处理的宏
-
conquer-struct
宏用于在填充结构体字段的同时执行并发future解析
-
pinned
用于!Send任务的同步原语
-
async-trait
异步特质的类型擦除方法
-
f289ctrl
Fluke 289数字万用表的通信库
-
async-stream-http-tunnel-grader
异步流HTTP隧道评分器
-
ipc-orchestrator
使用IPC通信对本地开发使用中的命令行进程进行编排
-
tempest
受Apache Storm启发并使用Actix构建的实时消息处理框架
-
tbon
TinyChain二进制对象表示法（TinyChain Binary Object Notation）是一种紧凑且灵活的二进制序列化格式，适用于流式传输
-
bridge_updater_lib
一个辅助库，可以轻松获取Tor桥
-
proq
Rust的惯用Async Prometheus查询（PromQL）客户端
-
plumb
一个功能性的异步管道框架
-
minicoro-sys
rust 对 minicoro 的绑定
-
archlinux-repo
Arch Linux 仓库解析器
-
evermore
允许您运行固定数量的异步任务，直到发送关闭信号
-
rs-car-ipfs
rs-car 封装，用于从 IPFS 无信任网关读取文件
-
futures-option
处理可选未来和流的扩展特质
-
libpool
来自《Rust 编程语言》的线程池
-
incoming
接收传入连接的所有权特质
-
safina-sync
用于在异步任务之间共享或发送数据的安全结构
-
tokio-futures-respawn
用于重启失败的长运行任务的功能
-
aral-runtime-noop
Aral 运行时 for noop
-
tonic_lnd
通过 tonic 和 prost 实现 LND RPC 的异步库
-
grpcio
基于 gRPC c 核心库的语言实现
-
settimeout
创建一个在某个时刻准备就绪的std::future::Future实现
-
completion-io
基于异步完成型I/O的核心特性和类型
-
zippyst
解析zippyshare.com下载链接
-
async-stream-tls-upgrader
异步流TLS升级器
-
bililive
基于流的哔哩哔哩直播客户端库
-
tokio-prepend-io
包装类型，在异步读取或写入时预置数据
-
futures-await-test-preview
通过过程宏为Rust提供异步测试支持。此crate定义了
#[async_test]属性，以简化使用async/await编写的测试。 -
bme280-rs
通过I²C查询BME280传感器
-
join
提供有用的快捷组合宏，结合同步/异步链，支持单线程和多线程（同步/异步）逐步执行分支，将结果元组转换为元组的结果
-
async-openai-wasm
在WASM上的OpenAI
-
deadline
一个宏crate，确保断言满足其截止日期
-
mediatrix
强类型、可扩展的事件中介
-
catty
异步发送和等待值
-
async-ioutils
异步I/O工具集合
-
epoxy_streams
为
epoxy_frp库提供基本流实现。请使用 epoxy_frp。 -
stick
跨平台的异步游戏手柄、摇杆和飞行杆库
-
specta-typescript
将Rust类型导出为TypeScript
-
restapi
使用 hyper、tokio、bb8、kafka-threadpool、postgres 和 prometheus 进行监控的默认安全的 rest api
-
async-priority-queue
一个异步感知优先队列
-
tokio-iocp
为 Tokio 异步运行时提供 IOCP 支持
-
tokio-transports
用于进程间通信
-
tower-async-hyper
在
tower-asyncService和hyper(1.x) 环境之间建立桥梁 -
tower
用于构建健壮客户端和服务器的模块化和可重用组件
-
async-tick
tick clock
-
skrillax-stream
将 skrillax-network 载件包组合起来，以便在 tokio tcp 流上良好工作
-
async-ops
使用 std::ops 特性与 Future
-
opencl-sys
Rust 编程语言的 OpenCL C FFI 绑定
-
signals
Rust 的功能反应式类库，允许异步链式操作
-
elfo-utils
为 elfo 系统提供的一些工具
-
posturn
使用 Rust 的
async构建 turn-based games -
async_channel_io
为
async_channel实现AsyncRead和AsyncWrite -
tractor
模仿 Pony 的 actors 的 actor 系统模型
-
gjio
异步输入和输出
-
smartpoll
一个简化轮询未来的 '任务' 抽象
-
ero
受Erlang启发的框架，以容错方式组织异步代码
-
actix_derive
为
actix实现提供宏 -
async-pidfd
Linux的进程文件描述符（pidfd）
-
sampr
使用actor的消息传递框架
-
memphis-rust-community
Memphis消息协议
-
eventastic
Eventually-rs的意见分歧版本。它强制使用事务并处理幂等性。
-
streem
创建和消费流
-
rust-cli-commands
-
mycelium_lib
Mycelium DDM
-
mobc-forked
支持async/await的通用连接池
-
veilid-async-tls
使用Rustls的异步TLS/SSL流
-
garcon
一组特性和类，使您的线程或异步函数能够等待
-
bookkeeper-client
Apache BookKeeper 的异步 Rust 客户端
-
futures-shuttle
具有 futures 意识的 shuttle 同步对象
-
async-i3ipc
为 i3 和 async-std 提供的绑定，允许异步应用程序通过其 IPC 接口与 i3 通信。包含 futures 实现，以及与 i3 一起工作的便利函数。
-
real-async-trait
使用实验性功能来绕过异步 trait 类型擦除的 proc macro
-
paggo
一个小型、快速且安全的内存数据库
-
eventually-redis
为 Eventually crate 实现的 Redis 事件存储
-
graus-db
高性能、线程安全的关键值嵌入式数据存储
-
throttled-reader
限制对 read() 调用的 io::Read 代理
-
peace_item_sh_cmd
管理为 peace 框架运行 shell 命令
-
actix-async-await
为 Actix 提供的实验性异步/await 支持
-
tokio-shield
通过将它们包装在任务中，防止 futures 被中止
-
mio-utun
mio 的 Utun 绑定
-
fluke-maybe-uring
复制一些 tokio-uring 类型，以便在不使用它的情况下构建代码
-
tokio-compat-02
Tokio 0.2 兼容工具
-
hentai
nhentai.net 的 API 包装器
-
rtx
为 Rust 库提供零成本的运行时抽象，以实现异步运行时之间的选择自由
-
fd-queue
支持 Unix 套接字上的 fd 传递
-
puppet
不使用动态调度或装箱的actor框架
-
weighted-select
带权重的 futures::stream::Select
-
shared_stream
易于克隆的流
-
futures-test-sink
futures::sink 的测试工具
-
ttl_cache_with_purging
带可选后台清除过期条目的生存时间（TTL）缓存实现
-
compio-dispatcher
compio 的多线程调度器
-
async-graphql-parser
async-graphql 的 GraphQL 查询解析器
-
azur
使用 io_uring 实现的 executor/reactor 和 futures 的无_std Rust crate
-
redis-asio
基于 tokio 的异步 Redis 驱动程序
-
async-read-length-limit
限制异步读取的大小
-
local-spawn-pool
在池中启动
!Sendfutures 并等待它们全部完成。相对于tokio::task::LocalSet的独立替代方案。 -
rxqlite-lite-common
基于
openraft、sqlx和sqlite构建的分布式sqlite数据库 -
fil_actors_runtime_v10
Filecoin协议的系统演员
-
ex-futures
扩展
futures -
async-throttle
异步速率限制
-
deploy-common
用于
deploy和fabriccrate 的通用组件 -
icee-rabbit-rs
异步-amqp (lapin) 的包装器
-
strife
轻量级的Discord API库
-
backdrop
使用Backdrop将大型或复杂对象放置在背景中！（稍后，在另一个线程上，或者两者都行！完全可定制！支持Tokio！）
-
stewart-utils
stewart的小型通用工具
-
dndx-fork-tokio-tun
使用tokio异步分配TUN/TAP设备
-
monoio-io-wrapper
用于连接同步和异步I/O的读写包装器
-
stun-client
基于async_std的异步STUN客户端库
-
signald-rust
与Signald接口
-
tokio-tls-gmssl
使用native-tls为Tokio提供TLS/SSL流，为非阻塞I/O流实现TLS
-
jarust_plugins
Rust中的janus客户端SDK
-
mai
更高层次的mio接口
-
mysql_async_uu
基于 Tokio 的异步 MySql 客户端库
-
async_repeat
重试 future 机制
-
activitystreams-types
活动流规范的基本类型
-
papaleguas
ACME 客户端
-
rt-local-core
与平台特定的事件循环协同工作的线程局部异步运行时
-
ianaio-worker
与 Web Workers 一起工作的便利包
-
vanilla_tokio_actor
Vanilla Tokio Actor
-
stream-future
实现具有返回值的异步迭代器
-
actix-ws-ng
Actix Web 的 WebSocket，无需 actor
-
again
适用于 std library futures 的 wasm 兼容重试实用工具
-
heph-rt
Heph 的 actor 专用运行时
-
async-stdin
异步读取 stdin
-
hyper-multipart-rfc7578
Hyper 的 multipart/form-data (RFC7578)
-
async-ucx
异步Rust绑定到UCX
-
must-done
一个保证完成的实验性Future
-
desaturate
该软件包旨在使维护常规和异步函数的单一代码库变得更容易
-
noosphere-fs
在Noosphere内容上提供类似于文件系统的视图
-
axum-serde
为Axum Web框架提供基于serde的多个提取器/响应，同时提供宏以轻松自定义提取器/响应
-
generic-api-client
用于HTTP/HTTPS/WebSocket API的客户端
-
titdb
数据库API中的Trails
-
pin-utils
固定
-
dioxus-query
为Dioxus提供的完全类型化、异步、可重用的缓存状态管理 🧬
-
rtix
具有生成器的Actor。名字暂定，直到我有所作为或Rust支持正确的协程
-
rusty-penguin
快速TCP/UDP隧道，通过HTTP WebSocket传输
-
simple-process-stats
获取Linux和Windows上的内存使用和CPU时间
-
bader-db
支持键过期值的键值缓存RESP服务器
-
stalk
使用tokio发送序列化数据
-
tes3mp-plugin
创建TES3MP服务插件用的存根
-
rosey-actors
Actor框架
-
online
📶 检查互联网连接的库
-
mysql_async_wasi
基于 Tokio 的异步 MySql 客户端库
-
hyper_lua_actor
lua_actor与hyper的绑定
-
nrf24radio
NRF24L01(+)设备的异步嵌入式驱动程序
-
samotop
基于async-std的SMTP服务器和库
-
holidayapi_rust
Rust的HolidayAPI库
-
opentls
使用OpenSSL进行TLS连接
-
hyper-http-proxy
基于Hyper的应用的代理连接器
-
async-rustls-stream
基于rustls和futures-io的异步TLS流库。适用于服务器/客户端。
-
basteh
具有可替换后端的通用键值存储
-
wasmcloud-interface-sleepy
与sleepy能力提供者交互的接口
-
aector
具有智能内置测试框架的actor模型动态实现
-
switchyard
专注于实时计算的异步执行器
-
noosphere-into
将Noosphere内容转换为各种目标格式
-
local-pool-with-id
在LocalPool执行器上的一种小变化，公开唯一ID以跟踪未来完成情况
-
bevy_async_system
异步等待游戏状态的能力
-
compio-io
基于完成的异步IO的IO特性
-
tower-sessions-dynamodb-store
AWS DynamoDB会话存储。不适用于直接使用；有关详细信息，请参阅
tower-sessionscrate。 -
async-graphql-viz
async-graphql for viz
-
async-openai-wasi
基于 OpenAPI 规范的 OpenAI REST API 的异步绑定
-
ginepro
tonic 的客户端 gRPC 通道实现
-
scoped_spawn
异步编程的全结构并发
-
crypto-auditing
crypto-auditing 项目的客户端库
-
cancellable-timer
可中断的计时器
-
tasktrace
异步任务的逻辑“回溯”
-
agner-test-actor
受 Erlang/OTP 启发的演员工具包（test-actor）
-
telers
使用 Rust 编写的 Telegram Bot API 的异步框架
-
count-write
计算写入字节数的 io::Write 包装器
-
fibers_tasque
针对
fibers的tasque扩展 -
async-resource
异步资源池
-
租约
租用值并自动返回的对象池，支持异步操作
-
openssh-mux-client
openssh 多路复用客户端
-
chikatetsu
另一个针对 Tokio 的 actor 框架
-
tokio-utun
Utun 的 Tokio 绑定
-
tokio-macros
Tokio 的 proc macros
-
async-pipe
使用 tokio.rs 创建异步管道的读写对
-
async-graphql-axum-wasi
axum 的异步 GraphQL
-
deadpool
简单的异步池
-
ara
异步随机访问 I/O 特性
-
fourche
以狮子分叉尾巴（queue fourché）命名的工作队列，与 Redis 一起使用
-
switch-resume
分隔的异步延续
-
meltdown
一个轻量级的服务管理器，用于协助异步应用的优雅关闭
-
simple-actor
用于编写基于actor的异步代码的辅助工具
-
thespis
thespis actor模型接口（仅包含特质）
-
tor-events
Arti的 typed 事件广播框架
-
aiur
单线程异步执行器，具有结构化并发
-
tracing-durations-export
记录并可视化跟踪跨度中的并行性
-
rasi-ext
包括对异步编程有用的扩展功能或实验性功能
-
kvarn_async
Kvarn 网络服务器中使用的异步工具
-
elk-mq
使用 Redis 作为通信介质的 Rust 消息队列实现
-
safina-select
安全的异步 select 函数，用于等待多个 futures
-
sealrs
经典异步原语集合（Actors、Executors、Futures / Promises）
-
async-shell
异步进程子进程等待
-
tonic-middleware
Tonic服务的异步中间件和拦截器
-
cache-compute
实现请求/异步计算合并
-
async-events-emitter
提供一个事件处理系统的实现
-
async-entry
扩展了Tokio的proc宏
-
async_event_streams
异步事件发布/订阅库
-
tokio-hglib
基于Tokio的Mercurial命令服务器的异步客户端库
-
verypoll
非常轮询库
-
async-dropper-simple
基于struct-wrapper（即AsyncDropper
）的AsyncDrop实现 -
pcap-async
libpcap的异步/流扩展
-
ws-gonzale
使用async/await实现的简单WebSocket服务器
-
stry-evermore
允许您运行固定数量的异步任务，直到发送关闭信号
-
aster-proxy
用Rust编写的轻量级、快速且强大的缓存代理
-
fut-compat
提供tokio和async_std运行时的兼容性
-
ntex-files
为ntex web提供静态文件支持
-
tiny-jsonrpc
基于reqwest的Json rpc库
-
futurify
将您的同步函数转换为非阻塞线程futures
-
async-gitlib
基于libgit2的异步库
-
openraft-rocksstore-compat07
符合v07的RaftStorage trait示例实现
-
async-graphql-extension-apollo-tracing
向Apollo Studio发送跟踪和指标的async_graphql扩展
-
its_ok_to_be_block_on
block_on的最小实现，用于在同步上下文中执行futures
-
sn_data_types
安全网络数据类型
-
tokio-mockstream
由缓冲区支持的测试网络应用的假流
-
indexed-db
IndexedDB 绑定，默认事务为中止并支持多线程操作
-
mqtt-channel-client
使用 Tokio 通道进行通信的 MQTT 客户端
-
tls-async
使用 native-tls 提供的 AsyncRead/AsyncWrite TLS 支持
-
async-weighted-semaphore
异步加权信号量
-
comet-eventbus
强类型同步和异步事件总线
-
isostatic
最小化 URL 缩短器
-
async-http-client-lite
异步 HTTP 客户端
-
ruyi
Rust 中非阻塞、异步 I/O 的事件驱动框架
-
salvo-serde-util
salvo 的 serde 工具
-
twitch-irc
从 Rust 应用程序连接到 Twitch 聊天
-
linux-io-uring
Rust 的
io_uring库 -
associated-async-io
使用 futures 替代 poll 的异步 IO 特性
-
ctrlgen
为消息传递服务生成枚举
-
waitfor
重试函数直到成功、出错或达到超时/截止日期
-
geese_executor
带有鹅事件系统集成的异步执行器
-
libp2p
点对点网络库
-
py_mcai_worker_sdk
用于监听和处理消息的AMQP Worker
-
relock
使用Redis进行分布式异步锁
-
clia-ntex-files-mod
ntex-files的mod，支持以'.'开头的文件名
-
f1-api
F1 API是Codemasters开发的F1视频游戏的遥测API的客户端库。它使用异步网络来解码传入的UDP数据包，并将它们转换为强类型Rust结构。
-
waker-waiter
异步运行时与任意futures交互
-
json-array-stream
通过异步流增量读取JSON数组
-
mobc-bolt
mobc连接池的bolt-client管理器
-
wasmflow-traits
封装通过Wasmflow组件发送的消息包
-
mio-anonymous-pipes
Windows 同步管道的异步包装
-
smol-hyper
smol 与 hyper 之间的集成
-
specta-jsdoc
将 Rust 类型导出到 JSDoc
-
jstream-ext
为 futures Stream 特性添加一些额外扩展
-
northstar-rcon-client
Northstar 模组的异步 RCON 客户端
-
fs4
无需 libc，纯 Rust 的跨平台文件锁。原始 fs2，现在支持异步并使用 rustix 替代 libc。
-
koibumi-socks
最小的 SOCKS5 客户端库
-
fizyr-rpc
Fizyr RPC 协议的本地 Rust 实现
-
mold2d
Rust 平台游戏库
-
reducer
Rust 应用程序的预测性响应式框架
-
tokio-timerfd
tokio 的 timerfd 支持
-
agreed-memstore
内存实现
agreed::RaftStorage特性的代码。async-raft 的 memstore crate 的分支。 -
rusturn
TURN 服务器和客户端
-
tower-buffer
在调度到
Service之前缓存请求 -
greenthread-future
基于裸金属（no_std + no_alloc）上的 greenthread 将闭包转换为 future
-
aspartam
基于 tokio，受 actix 启发的最小化 actor 框架
-
rados_hi
对 librados (Ceph) 的有见地的、高级包装器
-
tower-sessions-sqlx-store
为
tower-sessions提供的 SQLx 会话存储 -
tk-bufstream
由连续缓冲区（netbuf）支持的缓冲流（用于 tokio）
-
poem-openapi
为 Poem 提供的 OpenAPI 支持
-
minehut
对 Minehut API 的简单易用的 Rust 包装器
-
gneiss-mqtt
异步和线程化的 MQTT(5) 客户端
-
最终
在 Rust 应用中使用事件源
-
rdbc-rs
基于 futures 的 Rust 数据库连接 (RDBC) 库
-
aral-runtime-async-std
为 async-std 提供的 Aral 运行时
-
futures-utils-lite
关于 futures 的轻量级实用工具
-
heim-virt
跨平台虚拟化系统检测
-
pingora-boringssl
Pingora 的 BoringSSL 异步 API
-
async-diesel
干净且高效地将 Diesel 集成到 async-std 中
-
tabs
基于 tokio 的异步任务抽象集合
-
casus
包含一些基于事件的自旋原语
-
pn532
协议实现
-
async-graphql-actix-web
为 actix-web 提供的 async-graphql
-
beul
执行 futures
-
jelastic-rs
为 Jelastic API 提供的 Rust 封装
-
kay_codegen
为实现 kay actors 进行代码生成
-
mini-tokio
基本的异步 Rust 执行器
-
tower-balance
在一系列统一的服务之间平衡负载
-
unix-udp-sock
支持 sendmsg/recvmsg 和 src IP 操作的异步和同步 UDP 套接字
-
tower-sessions-surrealdb-store
SurrealDB 会话存储。不建议直接使用；有关详细信息，请参阅
tower-sessions包。 -
agilulf_protocol
Agilulf 协议序列化和反序列化器
-
smol-macros
用于设置 smol 运行时的宏
-
future-result
将 Result 映射到 Result 的 Future 的惯用方式
-
takyon
单线程异步运行时
-
aktrs
用于 Rust 的演员模型框架
-
aral-runtime-tokio
tokio 的 Aral 运行时
-
tokio-takconnect
异步 Playtak 客户端
-
kyansel
可取消的future。提供一个future作为参数，如果提供的future首先解决，则当前future将取消。
-
tokio-timer-patched
为Tokio提供的定时器功能，修复了问题#36，并将其推送到Crates.io，以便在其它开源crate中使用。
-
connection
一个可以读取和写入可序列化数据的TCP连接。
-
bing_client
Bing copilot的异步反向客户端。
-
concurrent_tor
多个tor客户端的异步实现，具有一个可以按用户定义队列传递请求的调度器。
-
awaitable-bool
由Tokio提供的awaitable bool（类似于标志，灵感来自Python的
asyncio.Event，但也可以等待其变为'false'） -
async-subscription-map
状态订阅的异步记账数据结构。
-
edge-dhcp
异步+
no_std+无分配实现DHCP协议。 -
sigfinn
任务的生命周期管理器。
-
handy_io
一个便捷的模式和基于future的异步I/O库。
-
镊子
异步与磁盘数据库
-
oso-cloud
Oso Cloud客户端
-
noosphere-storage
Rust Noosphere实现的可插拔后端存储
-
rseip-eip
rseip的封装协议
-
task_yield
与执行器无关的任务释放
-
fmmap
灵活方便的零拷贝文件I/O的高级mmap
-
completeq-rs
异步任务间传递消息的替代方案
-
melodium-macro
编译Mélodium包的宏工具
-
async-trait-ext
异步特质的过程宏
-
peace_item_spec_file_download
管理为peace框架下载文件
-
orcinus
异步就绪的MySQL协议实现/包装库
-
futures-stream-select-ext
未来流选择扩展
-
futuresdr-pmt
适用于异构架构实验性异步SDR运行时的多态类型
-
awaitable-error
具有可存储在容器中的输入和输出的可等待类型
-
tower-reqwest
reqwest 和 tower-httpcrate 之间的适配器
-
file-descriptors
包括套接字、管道、FIFOs、终端、串行端口、字符设备、epoll、POSIX 消息队列、timerfd 等常见类型的 (主要是 Linux) 文件描述符包装器
-
absinthe
你是 Actor & Async 爱好者吗？那么你的应用程序需要一些 Absinthe！
-
txrx
采用 C++ 统一执行器提议
-
agner-init-ack
受 Erlang/OTP 启发（init-ack）的 Actor 工具包
-
hyper-async-io
为 Hyper 的 Body 提供 AsyncRead 和 AsyncWrite 接口
-
reqwest-eventsource
使用 reqwest 构建 Eventsource 的辅助工具
-
async_main
无运行时依赖的异步主进程宏
-
pyo3-anyio
Anyio 事件循环的 PyO3 工具绑定
-
fil_actors_runtime_v9
Filecoin协议的系统演员
-
gtk-future-executor
使用Gtk-rs编写异步GUI代码的基本构建块
-
waker-set
唤醒集
-
atm-async-utils
实现和测试futures::Sink和futures::Stream相关代码
-
async-dup
复制异步I/O句柄
-
derive-tokio-io
派生AsyncRead和AsyncWrite
-
rxqlite-sqlx-common
基于
openraft、sqlx和sqlite构建的分布式sqlite数据库 -
register-count
统计由
Counter创建的Register数量 -
futures-stable-preview
支持内部引用的futures
-
feature-extension-for-async-std
为async-std扩展功能
-
name_locker
异步命名锁的接口，可以以给定名称运行带有锁的异步任务
-
tokio-buf
字节缓冲区的异步流
-
workflow-async-trait
异步 trait 方法的类型擦除（自定义，参见 README.md 中的说明）
-
ksqldb
围绕 KSQL DB REST API 的薄包装，使其更易于使用
-
cdrs-tokio
用 Rust 编写的异步 Cassandra DB 驱动程序
-
wasmbus-rpc
用于演员和功能提供者的运行时库
-
tower-redis
一个 Tower 服务，用于通过管理的、多路复用的连接执行异步 Redis 请求/响应
-
backstage
用于构建数据驱动分布式系统的框架。
-
tokio-tasker
允许停止和加入 Tokio 任务的组
-
async-core
异步运行时的标准
-
event_handlers
处理事件的统一库
-
agner-reg
受 Erlang/OTP 启发的演员工具包（reg）
-
dbus-tokio
使Tokio与D-Bus兼容，D-Bus是一种在Linux上常用作进程间通信的公交系统
-
elfo-telemeter
收集并公开elfo系统的指标
-
shuller
库，用于获取在rule34和任何标签上的图像链接
-
wasm-agnostic
想要为wasm目标编写异步运行时无关crate的用户
-
bb8-mongodb
为MongoDB数据库实现的bb8连接池
-
futures-length-delimited-frame
根据长度前缀封装字节流
-
thalo
一种高性能事件源运行时，利用WebAssembly和嵌入式事件存储
-
ratchet_rs
异步WebSocket实现
-
bidirectional-channel
一个接收者可以响应消息，发送者可以等待响应的通道
-
futures-jsonrpc
JSON-RPC的Futures实现
-
puddle
仅使用异步同步原语实现的对象池
-
heim
跨平台系统信息框架
-
safina-net
安全的异步网络函数
-
agency
一个小型异步actor框架
-
streaming-platform
具有并发数据传输功能的数据流平台和消息代理
-
tarpc
一个关注易用性的Rust RPC框架
-
taskwait
等待一组异步任务的无运行时感知方式
-
dynalock
支持DynamoDB的基于租约的分布式锁定算法
-
peace_item_tar_x
管理为peace框架提取tar文件
-
tower-async-bridge
在经典
tower环境中连接tower-asyncService，反之亦然 -
future-bool
可以等待其值变化的布尔值
-
retry-if-macro
一个用于装饰方法和支持指数退避的tokio兼容属性宏
-
async-option
本质上是一个异步的 Async<Mutex<Option<T>>>
-
posixmq
一个用于使用 POSIX 消息队列的惯用库，可选的 mio 集成
-
axum-server
专为与 axum 框架一起使用而设计的高级服务器
-
async-stdio
用于在 std::io 环境中使用异步读写流的适配器
-
tokio-native-tls
使用native-tls为Tokio提供TLS/SSL流，为非阻塞I/O流实现TLS
-
compio-runtime
compio 的高级别运行时
-
implicit-await
隐式等待返回 Future 实现的调用
-
xml-macro
quick-xml 的便利宏
-
futures-stream-reader
将 [AsyncRead] 转换为字节块的 [Stream]
-
linux-io-uring-sys
Rust 的
io_uring绑定 -
compio-tls
compio 的 TLS 适配器
-
async-component-components
async-component 组件
-
winmsg-executor
适用于 Windows 的线程异步 Rust 执行器
-
executor-trait
定义跨执行器通用接口的特质集合
-
stilgar
轻量级、无需烦恼、可替换 Rudderstack 的即插即用组件
-
telit-me310g1
使用 AT 命令与 Telit ME310G1 LTE-M 无线电台交互
-
form-data
AsyncRead/AsyncWrite/Stream
multipart/form-data -
async-stream-packed
异步流打包
-
failure_ext
failure 错误处理包的便利扩展特质
-
activitystreams-traits
ActivityStreams 2.0 对象的特质
-
tigerbeetle-unofficial-core
到 tigerbeetle 客户端库的安全低级回调式异步绑定
-
axum-sessions
🥜 通过 async-session 为 Axum 提供基于 Cookie 的会话
-
libp2p-autonat
为 libp2p 识别 NAT 和防火墙
-
尝试
重复做某件事情
-
async-graphql-value
async-graphql的GraphQL值
-
mega_etl
基于WasmEdge WebAssembly运行时的云原生ETL（提取、转换、加载）应用程序框架，用于开发者过滤、映射和转换进入云数据库的数据管道
-
safina-async-test
运行异步测试的宏
-
aldrin
面向服务的RPC和进程间通信的消息总线
-
common-multipart-rfc7578
multipart/form-data (RFC7578)
-
async-cuda-core
Rust的异步CUDA流和缓冲区
-
gloo-timers
JavaScript计时器的便捷存储库
-
socketioxide
作为Tower服务的Rust实现的Socket IO服务器
-
skipdb-core
skipdb和async-skipdb集装箱的核心 -
docker_engine_api
与 Docker Engine API 交互的方法
-
tokio-utils
用于 Tokio 应用异步编程的工具
-
ruchei-extra
用于 ruchei 的 Stream/Sink 包装器，包含额外数据
-
vesper-macros
由 Zephyrus 使用的过程宏
-
RobotS
Actor框架
-
vertigo
Rust 的 SSR (Server-Side Rendering) 响应用户界面库
-
num_stream
提供在指定间隔生成递增数字的 Stream
-
bounded_join_set
为 Tokio 提供的并发限制 JoinSet
-
actix-storage-dashmap
基于 dashmap 的 actix-storage
-
await_macros
宏，扩展为
(expr).await -
async-psec
异步 PSEC 实现
-
fast_websocket_client
基于 fastwebsockets 库构建的快速异步 WebSocket 客户端
-
misskey-util
misskey-rs 库的高级API
-
noop-waker
一个什么也不做的唤醒器
-
ntex-rt
ntex 运行时
-
deadpool-fantoccini
为 fantoccini 提供的简单异步会话池
-
netbeam
一个使用 tokio 的纯 Rust 异步网络同步 crate，重新创建了熟悉的异步范式，但在网络环境中
-
stream-reduce
不使用初始值折叠流
-
luarmor
luarmor.net 的 API 包装器
-
lspower
实现 LSP 服务器的轻量级框架
-
holly
使用 futures 的简单actor模型库
-
rabble
创建位置透明actor基于系统
-
futures-async-combinators
玩具 futures 组合器
-
async-zmq-types
创建异步 zmq 实现的通用接口的类型和特质
-
改进
演员微框架
-
carrot-cake
一个剥皮式的 pub/sub 框架
-
relm
异步、基于 GTK+ 的 GUI 库，受 Elm 启发，用 Rust 编写
-
direct-executor
直接执行 futures 的 executor，适用于嵌入式环境
-
volo
高性能且可扩展性强的 Rust RPC 框架，帮助开发者构建微服务
-
leaves
分布式 ID 分配器
-
sendgrid-async
基于 async-std 的 SendGrid 发送电子邮件客户端
-
jarust_rt
Rust中的janus客户端SDK
-
kompact-actor-derive
为 Kompact Actors 提供的 derive 宏
-
atedb
基于不可变数据存储的分布式数据链（数据库），具有强大的加密和身份验证
-
stage
一个易于使用的、可组合的 Actor 模型，专为无缝并发设计
-
rspc
Rust 的快速且易于使用的 TRPC 服务器
-
spotify-rs
Spotify API 包装器
-
gwyh
甜言蜜语库
-
iroh-quinn
多功能的QUIC传输协议实现
-
uller
生成/下载您的链接
-
pipebuf_rustls
Rustls的PipeBuf包装器
-
suspend-channel
通道和流实现
-
tower-timeout
对请求应用超时，确保在固定时间内完成
-
tracing-subscriber
实现和组合
tracing订阅者 -
async_buf_reader_utils
为BufReader添加额外功能到async-std包
-
nonblocking
Rust的stdin包
-
turbocharger
自动生成的异步RPC绑定，通过WebSockets和WASM立即将JS前端连接到Rust后端服务
-
mezzenger-channel
通过未来通道传输mezzenger
-
async-reactor-trait
为异步io实现的reactor-trait
-
catalyzer-utils
开发更简单
-
tokio-async-std
一个可以无缝集成到tokio生态系统中的异步std
-
stream-flatten-iters
将迭代器的流扁平化为一个连续的流
-
photonio
异步应用程序的运行时
-
futures-to-stream
将同关联输出类型的异构Futures转换为流
-
param
Param风格的trait
-
repeating_future
[RepeatingFuture] 是一个可以不断调用对象的异步函数的 [Future]
-
causality
事件驱动架构特质
-
mio-pidfd
mio对Linux的pidfd的支持
-
trovo
一个用rust编写的trovo.live API和聊天客户端
-
deepwell
Wikijump API 提供者和数据库管理器
-
mfio-rt
基于 mfio 的异步运行时
-
swiftide-core
专为AI应用设计的快速流式管道库
-
supplicant
wpa_supplicant 绑定
-
relay
轻量级的一次性 Future 通道
-
extern_executor
异步执行器，将 futures 轮询委托给外部事件循环
-
elfo-pinger
ping elfo 系统的组
-
ockam_transport_uds
Ockam 路由协议的 Unix 域套接字 (UDS) 传输
-
boomerang_runtime
"反应器" 确定性 Actor 模型
-
lazy-queue
基于 futures 的懒队列处理
-
qcow2-rs
在异步/await 中读写 qcow2 图像
-
async-thread
Futures 版本的 std::thread
-
async-imap-lite
异步 imap
-
reqwest-streams
为 reqwest 提供的 HTTP 主体流支持：JSON/CSV/Protobuf 等
-
tower-sessions-deadpool-sqlite-store
为
tower-sessions提供的deadpool-sqlite会话存储 -
libp2p-dns
libp2p 的 DNS 传输实现
-
barrage
异步广播通道
-
agner-helm
受 Erlang/OTP 启发的 actor 工具箱（控制台）
-
awaken
为 mio 和 io_uring 合并跨线程唤醒者
-
tower-async
Tower Async 是一个模块化和可重用的组件库，用于构建健壮的客户端和服务器。它是从原始 Tower 库中分叉出的 "Async Trait"。
-
chtsh
Rust 命令行界面，用于与 https://cht.sh 交互
-
erkpht-tower
Tower 是一个模块化和可重用的组件库，用于构建健壮的客户端和服务器
-
async-compression
压缩容器与 Rust 现代异步 IO 类型之间的适配器
-
jackrabbit
实时消息队列
-
stream-map-any
允许合并不同输出类型的异步流
-
mio-timerfd
mio 对 Linux 的 timerfd 的支持
-
futuresdr-remote
FutureSDR 的远程交互库
-
promising-future
Promise/Future 对
-
peace_item_file_download
管理为peace框架下载文件
-
heim-net
跨平台网络信息
-
thetvdb
API 异步客户端
-
volo-thrift
volo 的 Thrift RPC 框架实现
-
accumulate-api
通过 JSON-RPC 与 Accumulate 协议接口的底层 API
-
async_dataloader
基于 DataLoader 模式的异步/await 避免使用 N+1 查询的强大工具
-
async-attributes
Async Rust 的实验性语言级别填充程序
-
plctag
libplctag 的包装器，具有 Rust 风格的 API 和有用的扩展
-
cynthia
Rust 的高性能异步编程运行时
-
gain-lep
通过 Lep 暴露 Gain API 的支持
-
signalr_rs
基于 actix web 客户端和 async await 的 SignalR 客户端
-
cf-pty-process-alpha
tokio-pty-process 的分叉，通过伪 TTY 异步交互子进程
-
async-tun
使用 async-std 异步分配 TUN/TAP 设备
-
sendblue
提供与 SendBlue REST API 交互的 API 客户端，使企业能够将 iMessage 和 SMS 服务集成到其应用程序中
-
tokio-beanstalkd
与 Beanstalkd 工作队列交互的异步客户端库
-
memstore
async-raft::RaftStorage 特性的内存实现
-
aio_event
类似于 Python 中的 asyncio 事件，是 tokio 的事件
-
eventbuzz_core
eventbuzz项目的核心子模块
-
clia-ntex-files
为ntex web提供静态文件支持
-
tokio-dbus
为Tokio提供的纯Rust D-Bus实现
-
pulz-executor
某些异步运行时的抽象
-
marzban_api
异步客户端，用于抽象/简化与Marzban面板API（https://github.com/Gozargah/Marzban）的交互
-
actor
演员特剧行为
-
eventum
异步I/O事件管理器
-
xorstream
使用（可选的异步）数据流与数据向量的XOR运算
-
async-ready
异步就绪特性
-
tower-batch
batch-tower是一个Tower中间件，允许您在缓冲区达到最大大小或最大持续时间之前缓冲请求进行批量处理 -
busybody
服务容器和依赖注入crate
-
gen-z
通过可等待发送者通过异步生成器进行无宏流构建
-
logic-mesh
使用Rust编写的基于事件和响应式块的逻辑控制引擎
-
rw-stream-sink
Stream/Sink和AsyncRead/AsyncWrite之间的适配器
-
drop-awaiter
允许您异步等待某个对象被丢弃
-
delay
一组特性和类，用于使您的线程等待（并超时）
-
aligne
使用tokio同步异步请求/响应和Ids的小型crate
-
libp2p-mplex
libp2p的Mplex多路复用协议
-
seal_rs
经典异步原语集合（Actors、Executors、Futures / Promises）
-
mamenoki
基于Tokio运行时的Beanstalkd客户端的完整实现
-
futuredsp
SDR和实时DSP的信号处理库
-
tower-retry
重试失败的请求
-
futures-enum
#[derive(Future, Stream, Sink, AsyncRead, AsyncWrite, AsyncSeek, AsyncBufRead)] for enums
-
tokio-metrics
为Tokio应用程序提供运行时和任务级指标
-
async-mesos
Mesos HTTP调度器API的异步客户端
-
naumi
轻量级且快速的数据传输协议。快速反序列化和极小的大小！
-
proxied
用于代理的异步客户端连接器
-
async-time-mock-async-std
用于异步运行时的可模拟时间（与async-std兼容）
-
ws_stream_wasm
用于在WASM中使用WebSocket的便利库
-
aredis
用Rust实现的Redis客户端
-
misanthropic
Anthropic Messages API的异步、易用客户端
-
gidle_future
glib主循环空闲时间的future执行器
-
futures-async-runtime-preview
futurescrate中async/await宏的运行时 -
mlg
Rust 的异步日志
-
最终状态
Future & Stream 抽象
-
toy-rpc
一个异步 RPC，模仿 golang net/rpc 的使用，并支持 async-std 和 tokio
-
ruserf
一个轻量级、高可用、容错的服务发现和编排的分布式解决方案
-
async-timer
Rust 异步故事的计时器
-
async-graphql-warp
为 warp 实现的 async-graphql
-
openssh-sftp-client
用于与 openssh sftp 服务器通信的高级 API
-
sendfile
sendfile(2) 系统调用的包装器
-
digtask
Dig 是一个 YAML 定义的、操作系统级别的任务编排器。它可以“挖掘”指定的任务，或“挖掘”所需的输出文件
-
celery-rs-core
Rust 中 celery 客户端和工人的核心工具
-
pingora-openssl
针对 Pingora 的 OpenSSL 异步 API
-
akt
Rust 和 Tokio 的 actors 库，可直接与异步/await 消息处理器配合使用
-
futures-glib
在 glib 事件循环上启动 futures
-
scambio
端点对之间安全高效的价值交换
-
socksv5_future
为服务器和客户端提供 Socks v5 futures
-
tower-helmet
使用各种 HTTP 标头保护您的 tower 服务器
-
heim-runtime
为 heim crate 提供运行时模拟
-
motore-macros
Motore 的 proc macros
-
compio-process
为 compio 提供进程
-
what-the-async
运行时
-
prodash
用于可视化异步和可能阻塞的任务进度的仪表板
-
wasm_main_executor
在主浏览器线程上从 Web 工作器运行 futures
-
atomic-actor
具有异步处理器的
Actor -
future_pubsub
基于 tokio 的发布-订阅通道
-
nb-executor
基于事件位掩码的单未来、#![no_std] 执行器
-
upc
USB 数据包通道 (UPC)：通过 USB 提供可靠的数据包传输
-
st7735-async-low
用于 4 线串行 ST7735 的低级异步库
-
fil_actors_runtime_v8
Filecoin协议的系统演员
-
librdkafka-sys
对 librdkafka 库的本地绑定
-
zephyrus-macros
由 Zephyrus 使用的过程宏
-
flo_binding
Rust 的声明式绑定库
-
spin-executor
Spin SDK 异步执行器
-
wombo
管理事件循环线程
-
basteh-redb
基于 redb 的 basteh
-
freestuffapi
Freestuffbot API
-
async-component
零开销响应式编程
-
tower-async-http
Tower Async 中间件和 HTTP 客户端/服务器工具库。从原始 Tower 库分叉的 "Async Trait"
-
pychan
一个用于发送类型为
pyo3::Py<T>的项的通道集合 -
psbus
适用于应用程序消息的通用发布/订阅模型
-
async-middleware
使用元组和 async trait 转换实现的 Rust 中异步 monad 中间件
-
completable_future
Rust 的 CompletableFuture
-
rupnp
用于查找 UPnP 控制点、在其上执行操作和读取其服务描述的异步库
-
ndless-async
Ndless 特定的 async/await 集成，适用于 TI-Nspire
-
cqrs-core
cqrs 的核心类型和特质
-
jarust_transport
Rust中的janus客户端SDK
-
simcore
一个通用的离散事件模拟框架
-
async-std-test
#[async_std::test] 宏的替代实现
-
smol-axum
smol和axum之间的集成 -
emitter-rs
📢 Emitter RS 是为 Rust 和 Wasm 提供的轻量级 EventEmitter 实现
-
liburing
Rust liburing#24bd087 原始绑定及基本测试
-
mio-byte-fifo
用于 Mio poll 的并发非阻塞字节数据 SPSC FIFO 缓冲区
-
task_scope
支持使用任务创建结构化并发的异步运行时扩展
-
ws-lite
使用async/await实现的简单WebSocket服务器
-
aldrin-gen
Aldrin 代码生成器
-
tarpc-copy
一个关注易用性的Rust RPC框架
-
tonic-health
tonicgRPC 实现的健康检查模块 -
d3
服务器开发的框架
-
prefect
基于SQLite的可嵌入任务队列（重命名为effectum）
-
elfo-dumper
将elfo系统消息转储到磁盘
-
ianaio-events
用于处理DOM事件监听器的便捷包
-
actix-codec
用于处理帧协议的编解码器工具
-
futures-executor-preview
基于futures-rs库的异步任务执行器
-
async-utils
目前这里没有什么可看的 :)
-
task_scheduler
轻松安排在将来运行的 FnOnce
-
squinn
支持SCION的灵活QUIC传输协议实现
-
fundamentum-edge-mcu-http-client
EdgeMCU设备的HTTP客户端
-
taskio
非阻塞任务和IO的抽象
-
futures-macro-await
为
futures包定义await!宏 -
elfo-logger
记录elfo系统的事件
-
retry_fn
具有阻塞或非阻塞、tokio或async-std版本的retry函数
-
mini-telnet
异步最小telnet库
-
tower-worker
专注于包装异步工作任务的Tower层，这些任务可能还会向包装的服务发起请求
-
futures-macro-await-preview
为
futures包定义await!宏 -
async-await
只是一些用于模拟Async和Await的宏 :)
-
异步
Promise Q风格，异步和事件循环
-
windows-async
使用windows crate的windows应用程序的异步执行器
-
thread-executor
使用std::thread::park的轻量级futures执行器
-
stream_multiplexer
将多个流合并为几个
-
hydro
协作绿色任务
-
thespis_impl
thespis演员模型的参考实现
-
specta-serde
Serde对Specta的支持
-
spawns-core
Rust 的异步运行时无关的线程上下文任务生成器
-
async-timer-rs
哈希定时轮实现，兼容异步任务，支持async_std/tokio等基于future的框架
-
fieldset
结构体到枚举派生
-
tower-load-shed
如果内部服务未准备好，立即拒绝请求。这也就是所谓的削峰填谷。
-
tokio-non-async
非异步代码中处理tokio通道的辅助函数
-
tokio-dbus-macros
为Tokio提供的纯Rust D-Bus实现
-
hyena
异步任务池
-
core-futures-tls
A libcore包装器，允许在no_std crate中使用async/await
-
axum-macros
axum宏
-
coerce-rt
异步actor运行时
-
turmoil
分布式系统模拟测试框架
-
任务执行器
一个任务执行器
-
uasync
快速、安全的异步执行器
-
async-graphql-rocket
为 Rocket.rs 提供的 async-graphql
-
swimos_messages
SwimOS 运行时内部消息协议
-
genawaiter-macro
为生成器（genawaiter）提供的便捷宏
-
axum-messages
🛎️ 为 Axum 的一次性通知消息
-
one-file-raft
300 行代码中的 Raft 协议
-
embassy-futures
用于处理 futures 的无标准、无分配工具
-
safe-async-scoped
用于作用域异步任务的极简、安全库
-
diath
用于 tokio 异步任务间通信的轻量级库
-
stream_generator
允许轻松使用 async/await 生成流
-
tokio-blocking
提供简单接口，在 futures 上下文中将阻塞操作插入到非阻塞操作之间的一层薄包装
-
stream-body
为 Rust HTTP 库 hyper 提供高效流支持的 HttpBody 实现
-
lucia-apis
基于 lucia 框架的 API 集合
-
tokio-fastcgi
为 Tokio 提供的 FastCGI 处理程序（响应者、授权者、过滤器）库
-
hop
Api 的 Rust 客户端库
-
ratchet_ext
Ratchet 的 WebSocket 扩展
-
axum-serveplus
专为与 axum 框架一起使用而设计的高级服务器
-
feature-extension-for-wasm-bindgen-futures
wasm-bindgen-futures 的功能扩展
-
shutdown-async
异步关闭
-
tokio01-test
为 Tokio 和基于 futures 的代码提供测试工具
-
armature
基于 Rust 的事件驱动有状态演员框架
-
alzheimer
Brainfuck 解释器的异步实现
-
tokio_safe_block_on
能够在同步上下文中执行异步代码，而不会阻塞 tokio 核心线程或忙等待 CPU
-
tangle
Rust 的 Future 实现
-
mercury
Mercury 解析器的官方 Rust 客户端
-
noosphere-ns
Noosphere 的 P2P 命名系统
-
actm
用于 Rust 的小型异步演员框架
-
see-you-later
延迟和调度异步任务
-
tower-http
Tower 中间件和 HTTP 客户端/服务器的实用工具
-
flysystem
Rust 的文件系统抽象层
-
entangled
fork-join 任务执行器
-
peace_cmd_rt
Peace 框架命令的运行时类型
-
quinn-proto
QUIC 传输协议的状态机
-
libp2p-yamux
libp2p 的 Yamux 多路复用协议
-
async-spawner
独立的任务生成器
-
nephele
Rust 的高性能异步编程运行时
-
swiftide-macros
专为AI应用设计的快速流式管道库
-
archflow
创建可流式传输的 Zip 存档
-
toy-rpc-ha421
一个异步 RPC，模仿 golang net/rpc 的使用，并支持 async-std 和 tokio
-
logimesh
微服务 2.0 框架
-
dialectic-tokio-mpsc
Dialectic crate 的 Tokio MPSC 通道后端
-
compio-signal
为 compio 处理信号
-
mirai
Mio 之上的 Futures 层
-
simple-async
Rust 的一个非常简单的异步运行时
-
diny
一个异步、无分配的序列化框架
-
批处理
基于RabbitMQ的分布式任务队列库
-
tokio-channel
使用Tokio进行异步通信的通道
-
lelet
类似Go语言的任务执行器
-
tinyio-core
tinyio的核心
-
cassandra-protocol
Cassandra协议实现
-
peace_item_sh_sync_cmd
管理peace框架的同步shell命令
-
tokio-fd
非阻塞读取和写入Linux文件描述符
-
memberlist
一个高度可定制、适应性强、异步运行时无关的Gossip协议，有助于管理集群成员和成员故障检测
-
async-graphql-poem
为poem提供async-graphql
-
async-transport
带有ECN信息的异步传输
-
compiolog
compiolog日志
-
openssh-sftp-error
与openssh sftp服务器通信时使用的错误类型
-
elfo-network
elfo的分布式actor
-
tokio-eventfd
tokio的Linux eventfd
-
actix-service
表示异步请求/响应操作的service特性和组合器
-
nostr-bot
Nostr机器人库
-
just-watch
异步监视通道
-
libp2p-webtransport-websys
WASM环境下的libp2p WebTransport
-
async-watch
异步监视通道
-
smol-executor-trait
smol的executor-trait实现
-
somen
异步解析组合器
-
monoio-macros
Monoio过程宏
-
tower-sessions-mongodb-store
为
tower-sessions提供的MongoDB会话存储 -
lrcall
与本地和远程过程调用兼容的调用框架
-
puff-rs
Puff - 深度堆栈Python运行时和GraphQL库
-
peace_value_traits
Peace框架中值类型的特性界限
-
ntex-io
编码和解码帧
-
madsim-tonic
madsim上的
tonic模拟器 -
stream-consumer-task
在后台启动异步任务以消费流
-
fil_actors_runtime_v11
Filecoin协议的系统演员
-
specta-util
Specta的高层次实用工具
-
vkteams-bot
VK Teams机器人API客户端
-
rxqlite-notification
基于
openraft、sqlx和sqlite构建的分布式sqlite数据库 -
waaaa
WebAssembly，自动抽象
-
tokio-net
驱动 Tokio I/O 资源的 Event Loop
-
async-backtrace
高效、逻辑的异步任务 '回溯' 记录
-
compio-macros
compiro 的过程宏
-
misskey-core
misskey-rs 中的核心特性和类型
-
poem-grpc-build
poem-grpc 的代码生成模块
-
protwrap
针对网络应用的轻量级协议包装器
-
selectme-macros
为异步 Rust 提供的一个快速且公平的选择宏
-
forkable
可分叉的迭代器和异步流
-
dialectic-null
Dialecticcrate 的无操作后端，用于基准测试和测试
-
madsim-etcd-client
madsim 上的 etcd 模拟器
-
async-task-group
将
async-std任务组管理为一个单元 -
tokio-tls-api
为Tokio提供的TLS/SSL流，实现了非阻塞I/O流的TLS实现
-
futures-mpsc
支持背压的futures感知的有限MPSC通道
-
tower-layer
装饰一个
Service，以允许在Service之间轻松组合 -
yaar-reactor
构建执行器的非阻塞IO抽象