Async IO libraries

Libevent is a cross-platform library that provides a mechanism for executing callback functions when specific events occur on file descriptors, signals, or timers. It functions as a network event loop framework, enabling the development of applications that manage concurrent network connections and non-blocking input and output operations within a single execution context. The library distinguishes itself by providing a portable abstraction layer that automatically selects the most efficient system-level event notification mechanism available on the host operating system. It includes thread-s

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

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

ReactPHP is an asynchronous runtime and event-driven I/O framework for PHP. It provides an environment for executing concurrent tasks through a central event loop implementation and reactor pattern, allowing applications to handle multiple operations without pausing the main execution thread. The project includes a specialized asynchronous socket library for TCP, UDP, and TLS communication, alongside a non-blocking HTTP server and client for streaming web requests and responses. Its capability surface covers asynchronous control flow via promises and fibers, non-blocking network connectivity

Asio is a C++ library for performing network and low-level I/O operations using a consistent asynchronous model that avoids blocking program execution. It provides a portable, cross-platform interface for network socket communication across different operating systems, and manages multiple asynchronous operations without requiring explicit thread management or locking. The library implements a proactor-based asynchronous model where operations post completion handlers to a queue for later execution, and wraps operating system I/O multiplexing mechanisms like epoll, kqueue, IOCP, and select in

evpp is a C++ network library and framework designed for building high-performance network services using TCP, UDP, and HTTP protocols. It provides an asynchronous event loop to manage nonblocking I/O operations and concurrent network connections across multiple threads. The framework includes specialized tools for asynchronous DNS resolution and a system for asynchronous task scheduling using a managed thread pool. It also features a nonblocking HTTP server and client with integrated connection pooling. The project covers low-level transport layer connectivity for TCP and UDP, as well as hi

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

Muduo is a C++11 event-driven network library and framework designed for building high-concurrency Linux servers. It provides a toolkit for implementing scalable network services and socket communication using non-blocking I/O and asynchronous event processing. The framework implements a multi-threaded TCP server architecture that distributes connection handling across multiple CPU threads to maximize server throughput. This is achieved through a one-loop-per-thread model and a reactor pattern implementation, which dispatch network events from a central demultiplexer to registered handler fun

libhv is a high-performance C/C++ network library and event-driven I/O framework used to build TCP, UDP, SSL, HTTP, WebSocket, and MQTT clients and servers. It provides a non-blocking event loop for managing network sockets, timers, and system signals across multiple threads. The project is distinguished by its integrated support for specialized network roles, including a full HTTP web server with RESTful routing and middleware, an MQTT messaging client for IoT communication, and the ability to implement SOCKS5 and HTTP proxies. It also features a reliable UDP implementation to ensure ordered

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,

Mio is a low-level I/O library for Rust that provides an event-driven framework for monitoring multiple network sockets and file descriptors. It acts as a portable wrapper for operating system native polling systems, including epoll, kqueue, and IOCP, allowing applications to trigger events when resources are ready for reading or writing without blocking the execution thread. The library provides a non-blocking socket interface for managing TCP, UDP, and Unix sockets. It distinguishes itself through a vectored I/O implementation, enabling scatter-gather reads and writes across multiple buffer

Netty is an asynchronous network framework designed for building scalable protocol servers and clients. It utilizes an event-driven reactor pattern and a non-blocking input/output model to decouple connection handling from application logic, allowing for the development of responsive network services that manage high volumes of concurrent connections. The framework distinguishes itself through a modular pipeline-based processing chain that enables the implementation of custom binary or text-based protocols. It provides a pluggable transport abstraction that allows developers to switch between

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

This project is an asynchronous network framework for Python that provides both a client and a server for HTTP communication. It is designed to handle high-concurrency network operations by leveraging cooperative multitasking, allowing for the management of thousands of simultaneous connections without the overhead of traditional thread-per-request models. The framework distinguishes itself through its focus on efficient resource management and persistent communication. It utilizes connection pooling to reuse network sockets, which reduces latency during sequential requests, and supports full

DotNetty is an asynchronous network framework and event-driven networking library for .NET. It is a port of the Netty architecture designed for building high-performance protocol servers and clients. The framework enables the development of network applications that handle concurrent connections and high-throughput data streaming without blocking execution threads. It supports the implementation of custom network protocols through defined encoding and decoding rules. The library utilizes a pipeline-based processing model and non-blocking I/O to manage network traffic. Its architecture incorp

aiohttp is an asynchronous networking framework for Python that provides both an HTTP client and an HTTP server. It utilizes the asyncio library to handle network requests and server-side routing through a non-blocking event loop. The framework includes a dedicated toolkit for establishing persistent bidirectional communication channels, enabling the implementation of both WebSocket servers and clients for real-time data exchange. It covers a broad range of asynchronous network programming capabilities, including the development of web servers with customizable routing and the ability to sen

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

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

async-std is a Rust asynchronous runtime and non-blocking I/O library. It serves as an asynchronous standard library, providing a set of alternatives to the core Rust library for managing concurrent tasks, networking, and file system access. The project implements a standard-library-mirrored API, offering asynchronous versions of existing synchronous types to maintain a familiar interface. This approach allows for asynchronous Rust development using an interface that reflects the ergonomics of the language's standard library. The runtime includes a task executor for scheduling and executing

Swift NIO is a low-level, event-driven network framework for the Swift language. It serves as an asynchronous network protocol stack and I/O library designed to build high-performance network servers and clients that handle thousands of simultaneous connections. The framework functions as a high-concurrency network engine that dispatches events across multiple CPU cores. It enables the implementation of custom network protocols by processing raw bytes through a sequence of reusable data transformation handlers. The system provides capabilities for non-blocking I/O multiplexing, asynchronous

Tornado is a Python web framework and asynchronous networking library used to build scalable web applications and high-performance servers. It provides a non-blocking HTTP server capable of handling thousands of simultaneous connections. The project functions as a WebSocket server framework, enabling real-time bidirectional communication and persistent connections between clients and servers. It supports the implementation of custom networking protocols and high-performance networking services beyond standard HTTP. Its capabilities cover asynchronous web application development, concurrent A

Boost.org asio module

Swoole is a coroutine-based concurrency library and IO framework for PHP. It provides a system for building high-performance network servers and applications by bringing asynchronous, event-driven, and coroutine-based concurrency to the PHP runtime. The project distinguishes itself by implementing user-space coroutine scheduling and non-blocking IO interception, which transforms standard blocking network and file operations into asynchronous actions. It further enables high-speed data exchange across multiple PHP processes through shared memory management and specialized data structures. The

Starlette is an asynchronous web framework and toolkit for building high-performance web services based on the ASGI specification. It serves as a lightweight foundation for creating web applications with a focus on asynchronous request and response handling. The framework provides specialized toolkits for managing persistent bidirectional WebSocket communication and an asynchronous HTTP server toolkit for routing and middleware. It distinguishes itself by offering a non-blocking background task queue that executes functions after a response has been sent to the client. The project covers a b

This library provides a framework for building event-driven, non-blocking network applications in PHP. It enables the development of asynchronous TCP and TLS servers and clients that manage multiple concurrent connections without stalling the main execution thread. By utilizing an event-loop architecture, the library handles network operations and data exchange through asynchronous streams, ensuring that the application remains responsive during high-throughput tasks. The project distinguishes itself through its integration with operating system primitives, such as raw file descriptors and Un

Gevent is a Python coroutine concurrency library and asynchronous task manager designed for high-concurrency I/O tasks. It provides a cooperative networking framework for building asynchronous TCP, UDP, and HTTP servers, as well as a WSGI web server implementation for hosting web applications. The project is distinguished by its standard library monkey-patching tool, which replaces blocking synchronous functions with cooperative versions to enable asynchronous behavior in third-party code. This allows for a cooperative multitasking workflow where the system yields execution during I/O waits t

This project is a C++ TCP server framework and educational socket programming guide. It provides a high-performance network library focused on event-driven architecture, implementing a reactor pattern to handle thousands of simultaneous client connections. The framework is distinguished by its multi-threaded event loop, which utilizes a main-sub reactor coordination model to distribute network events across a worker thread pool. It includes an abstraction layer for non-blocking socket I/O and event multiplexing via the epoll system call, decoupling network transport from application business

Sanic is an asynchronous Python web framework designed for building high-performance APIs and services. It operates as a production-ready ASGI web server, utilizing a non-blocking event loop to handle concurrent requests and maximize throughput. The framework is built to support scalable architectures, offering built-in worker process management to distribute traffic across available CPU cores. What distinguishes Sanic is its focus on modularity and developer-centric tooling. It features a blueprint-based system for organizing complex applications into pluggable components, alongside a robust

Hyper is a low-level networking library designed for building high-performance HTTP clients and servers. It provides a foundational toolkit for creating network services that leverage asynchronous execution and memory-safe data handling, supporting both HTTP/1 and HTTP/2 protocols. The library distinguishes itself through a protocol-agnostic architecture that separates transport logic from HTTP semantics. It utilizes a service-trait abstraction to decouple network logic from the underlying transport, enabling developers to inject custom middleware for request interception and response transfo

Actix Web is an asynchronous web framework designed for building high-performance network services. It provides a foundation for processing concurrent requests through a non-blocking execution model, utilizing an actor-based concurrency system to manage lightweight processes and message passing. The framework includes a low-level networking layer that handles the parsing and serialization of HTTP traffic according to standard specifications. The framework distinguishes itself through a type-safe routing engine that enforces strict data types at compile time, ensuring that request parameters a

This project is an open-source JavaScript runtime built on the V8 engine. It provides a comprehensive environment for executing JavaScript code outside of a web browser, offering foundational primitives for process management, multi-core load distribution, and parallel execution through worker threads. The runtime includes a broad set of built-in modules for system-level operations, such as file system interaction, network communication across various protocols, and cryptographic security. It supports multiple module systems, native binary addon integration, and diagnostic tools for monitorin

Beast is a C++ library for implementing low-level HTTP and WebSocket clients and servers. It functions as an asynchronous networking framework designed to compose non-blocking I/O operations and layered stream stacks for managing concurrent network traffic, specifically utilizing the Boost.Asio asynchronous model. The library provides a comprehensive implementation of the HTTP/1.1 and WebSocket protocols. For HTTP, it includes primitives for parsing and serializing messages with support for chunked transfer encoding, incremental body reading, and request pipelining. Its WebSocket implementati

The php-standard-library is a comprehensive toolkit for functional programming and asynchronous networking in PHP, featuring typed data structures, structured concurrency, and composable validation mechanisms. It provides explicit result types and pure collection transformers that separate lists from dictionaries, eliminating traditional array key confusion and error-throwing patterns. The library supports concurrent execution through lightweight user-space fibers, message-passing channels, and non-blocking event loops, driving asynchronous TCP, TLS, UDP, and Unix socket servers without relyi

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

Coost is a concurrent network framework and coroutine scheduler designed for building high-performance TCP, HTTP, and RPC services. It provides a set of tools for handling non-blocking IPv4 and IPv6 communication, integrating SSL encryption and a lightweight execution engine that manages concurrent tasks using shared stacks. The project features a specialized JSON RPC implementation for exchanging structured data over encrypted connections and a high-performance logging system. This logging infrastructure supports topic-based routing, frequency filtering, and automated stack trace capture for

PHP-Websockets is a network programming library that provides a persistent server implementation for handling bidirectional real-time communication. It functions as a framework for managing asynchronous data exchange between web clients and server-side application logic, enabling the development of responsive systems that react to incoming messages. The library facilitates the hosting of WebSocket servers by managing persistent connections and pushing live updates to users. It handles the technical requirements of the protocol, including the validation of upgrade requests through handshake ne