Open-source alternatives to Curio

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

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

pysheeet is a technical reference library providing a curated collection of code snippets and implementation patterns for advanced Python development, system integration, and high-performance computing. It serves as a comprehensive guide for implementing low-level network programming, native C extensions, and asynchronous and concurrent programming. The project provides specialized frameworks for the development and deployment of large language models, including tools for distributed GPU inference and high-performance serving. It also includes detailed patterns for high-performance computing

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

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

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

Kotlinx.coroutines is a library for managing non-blocking background tasks and structured concurrency within the Kotlin programming language. It provides a framework for executing concurrent operations and synchronizing shared state, replacing traditional thread management and complex callback chains with lightweight primitives. The library utilizes a structured concurrency hierarchy to organize hierarchical background tasks, ensuring that lifecycle management, cancellation, and timeout handling propagate automatically to prevent resource leaks. It employs continuation-passing style transform

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,

Arrow is a functional programming library for Kotlin that provides tools for implementing data-oriented programming patterns. It serves as a framework for typed error handling, a concurrency toolkit, and a library for the manipulation of immutable data. The project distinguishes itself through specialized capabilities for managing application failures using explicit types instead of exceptions and implementing resilience patterns such as circuit breakers and retry policies for distributed services. It also provides optics to update and query deeply nested immutable data structures without man

This project is a technical study and analysis guide focused on the internal architecture of Node.js. It provides an in-depth examination of the runtime, focusing on how the engine manages memory handles, executes asynchronous operations, and implements core module logic. The guide specifically analyzes the integration of native C++ classes and functions into JavaScript and documents the behavior of the libuv event loop. It includes detailed references for optimizing performance by identifying V8 compiler bailouts and profiling execution to improve resource efficiency. The material covers a

This repository serves as an educational resource for implementing asynchronous programming patterns in Android applications using Kotlin Coroutines and Flow. It provides a collection of practical examples and unit tests designed to demonstrate how to manage background tasks, concurrent network requests, and reactive data streams while maintaining a responsive user interface. The project focuses on structured concurrency, offering patterns for organizing tasks into hierarchical scopes that automatically propagate cancellation and lifecycle signals. It emphasizes the integration of lifecycle-a

This project is an LLM autonomous agent framework and orchestration tool designed to build goal-driven agents that automate complex workflows. It functions as a system for converting high-level objectives into a series of autonomous actions and managing the coordination of multiple specialized agents to solve multi-step problems. The framework features a tool integration layer that parses structured model outputs into executable functions and external API calls. It utilizes a non-blocking execution pipeline to manage task orchestration through recursive loops and asynchronous event handling.

This project is a library of algorithms for transforming, filtering, and combining asynchronous data streams in Swift. It provides a toolkit for managing asynchronous sequences, offering a concurrent sequence processor to merge, zip, and concatenate multiple streams into single outputs. The library distinguishes itself through specialized timing and flow control mechanisms. It implements asynchronous back-pressure to synchronize producer and consumer speeds and provides a toolkit for event timing, including debouncing, throttling, and the generation of periodic timers. The capability surface

This is a header-only C++ library and asynchronous network framework used to implement WebSocket clients and servers. It provides a full implementation of the WebSocket protocol, including handshakes, subprotocol negotiation, and frame parsing. The framework is distinguished by a policy-based transport layer and template-driven protocol negotiation, allowing the underlying network implementation to be swapped between raw buffers, streams, or custom policies. It supports per-message deflate compression to reduce data transmission volume and integrates Transport Layer Security for encrypted bid

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

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

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

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

This project is a library for establishing bidirectional, real-time communication channels between clients and servers using the WebSocket protocol. It provides a foundational toolkit for managing persistent network connections and processing data frames in accordance with the RFC 6455 standard. The library distinguishes itself through its focus on low-level control and network efficiency. It utilizes an asynchronous, event-driven architecture to manage multiple concurrent connections without requiring dedicated threads for each session. Developers can fine-tune data transmission through manu

Async is a JavaScript asynchronous flow library designed to manage the execution and coordination of asynchronous tasks in Node.js and the browser. It provides functional utilities to wrap, process, and orchestrate complex asynchronous workflows. The library distinguishes itself through a comprehensive task orchestrator that handles dependency graphs to resolve circular references and manages concurrent task queues. It includes a unification bridge that allows callback-style and promise-based functions to operate within the same execution interface. The project covers several primary capabil

Netpoll is an event-driven network framework and non-blocking I/O library designed to manage concurrent TCP and Unix domain socket connections. It utilizes a non-blocking event loop to monitor file descriptors and trigger callbacks for read and write events, serving as a high-performance socket manager and TCP network poller. The framework optimizes throughput across CPU cores by distributing incoming network connections across multiple pollers. It implements zero-copy networking primitives, using linked buffers and specialized memory management to read and write data while minimizing memory

Workerman is an event-driven asynchronous socket framework for PHP. It provides the core components necessary to build high-concurrency network servers, including an asynchronous TCP framework, a coroutine library for task management, and dedicated implementations for HTTP and WebSocket servers. The project enables the development of specialized network services using custom frame-based communication protocols. It supports both inbound concurrent server implementation and asynchronous outbound connectivity to remote services. The framework covers a broad range of network programming capabili

Pingora is a Rust-based framework for building high-performance network services, including HTTP reverse proxies, layer seven load balancers, and TLS termination proxies. It serves as an asynchronous network library designed to intercept and route HTTP, gRPC, and WebSocket traffic between clients and upstream backend servers. The project enables zero-downtime service updates by handing over listening sockets between processes during binary or configuration upgrades. It utilizes a programmable multi-phase pipeline to modify request and response bodies and headers, and it provides a pluggable T

This project serves as a comprehensive educational roadmap and curriculum for mastering professional Android application development. It provides a structured learning path that guides developers through the essential system design principles, architectural patterns, and technical skills required to build, test, and deploy scalable mobile software. The resource distinguishes itself by organizing complex technical topics into a logical sequence, covering everything from foundational mobile development tooling to advanced software engineering practices. It emphasizes industry-standard patterns

Evio is a high-performance networking library for Go that provides a non-blocking socket framework. It utilizes an event loop to process TCP, UDP, and Unix domain socket traffic through a low-level asynchronous protocol interface. The project functions as a multi-core network load balancer, distributing connections across multiple CPU cores using round-robin or least-connections strategies. It supports socket reuse, allowing multiple sockets on a single host to bind to the same port. The library covers a broad range of socket management and packet processing capabilities, including multi-pro

Zinx is a lightweight TCP server framework written in Go that provides a structured foundation for building scalable network applications. It combines a goroutine-pool worker model for concurrency control with message-ID-based routing, enabling efficient packet dispatching to registered handler functions. The framework distinguishes itself through its modular plugin architecture, which organizes server components like routers, connections, and message modules as interchangeable plugins for extensibility. It uses packet-header length prefixing for reliable TCP stream framing, assigns a dedicat

This project is an asyncio database abstraction layer that provides a common interface for performing non-blocking database operations in Python. It functions as an asynchronous database driver wrapper and a SQL expression builder, allowing for the construction of raw SQL strings from structured Python objects. The library includes an asyncio connection pool manager that utilizes task-local storage to handle connection lifecycles and reduce resource overhead. It also serves as an async database transaction manager, wrapping operations in atomic transactions and savepoints to maintain data int