Open-source alternatives to Async Std

Smol is a lightweight Rust asynchronous runtime and task executor. It provides a suite of foundational tools for scheduling and executing asynchronous futures, managing background workloads, and handling non-blocking network and file operations. The project includes a compatibility layer for adapting asynchronous types and execution contexts, enabling futures to run across different runtime ecosystems. It also features a mechanism to offload synchronous I/O and CPU-intensive operations to dedicated worker thread pools to prevent runtime stalls. Its capabilities cover non-blocking network I/O

monoio is a high-performance asynchronous runtime and executor for Rust. It implements a thread-per-core concurrency model that pins tasks to specific CPU cores to eliminate synchronization overhead and data migration. The runtime leverages the io_uring interface to perform non-blocking system calls and reduce kernel-user mode memory copying. It utilizes a high-performance I/O driver and zero-copy TCP stream wrapping to manage data transfer via shared-memory buffers. The project provides capabilities for CPU core affinity management, low-latency system programming, and high-performance netwo

Handy is a C++11 network server framework and event-driven networking engine designed for building high-performance concurrent TCP and UDP servers. It functions as an asynchronous I/O library and an HTTP server implementation that separates asynchronous network I/O from synchronous business logic to simplify server development. The framework distinguishes itself by utilizing platform-specific event notifications to manage millions of simultaneous network connections and providing an SSL/TLS network wrapper for encrypted asynchronous data transmission. It implements a half-sync/half-async proc

EventMachine is a reactor-pattern network framework for Ruby that provides an asynchronous I/O library for performing non-blocking network and file operations. It functions as a network server framework used to build scalable TCP and UDP servers and clients that process multiple simultaneous requests. The framework implements a concurrency model that dispatches network events to registered handlers using a single-threaded event loop. This approach allows for the management of high-concurrency network connections without the overhead of multi-threaded programming. The library covers the devel

An asynchronous I/O and reactor event loop library for PHP, this project provides core primitives for coordinating non-blocking operations, managing system resources, and scheduling background tasks. The runtime executes concurrent operations by continuously running tick-based loop iterations that process pending timers, network streams, deferred callbacks, and system signals through efficient system-level polling mechanisms. The library coordinates event-driven execution using asynchronous timers for one-off or periodic tasks, next-tick deferred execution for breaking down workloads, and str

Async-task is a low-level Rust concurrency library and asynchronous task executor designed for building custom asynchronous runtimes and managing background task execution pipelines. It provides concurrency primitives that handle atomic task state management, heap-allocated futures, output retrieval, and type-erased execution handles. The library coordinates task execution, cancellation, and polling states across multiple threads using lock-free atomic operations and reference counting. Developers can supply custom scheduling logic and metadata hooks that dictate when and how tasks are queue

Trio is an asynchronous I/O runtime and concurrency library for Python. It provides a system for executing non-blocking network and disk operations through a centralized event loop and task scheduler. The library is built on a structured concurrency model, which ensures that asynchronous tasks are bound to a specific lifetime and cannot outlive the scope that started them. It utilizes a nursery-based task manager to track task lifecycles in a parent-child tree, preventing orphaned concurrent operations by requiring child tasks to be joined before their parent scope exits. The framework cover

This project is a framework for building concurrent, event-driven applications in Ruby. It provides a core engine that orchestrates non-blocking input and output operations, allowing developers to handle high-volume network traffic and system tasks without the complexity of traditional callback-based programming. By leveraging lightweight fibers, the library enables cooperative multitasking that maintains responsiveness during heavy data processing workloads. The framework distinguishes itself through a structured concurrency model that organizes tasks into parent-child hierarchies. This appr

gnet is a high-performance event-driven networking framework for Go, designed for building scalable TCP, UDP, and Unix socket servers. It functions as a non-blocking socket manager and multi-reactor network engine that handles thousands of simultaneous connections with low memory overhead. The framework distinguishes itself by using a multi-reactor architecture that distributes I/O across multiple event loops pinned to operating system threads to minimize context switching. It employs edge-triggered polling to reduce system call frequency and utilizes elastic ring-buffers to minimize allocati

The AWS Java SDK is a programmatic interface and client library for managing and interacting with AWS cloud infrastructure and services using the Java language. It serves as an API wrapper that connects applications to cloud storage, databases, and compute resources through a standardized set of Java classes. The library provides a non-blocking I/O model and future-based request handling to support high-throughput asynchronous cloud operations. It includes mechanisms for serverless performance optimization to reduce initial startup times and cold starts in those environments. The SDK manages

Twisted is an event-driven networking engine for Python that provides a framework for building asynchronous network applications. At its core, it uses a reactor-based event loop to drive all input and output, dispatching callbacks in a single thread without blocking. The library implements a deferred promise chain for composing asynchronous logic, along with a protocol and factory pattern that separates connection state management from protocol handling, enabling reusable handlers for different network protocols. The framework supports multiple event loops across platforms, including select,

🗑 async-dropper is probably the least-worst ad-hoc AysncDrop implementation you've seen so far.

Coroutine I/O for Rust

High-performance, Rust-based asynchronous task programming framework implementing Flow-Based Programming for scalable directed acyclic graph (DAG) task orchestration

Monad/MonadIO, Handler, Coroutine/doNotation, Functional Programming features for Rust

Gabriel2: Indeed, an actor library based on Tokio, written in Rust

Tokio is an asynchronous runtime for the Rust programming language, designed to manage and execute concurrent tasks efficiently. It provides a multi-threaded execution environment that schedules lightweight tasks across available processor cores, utilizing a work-stealing scheduler to balance computational load. By employing a poll-based execution model and waker-based notifications, the runtime drives asynchronous operations forward without requiring active polling loops, ensuring efficient resource utilization. The project distinguishes itself through a comprehensive suite of tools for high

Fault-tolerant async actors for Rust that scale seamlessly

iii is a distributed service orchestrator and event-driven workflow engine designed to compose and manage cross-language functions and workers through a central execution engine. It functions as a multi-language service mesh and WebSocket service gateway, providing a persistent communication layer for remote service workers. The platform enables dynamic runtime extensions, allowing new workers and capabilities to be deployed and registered into a live environment without requiring system restarts. It distinguishes itself by offering machine-readable skill exposure and agent capability integra

Queue futures to run concurrently, in the order they're spawned, and with global and group limits.

rust stackful coroutine library

no longer maintained Scalable, coroutine-based, fibers/green-threads for Rust. (aka MIO COroutines).

This project is a collection of guides, toolkits, and scripts designed to optimize agentic coding workflows using large language models. It provides strategies for orchestrating AI agents, automating git patterns, and enhancing terminal-based development environments. The toolkit focuses on AI agent orchestration and git management, offering patterns for parallel codebase analysis and autonomous testing frameworks. It includes specialized workflows for conducting interactive pull request reviews and performing root cause analysis on continuous integration failures. The project covers a broad

libuv is a cross-platform asynchronous I/O library that provides an abstraction layer for event-driven networking, filesystem operations, and system signals. It utilizes a non-blocking event loop to coordinate asynchronous tasks and I/O events across different operating systems. The project features a unified interface for managing TCP, UDP, and DNS resolution, alongside an inter-process communication layer for sharing sockets via named pipes and Unix domain sockets. To prevent blocking the main execution loop, it includes a multi-platform thread pool for offloading computationally expensive

Boost is a collection of portable, high-performance source libraries that extend the C++ standard library. It provides a wide range of reusable components, data structures, and algorithms designed to add capabilities to the base language across different platforms. The project is distinguished by its extensive focus on compile-time template metaprogramming and generic programming. It implements advanced architectural patterns such as policy-based design, concept-based type validation, and the use of SFINAE for conditional template resolution to minimize runtime overhead. The library covers a

cppcoro is a C++ coroutine library and concurrency toolkit providing primitives for asynchronous tasks, lazy generators, and non-blocking execution. It functions as an asynchronous I/O framework for managing network sockets and file operations through an event loop. The library features a work-stealing thread pool for distributing tasks across multiple cores and a set of async generators for producing lazy sequences of values both synchronously and asynchronously. It includes a concurrency toolkit with async mutexes, latches, and shared tasks to coordinate multi-threaded execution. Its capab