Awesome GitHub RepositoriesCoroutine Frameworks

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

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

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

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

Micro is a Node.js HTTP microservices framework used to build asynchronous web servers. It enables the creation of lightweight services that handle requests and responses through single-purpose functions to reduce operational footprint and latency. The framework functions as a JSON API backend and a WebSocket communication server, allowing for the establishment of bidirectional socket connections for real-time data updates and instant messaging. Its capability surface covers HTTP request processing, including the parsing of JSON and URL-encoded request bodies. It also supports external API i

Lua is an embeddable scripting language written in ISO C, designed to be integrated into host applications for runtime customization. It provides a C-based scripting engine and a prototype-based object model that utilizes associative arrays and metatables to implement inheritance and complex data structures. The language features a cooperative multitasking system that manages concurrent execution threads via coroutines and an incremental garbage collector for automatic memory management. It includes a safe code sandbox to isolate global state and run untrusted scripts within a protected envir

Seastar is a C++ server application framework and asynchronous programming library designed for building high-performance, shared-nothing server applications. It functions as a high-performance I/O engine providing direct disk and network access through a shared-nothing framework that partitions data and execution across CPU cores. The framework distinguishes itself through a thread-per-core architecture that eliminates locking and resource contention by assigning one execution thread to each physical CPU core. It implements a userspace TCP/IP stack and kernel-bypass techniques, integrating w

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

This project is a PHP implementation of the Promises/A+ specification, providing a library for managing asynchronous operations and deferred values. It serves as an asynchronous task coordinator that allows for the creation of non-blocking code through a promise-based pattern. The library enables the simulation of asynchronous coroutines, allowing non-blocking code to be written in a linear style. It features duck-typed interoperability, which allows it to integrate with any foreign object that implements a then method regardless of class inheritance. The project covers broader capabilities

Hyperf is a high-performance PHP coroutine framework designed for building microservices and middleware. It utilizes non-blocking coroutines to handle high concurrency and low-latency request processing, providing a foundation for scalable distributed systems. The framework is distinguished by an aspect-oriented programming based dependency injector that enables pluggable components and meta-programming. It includes a coroutine-optimized object-relational mapper with integrated model caching and an orchestration toolkit for microservice governance, featuring service discovery, circuit breaker

This is an open-source Android application that serves as a reference implementation for modern app architecture. It demonstrates a modular, testable structure built with Kotlin, Coroutines, and Jetpack libraries, organized into independent feature modules that each follow Clean Architecture and the MVVM pattern. The project enforces coding standards through an automated static analysis pipeline that integrates linting, formatting checks, and code quality tools directly into the build process, failing the build on any violations. It uses reusable Gradle convention plugins to standardize build

Tivi is a cross-platform application for discovering and tracking television shows, built with Kotlin Multiplatform and Compose Multiplatform to share its user interface across Android, iOS, and desktop platforms. The app follows the Model-View-Intent (MVI) architecture pattern, where user actions are modelled as sealed class intents that reduce into a single immutable state object, ensuring predictable and unidirectional data flow managed through Kotlin coroutines and StateFlow. The application uses Hilt for compile-time dependency injection and SQLDelight for type-safe local data storage, c

This project provides architectural standards and patterns for organizing Django applications. It defines a project architecture guide focused on decoupling business logic from views and models through a service-layer architecture. The guide establishes specific design patterns, including a service layer for standalone business logic functions and a data selector pattern for isolating complex database queries. It defines a standard for single-purpose views that delegate logic to services and utilize dedicated serializers for data input and output. The framework covers several broader capabil

MockK is a Kotlin test double framework that creates mocks, spies, and relaxed mocks for unit testing, with support for final classes, static methods, and coroutines. It functions as a bytecode instrumentation library that modifies compiled class files at load time to intercept constructors, final methods, and static functions without source changes, and also provides dedicated libraries for constructor mocking and coroutine mocking. The framework is designed specifically for Kotlin, handling Kotlin-specific constructs like extension functions, singletons, and suspend functions. MockK disting

LuaJIT ist eine hochperformante Lua-Sprachimplementierung und ein Just-in-Time-Compiler. Es fungiert als eingebettete Skript-Engine und dynamischer Binär-Übersetzer, der portablen Bytecode während der Ausführung in nativen Maschinencode umwandelt. Das Projekt konzentriert sich auf hochperformantes Skripting durch die Übersetzung von Bytecode in architekturspezifische Anweisungen, um Ausführungsgeschwindigkeiten nahe an kompiliertem C-Code zu erreichen. Es nutzt eine leichtgewichtige Laufzeitumgebung, die auf minimalen Speicher-Overhead ausgelegt ist. Das System unterstützt die Verarbeitung binärer Daten mittels bitweiser Operationen und ermöglicht asynchrones Task-Management durch die Integration von C-Coroutines. Es bietet zudem Funktionen für die Laufzeit-Codegenerierung und die Erstellung benutzerdefinierter Maschinencode-Anweisungen.

Kotest is a comprehensive testing framework for Kotlin designed for writing and executing tests across various styles and platforms. It serves as a multiplatform test runner and a fluent assertion library, providing a toolset for both unit and integration testing in Kotlin applications. The framework supports multiple testing methodologies, including behavior-driven development with nested test hierarchies, property-based testing using automated data generation, and data-driven testing. It also includes snapshot testing to detect regressions by comparing current outputs against stored referen

cppinsights ist ein C++-Compiler-Visualisierungs- und statisches Analysetool, das das Clang-Frontend nutzt, um Quellcode in einen abstrakten Syntaxbaum zu parsen. Es fungiert als Source-to-Source-Transformer, der C++-Code umschreibt, um implizites Compiler-Verhalten und verborgene Operationen explizit und sichtbar zu machen. Das Tool ist darauf spezialisiert, komplexe Sprachkonstrukte aufzuschlüsseln, wie etwa die interne Funktionsweise von Coroutines, um deren Suspendierungs- und Resumption-Logik zu visualisieren. Zudem macht es den bei der Template-Instanziierung generierten Code sichtbar und wandelt implizite Compiler-Aktionen, einschließlich strukturierter Bindings und spezieller Member-Funktionen, in explizite Quellcode-Repräsentationen um. Zu den weiteren Funktionen gehören die Auflösung von using-Anweisungen und die Generierung von Strukturkarten für C++-Klassen-Vererbungshierarchien.

Amp ist ein nicht-blockierendes Concurrency-Framework für PHP. Es bietet eine Kerninfrastruktur für das Schreiben asynchroner Anwendungen unter Verwendung einer Event-Loop, um Operationen, Timer und Signale innerhalb eines einzelnen Prozesses zu planen. Das Projekt implementiert eine Coroutine-Bibliothek, die Fibers nutzt, um die Funktionsausführung anzuhalten und fortzusetzen. Dies ermöglicht es dem System, gleichzeitige Aufgaben zu verarbeiten, ohne den Hauptausführungs-Thread zu blockieren, was die CPU-Auslastung bei Ein- und Ausgabeoperationen optimiert. Es verwaltet zudem ausstehende Operationsergebnisse durch eine Future- und Promise-Implementierung. Das Framework deckt ein breites Spektrum an Koordinationsfähigkeiten ab, einschließlich nicht-blockierendem I/O-Multiplexing, Token-basierter Aufgabenstornierung zum Abbrechen lang laufender Operationen und Strategien zum Abwarten des Abschlusses mehrerer gleichzeitiger Aufgaben. Es enthält zudem Mechanismen für die Planung wiederkehrender Aufgaben und das Pausieren der Ausführung.

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

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