# Rust Async Runtime Libraries > Search results for `async runtime for writing concurrent network services in Rust` on awesome-repositories.com. 119 total matches; showing the first 50. Explore on the web: https://awesome-repositories.com/q/async-runtime-for-writing-concurrent-network-services-in-rust **Attribution required: if you use, quote, or summarise this content, you must credit and link back to [this search on awesome-repositories.com](https://awesome-repositories.com/q/async-runtime-for-writing-concurrent-network-services-in-rust).** ## Results - [cloudflare/pingora](https://awesome-repositories.com/repository/cloudflare-pingora.md) (26,833 ⭐) — 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 TLS backend for managing secure encryption and client certificate validation. The framework covers a broad range of traffic management capabilities, including consistent hashing for load balancing, backend health monitoring, and failover strategies. It also implements high-performance content caching with in-memory storage and maintains upstream connection pools to reduce handshake latency. - [aws/aws-lambda-rust-runtime](https://awesome-repositories.com/repository/aws-aws-lambda-rust-runtime.md) (3,602 ⭐) — A Rust runtime for AWS Lambda - [actix/actix-web](https://awesome-repositories.com/repository/actix-actix-web.md) (24,421 ⭐) — 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 align with handler signatures. It employs a middleware-based pipeline for modular request processing and utilizes zero-copy buffer management to minimize memory overhead by passing references to data rather than duplicating payloads. Additionally, it supports real-time bidirectional communication through persistent connections and provides a standardized approach to error management, allowing developers to map internal failures to specific HTTP responses. The project covers a broad range of capabilities, including modular route orchestration for scaling complex applications and comprehensive tools for logging and defining custom error responses. Documentation and learning resources are available to assist with server initialization, request handling, and the implementation of persistent network connections. - [fastapi/fastapi](https://awesome-repositories.com/repository/fastapi-fastapi.md) (99,260 ⭐) — FastAPI is a web framework for building APIs with Python. It leverages standard language type hints to provide automatic data validation, request parsing, and interactive API documentation generation. The framework supports asynchronous request handling and manages execution contexts to prevent blocking the main event loop. The project includes a dependency injection system that allows for the resolution and injection of reusable components into request handlers. This system supports request-scoped caching, lifecycle management, and integration with security mechanisms like OAuth2 and JSON Web Tokens. Developers can organize applications into modular routers and mount sub-applications to manage complex routing logic. Infrastructure features include middleware support for cross-origin resource sharing, background task management, and static file serving. The framework automatically generates OpenAPI specifications for defined endpoints, which can be customized through metadata and schema extensions. Testing utilities are provided to simulate HTTP and WebSocket connections, allowing for isolated verification of application behavior. - [tiangolo/fastapi](https://awesome-repositories.com/repository/tiangolo-fastapi.md) (99,301 ⭐) — FastAPI is a high-performance Python web framework designed for building REST APIs. It operates as an ASGI web framework, providing a system to create structured HTTP endpoints that automatically serialize data and validate request parameters. The framework utilizes Python type hints to drive data validation and serialization, automatically generating machine-readable OpenAPI and JSON Schema specifications. This process enables the automatic creation of interactive, browser-based API documentation where endpoints can be tested directly. The project includes a dependency injection system for managing shared logic and supports asynchronous request handling and WebSocket communication for real-time data exchange. It also provides tools for API endpoint security through authentication and authorization standards. Local development is supported via a server with hot reloading, and the framework includes utilities for automated cloud deployment. - [dioxuslabs/dioxus](https://awesome-repositories.com/repository/dioxuslabs-dioxus.md) (36,400 ⭐) — Dioxus is a cross-platform development framework designed for building native desktop, mobile, and web applications from a single codebase. It utilizes a declarative component model and macro-powered syntax to define reusable interface elements, which are then rendered as native widgets or web elements. At its core, the framework employs a signal-based reactivity system that tracks state dependencies to trigger granular updates, ensuring efficient interface performance without re-rendering the entire application tree. The framework distinguishes itself through a unified full-stack runtime that integrates server-side logic with client-side interactive components. It supports server-side rendering with HTML streaming and hydration, allowing developers to generate initial content on the server for improved load times and search engine visibility. Additionally, Dioxus provides a hot-reload development workflow that patches functions at runtime, enabling rapid iteration on application logic and interface designs without requiring manual restarts. Beyond its core rendering and reactivity capabilities, Dioxus includes a comprehensive suite of tools for managing complex application requirements. This includes a robust routing system for nested layouts and dynamic parameter parsing, as well as advanced state management features like context sharing, signal-based data flow, and asynchronous task integration. The framework also offers native desktop integration for managing system windows and hardware access, alongside optimized networking primitives for bidirectional data streaming and efficient resource fetching. - [rust-lang/async-book](https://awesome-repositories.com/repository/rust-lang-async-book.md) (2,185 ⭐) — Asynchronous Programming in Rust - [async-rs/async-std](https://awesome-repositories.com/repository/async-rs-async-std.md) (4,068 ⭐) — Async version of the Rust standard library - [libuv/libuv](https://awesome-repositories.com/repository/libuv-libuv.md) (26,912 ⭐) — 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 work. Beyond networking and threading, the library covers asynchronous filesystem access and real-time event monitoring. It also provides tools for child process management, system signal handling, and high-resolution timing for performance tracking. Core capabilities are exposed to multiple programming languages through community-maintained bindings and wrappers. - [duckdb/duckdb](https://awesome-repositories.com/repository/duckdb-duckdb.md) (38,805 ⭐) — DuckDB is an in-process analytical database engine designed to run directly within an application process. As a zero-dependency, embedded system, it provides enterprise-grade SQL data processing capabilities without the overhead of managing a dedicated database server. It is built to handle complex analytical and aggregation tasks by storing and retrieving information in columns, allowing for high-performance relational data manipulation. The engine distinguishes itself through a columnar vectorized execution model that maximizes CPU cache efficiency during query operations. It employs adaptive query optimization to dynamically select execution plans at runtime and utilizes zero-copy ingestion to map external data formats directly into memory. To facilitate integration with analytical programming environments, the system supports high-performance data exchange through standardized memory formats and provides specialized connectors for Python, R, and Java. The project covers a broad capability surface, including advanced relational join operations, incremental result streaming for large datasets, and flexible data ingestion from various file formats. It supports complex data types and provides a comprehensive command-line interface for interactive session management and batch processing. The codebase is designed for portability, offering single-file amalgamation to simplify integration into external projects and build systems. - [rust-in-action/code](https://awesome-repositories.com/repository/rust-in-action-code.md) (2,122 ⭐) — Source code for the book Rust in Action - [zlmediakit/zlmediakit](https://awesome-repositories.com/repository/zlmediakit-zlmediakit.md) (17,197 ⭐) — ZLMediaKit is a high-concurrency streaming engine designed to function as a protocol gateway and media server. It provides a native development kit for embedding streaming and transcoding capabilities directly into custom applications, supporting the ingestion, distribution, and recording of live video feeds across various network protocols. The platform distinguishes itself through a high-performance architecture that bridges legacy surveillance protocols with modern web-compatible streaming standards. It utilizes a thread-per-core execution model and zero-copy buffer management to maintain low-latency delivery, enabling the translation of media formats and container types to ensure interoperability across diverse network environments. Beyond core streaming, the server includes a RESTful API and webhook-driven event orchestration for programmatic control over stream authentication, traffic monitoring, and server operations. It supports the capture of live streams into standard file formats for on-demand playback and provides hooks for extending server functionality through external application logic. - [cloudflare/workerd](https://awesome-repositories.com/repository/cloudflare-workerd.md) (8,346 ⭐) — workerd is a serverless edge runtime designed for executing lightweight, distributed functions at the network edge. It utilizes a V8-based JavaScript engine to provide fast startup and low memory overhead, while maintaining a WebAssembly-compatible execution environment that allows modules to run alongside JavaScript for high-performance computational tasks. The runtime supports isolate-based multi-tenancy to run multiple independent execution contexts within a single process. It implements an event-driven execution model that triggers code based on network requests or scheduled events and includes support for privileged socket inheritance to operate under unprivileged user accounts. The project covers a broad set of capabilities including serverless API development, AI inference deployment using GPU hardware and vector databases, and automated browser orchestration for web scraping. Additional functionality encompasses global state management via SQL databases and key-value stores, background job scheduling with message queues, and the delivery of static assets through a content delivery network. Development is supported by a command-line interface for project management, custom build pipelines, and tools for pinning runtime behavior to specific dates to ensure consistency. - [xtls/xray-core](https://awesome-repositories.com/repository/xtls-xray-core.md) (39,605 ⭐) — Xray-core is a high-performance, cross-platform networking engine designed to manage secure data transmission and traffic routing. At its core, the project utilizes an asynchronous, event-driven runtime model capable of handling thousands of concurrent connections through non-blocking input and output. It functions as a central traffic controller, employing a sophisticated routing engine that dynamically matches incoming network requests to specific outbound proxies based on user-defined criteria. The project distinguishes itself through a modular architecture that decouples proxy and transport layers, allowing for the flexible stacking of security and obfuscation protocols. This design supports stateful connection multiplexing to improve efficiency and includes a pluggable transport layer that encapsulates network streams to mask traffic patterns. By providing a framework for custom protocol development, it enables the implementation of specialized communication standards to maintain stable connections across diverse and restrictive network environments. The software encompasses a broad range of infrastructure capabilities, including compile-time feature flagging to minimize binary size and a comprehensive suite of tools for managing proxy connections. It supports consistent deployment across various operating systems, with automated build processes that facilitate the generation of executable binaries. Detailed documentation and installation guides are provided to assist in setting up the environment and configuring the underlying network services. - [crystal-lang/crystal](https://awesome-repositories.com/repository/crystal-lang-crystal.md) (20,299 ⭐) — Crystal is a statically typed, compiled programming language designed for high performance and memory safety. It leverages an LLVM-based compiler to translate source code into optimized machine-executable binaries, while its type-inference-based static analysis enforces strict safety rules during the build process. The language distinguishes itself through a fiber-based concurrent runtime that manages lightweight execution units for asynchronous input and output without blocking the main process. It also features a powerful compile-time macro system that allows for the inspection and transformation of the abstract syntax tree, enabling developers to automate repetitive tasks and generate code dynamically during compilation. Furthermore, Crystal provides a native foreign function interface that maps native memory layouts and function signatures to local identifiers, facilitating direct interaction with external system libraries. Beyond its core language features, Crystal includes a comprehensive suite of tooling for the entire software lifecycle. This includes dependency management, automated testing frameworks, documentation generation, and project scaffolding utilities. The ecosystem supports high-performance systems programming, cross-architecture compilation, and the production of statically linked binaries to simplify deployment across diverse environments. - [shenxiaocam/deep-network-embedding-for-graph-representation-learning-in-signed-networks](https://awesome-repositories.com/repository/shenxiaocam-deep-network-embedding-for-graph-representation-learning-in-signed-networks.md) (14 ⭐) — Deep network embedding for graph representation learning in signed networks - [ardanlabs/service](https://awesome-repositories.com/repository/ardanlabs-service.md) (4,030 ⭐) — Starter-kit for writing services in Go using Kubernetes. - [walkor/workerman](https://awesome-repositories.com/repository/walkor-workerman.md) (11,547 ⭐) — 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 capabilities, including secure socket communication via network traffic encryption and the management of shared state through coroutine communication channels. It also includes tools for server lifecycle management to control the operational state of the application. - [iced-rs/iced](https://awesome-repositories.com/repository/iced-rs-iced.md) (30,757 ⭐) — Iced is a cross-platform graphical user interface framework designed for building interactive applications with a focus on type safety and predictable state management. It utilizes a declarative architecture that separates application state, update logic, and view rendering, allowing developers to construct complex interfaces by nesting reusable functional components. The framework distinguishes itself through an Elm-inspired message-passing pattern, where all user interactions are processed as discrete messages to ensure reliable state transitions. It employs an immediate-mode rendering paradigm and a constraint-based layout engine, which together ensure that the interface remains synchronized with the application state and responsive across varying screen sizes and operating systems. Beyond its core architecture, the project provides a comprehensive set of primitives for interface engineering. This includes tools for managing dynamic text, container alignment, and styling, all of which map to native graphical backends to maintain a consistent look and feel. The system relies on strict data modeling to prevent invalid states, ensuring that business logic remains maintainable and robust throughout the development lifecycle. - [bee-san/rustscan](https://awesome-repositories.com/repository/bee-san-rustscan.md) (19,969 ⭐) — RustScan is a high-speed network reconnaissance tool designed for automated port discovery and service enumeration. It functions as an automated vulnerability scanner that identifies open ports and active services across network environments, providing a foundation for mapping attack surfaces and gathering intelligence on target systems. The tool distinguishes itself through its ability to dynamically adjust scanning parameters and concurrency in real-time based on system feedback, ensuring efficient performance while preventing network congestion. It features an extensible architecture that supports the execution of custom scripts and the automated piping of discovered data into external security utilities, including native integration with Nmap for deep service analysis. Beyond basic port discovery, the software supports payload-driven service probing to accurately classify network services and includes capabilities for UDP service identification. It is built as a cross-platform utility, utilizing a unified codebase to generate native binaries for multiple operating systems. - [ruby-concurrency/concurrent-ruby](https://awesome-repositories.com/repository/ruby-concurrency-concurrent-ruby.md) (5,830 ⭐) — Modern concurrency tools including agents, futures, promises, thread pools, supervisors, and more. Inspired by Erlang, Clojure, Scala, Go, Java, JavaScript, and classic concurrency patterns. - [denoland/deno](https://awesome-repositories.com/repository/denoland-deno.md) (107,110 ⭐) — Deno is a high-performance runtime for JavaScript and TypeScript that prioritizes security and developer productivity. Built on the V8 engine, it provides a secure execution environment that enforces a default-deny security model, requiring explicit user authorization for access to system resources like the file system, network, and environment variables. The runtime natively supports modern web-standard APIs, ensuring consistent behavior and portability across different environments. What distinguishes Deno is its integrated approach to the software development lifecycle. It bundles essential utilities—including a formatter, linter, test runner, and dependency manager—directly into the runtime, eliminating the need for external build tools or complex transpilation steps. The platform features a universal module resolution system that supports remote HTTPS URLs, local paths, and standard package registries, all backed by lockfiles to ensure build determinism and supply chain security. Beyond its core runtime capabilities, Deno includes a built-in, persistent key-value database engine that supports atomic transactions and reactive data monitoring. It also provides a robust compatibility layer for the Node.js ecosystem, allowing for the seamless execution of legacy modules and native binary addons. For multi-tenant or distributed applications, the runtime offers isolated sandbox environments that manage resource constraints and security boundaries, facilitating secure code execution in shared infrastructure. The project is distributed as a single binary, providing a unified toolchain for managing dependencies, executing tasks, and configuring runtime security policies. - [vi/websocat](https://awesome-repositories.com/repository/vi-websocat.md) (8,571 ⭐) — Websocat is a specialized set of command-line tools for WebSocket communication, acting as a client, server, and stream processor. It provides a terminal-based interface for connecting to WebSocket servers, hosting secure WebSocket servers, and bridging data between WebSockets and other network transports. The project distinguishes itself by functioning as a bidirectional network relay, allowing the routing of data between WebSocket streams, TCP sockets, UNIX sockets, and standard system input and output. It includes specialized implementations for SOCKS5 and HTTP proxying, as well as a stream processor capable of transforming WebSocket messages into line-based or binary records for use with external programs. The toolset covers a broad range of networking capabilities, including secure communication via TLS and symmetric encryption, protocol bridging, and network debugging through traffic inspection. It also supports server mocking, automatic connection re-establishment, and the exposure of performance metrics on dedicated ports. The project is packaged as a lightweight Docker container image for deployment across different environments. - [agno-agi/agno](https://awesome-repositories.com/repository/agno-agi-agno.md) (40,717 ⭐) — Agno is an agent operating system designed to manage the lifecycle, tool execution, and persistent state of autonomous agents across distributed infrastructure. It provides a unified runtime environment that wraps diverse agent frameworks into a consistent, interoperable protocol, allowing developers to build and deploy complex multi-agent systems that coordinate tasks and delegate sub-processes. The platform distinguishes itself through a robust governance and orchestration layer that includes human-in-the-loop approval gates, role-based access control, and a centralized API gateway. It features a shared cultural knowledge layer that enables agents to reflect on interactions and store universal principles across sessions, alongside persistent memory architectures that manage chat history and context retrieval. The system supports a wide range of operational capabilities, including real-time response streaming, asynchronous background task management, and automated performance evaluation. It integrates with external systems through standardized interfaces and provides comprehensive observability tools to trace autonomous decision paths and monitor agent accuracy in production environments. Developers can configure the system using typed classes or YAML files, and the platform exposes agents as secure, scalable web services with built-in middleware for authentication and request validation. - [mmstick/concurr](https://awesome-repositories.com/repository/mmstick-concurr.md) (117 ⭐) — Performs distributed command execution, written in Rust w/ Tokio - [cesanta/mongoose](https://awesome-repositories.com/repository/cesanta-mongoose.md) (12,876 ⭐) — Mongoose is an embedded networking library providing TCP/IP stacks, web server hosting, and IoT device connectivity. It enables microcontrollers and desktop systems to implement network protocols including HTTP, WebSocket, and MQTT. The project provides a bare-metal TCP/IP stack for environments without a native operating system and includes built-in TLS and ECC encryption to secure network traffic. It features a binary-embedded file system to serve web content directly from the executable and supports over-the-air firmware updates for managing device fleets. Additional capabilities cover asynchronous DNS resolution, the creation of embedded device dashboards for hardware monitoring, and an event-driven network loop for handling asynchronous I/O. The library supports both internal stack implementations and standard BSD socket APIs. - [google/comprehensive-rust](https://awesome-repositories.com/repository/google-comprehensive-rust.md) (33,049 ⭐) — Comprehensive Rust is a structured educational curriculum designed to teach the Rust programming language, focusing on its core principles of memory safety, performance, and type correctness. The project provides a comprehensive learning path for software engineers, covering the language's ownership model, borrow checking, and compile-time validation mechanisms that eliminate common memory-related errors without the need for a garbage collector. The curriculum distinguishes itself by offering specialized modules that demonstrate how to apply these safety guarantees in diverse, high-performance environments. It includes dedicated training for systems programming, bare-metal development, and integration strategies for large-scale projects like Android and Chromium. By combining technical documentation with practical code examples, the resource helps developers transition to memory-safe systems development while mastering idiomatic patterns. The materials cover the full breadth of the language, including its type system, generic programming, error handling, and concurrency primitives. It also addresses advanced topics such as metaprogramming, smart pointers, and the controlled use of unsafe blocks for low-level hardware access. The project is designed as a self-contained training resource, providing the necessary context and exercises to build proficiency in writing efficient, reliable software. - [async-plus/async-plus](https://awesome-repositories.com/repository/async-plus-async-plus.md) (213 ⭐) — ⛓ A chainable interface for Swift's async/await. - [chenshuo/muduo](https://awesome-repositories.com/repository/chenshuo-muduo.md) (16,157 ⭐) — 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 functions. The library covers core network programming capabilities including non-blocking I/O multiplexing via epoll and TCP connection abstractions that decouple network transport from application logic. It also provides a thread-safe event queue to manage tasks across different event loops. - [typelift/concurrent](https://awesome-repositories.com/repository/typelift-concurrent.md) (208 ⭐) — Functional Concurrency Primitives - [encode/httpx](https://awesome-repositories.com/repository/encode-httpx.md) (15,090 ⭐) — This project is a comprehensive Python network request framework designed for both synchronous and asynchronous HTTP communication. It provides a high-performance client capable of executing non-blocking requests within event-driven applications, while also supporting standard blocking calls for simpler scripts. The library is built to operate natively across diverse asynchronous runtimes, automatically detecting and utilizing the underlying event loop for concurrency. What distinguishes this library is its modular architecture, which decouples request construction from network execution through swappable transport layers. It features a middleware-based hook system that allows for the injection of custom logic into the request-response lifecycle, enabling advanced capabilities like custom authentication, detailed activity logging, and internal network event tracing. The framework also supports protocol-multiplexing via HTTP/2 and maintains long-lived connection pools to minimize handshake overhead across sequential requests. The library covers a broad range of networking requirements, including real-time communication through WebSocket and server-sent event interfaces, secure proxy routing, and granular control over SSL and TLS configurations. It provides robust tools for data handling, such as stream-oriented processing for large payloads, automatic content decoding, and multipart file uploads. Additionally, it includes built-in utilities for testing and debugging, such as response mocking, traffic recording, and direct invocation of local applications. The project is distributed as a feature-rich library that integrates into Python environments to manage complex API interactions and low-level transport configurations. - [shadowsocks/shadowsocks-libev](https://awesome-repositories.com/repository/shadowsocks-shadowsocks-libev.md) (16,180 ⭐) — shadowsocks-libev is an event-driven network daemon that provides an encrypted SOCKS5 proxy. It functions as a lightweight proxy server using a non-blocking event loop to route TCP and UDP traffic through encrypted tunnels to bypass network restrictions. The project implements a transparent proxy gateway capable of intercepting outbound packets at the network layer, allowing system traffic to be redirected through the encrypted tunnel without per-application configuration. It also includes a daemon process manager to control multiple proxy server instances as child processes via local communication sockets. The system covers a broad range of traffic management capabilities, including local port forwarding, encryption tunnel multiplexing, and the encapsulation of UDP datagrams within TCP streams. Access is managed through IP-based access control lists that permit or block client connections. - [fermyon/spin](https://awesome-repositories.com/repository/fermyon-spin.md) (6,443 ⭐) — Spin is a WebAssembly serverless framework and development toolchain for building and running portable microservices. It functions as an event-driven orchestrator and runtime that executes WebAssembly components, allowing developers to map HTTP requests, Redis messages, and cron schedules to specific modules. The project distinguishes itself by implementing a Wasm-based AI inference gateway, enabling components to perform model inference and generate text embeddings. It utilizes the WebAssembly Component Model and WASI for language-agnostic composition and portable host interfacing, while employing a capability-based security system to restrict access to network hosts and storage backends. The framework provides a comprehensive set of capabilities including OCI-compliant distribution, in-memory service chaining for internal microservices, and integration with various SQL and NoSQL databases. It also includes tools for background task spawning, OpenTelemetry signal export for observability, and a CLI for project bootstrapping and hot reloading. The toolchain supports compiling multilingual components into WebAssembly and deploying them across local environments, Kubernetes clusters, or global edge distributions. - [async-graphql/async-graphql](https://awesome-repositories.com/repository/async-graphql-async-graphql.md) (3,671 ⭐) — A GraphQL server library implemented in Rust - [autoscrape-labs/pydoll](https://awesome-repositories.com/repository/autoscrape-labs-pydoll.md) (6,919 ⭐) — pydoll is a Chrome DevTools Protocol automation library and headless browser controller used for web data extraction and parallel browser automation. It controls Chromium-based browsers via direct WebSocket connections, allowing it to manage isolated browser contexts and tabs while bypassing the overhead and detection associated with WebDriver. The project features an anti-bot evasion framework that mimics natural human behavior, including mouse movements generated via Bezier curves and variable typing patterns. It provides specialized stealth capabilities to bypass behavioral analysis and automate interactions with CAPTCHA challenges. The library covers a broad range of capabilities, including network traffic interception for mocking server responses, comprehensive DOM manipulation and shadow DOM traversal, and structured data mapping for extracting content from dynamic pages. It also includes tools for browser fingerprint spoofing, identity synchronization, and the capture of page screenshots, PDFs, and screencasts. - [coturn/coturn](https://awesome-repositories.com/repository/coturn-coturn.md) (13,637 ⭐) — Coturn is a network server that facilitates peer-to-peer media traffic for real-time communication applications. It functions as a relay platform for voice, video, and data transmission, enabling direct connections between clients located behind restrictive firewalls and network address translators. The server implements standard network traversal protocols to manage media packet exchange and client authentication. It utilizes a multi-threaded architecture and event-driven polling to handle high-throughput traffic, while employing hash-based message authentication codes to verify client identity and secure access to relay services. The platform includes a modular interface for persistent storage of credentials and server state across various database backends. It also provides integrated monitoring capabilities to track traffic volume, connection status, and operational health metrics, allowing for the identification of performance bottlenecks in distributed communication environments. - [tejzpr/ordered-concurrently](https://awesome-repositories.com/repository/tejzpr-ordered-concurrently.md) (46 ⭐) — Ordered-concurrently a library for concurrent processing with ordered output in Go. Process work concurrently and returns output in a channel in the order of input. It is useful in concurrently processing items in a queue, and get output in the order provided by the queue. - [free/concurrent-writer](https://awesome-repositories.com/repository/free-concurrent-writer.md) (63 ⭐) — Highly concurrent drop-in replacement for bufio.Writer - [electric-sql/electric](https://awesome-repositories.com/repository/electric-sql-electric.md) (9,909 ⭐) — Electric is a Postgres data synchronization engine and replication proxy designed to enable local-first software. It replicates data from Postgres databases to client-side stores in real time using logical replication, allowing applications to maintain a local embedded database for offline access and low-latency updates. The system distinguishes itself by using shapes to filter and authorize specific subsets of database rows and columns before streaming them to clients or edge workers. It further supports multi-user collaboration by integrating a conflict-free replicated data type framework to ensure consistent state synchronization across different users. The project covers a broad range of capabilities, including reactive state management and real-time data streaming to client interfaces and server-side renders. It provides tools for data shaping and transformation, database integration across various cloud and serverless Postgres providers, and security primitives such as token-based authorization and end-to-end encryption. The service can be deployed as a containerized web service on cloud platforms with support for rolling deployment management. - [eclipse-vertx/vert.x](https://awesome-repositories.com/repository/eclipse-vertx-vert-x.md) (14,667 ⭐) — Vert.x is a reactive polyglot framework and asynchronous programming library for the Java Virtual Machine. It functions as an event-driven networking framework and toolkit for building non-blocking applications. The system enables the development of high-concurrency network services and event-driven microservices. It supports the creation of reactive services using multiple languages running on the JVM. The framework covers a wide range of capabilities including the management of HTTP and TCP network protocols, non-blocking file system access, and the integration of reactive clients. - [appwrite/appwrite](https://awesome-repositories.com/repository/appwrite-appwrite.md) (56,318 ⭐) — Appwrite is a backend-as-a-service platform that provides a unified development environment for building full-stack applications. It integrates essential infrastructure components—including authentication, databases, storage, and serverless functions—into a single, centralized interface to simplify application development and resource management. The platform distinguishes itself through a container-based microservices architecture that ensures consistent execution across diverse infrastructure. It features a versatile connectivity layer that links frontend applications with third-party services, databases, and external APIs through standardized interfaces. Developers can manage and automate the configuration of these backend resources using infrastructure-as-code tools, while granular role-based access control enforces security policies across all platform resources and API endpoints. Beyond its core services, the platform offers a broad capability surface that includes cross-platform data synchronization, event-driven webhooks, and comprehensive billing and usage monitoring. It supports extensive integrations for AI utilities, payment processing, messaging, and logging, allowing developers to extend application functionality through modular, event-driven workflows. The platform is designed for both managed and self-hosted deployments, providing tools for production environment optimization, data migration, and custom domain configuration. - [reactphp/reactphp](https://awesome-repositories.com/repository/reactphp-reactphp.md) (9,091 ⭐) — 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 including DNS resolution, and system integration for managing child process execution and I/O piping. It also provides event-driven stream interfaces and asynchronous data caching to maintain responsiveness during heavy I/O operations. - [yaitoo/async](https://awesome-repositories.com/repository/yaitoo-async.md) (16 ⭐) — Async is an asynchronous task package for Go - [wickwirew/runtime](https://awesome-repositories.com/repository/wickwirew-runtime.md) (1,166 ⭐) — A Swift Runtime library for viewing type info, and the dynamic getting and setting of properties. - [etcd-io/etcd](https://awesome-repositories.com/repository/etcd-io-etcd.md) (51,838 ⭐) — etcd is a distributed, strongly consistent key-value store designed to provide reliable storage for critical system metadata and coordination primitives. It functions as a distributed consensus engine, utilizing a replicated log and leader-based state machine to ensure that all nodes in a cluster maintain a synchronized view of data. By providing atomic operations and linearizable reads and writes, it serves as a foundational component for distributed systems requiring high availability and fault tolerance. The system distinguishes itself through its multi-version concurrency control, which enables non-blocking read operations while maintaining strict consistency for concurrent writes. It supports complex distributed coordination through features like lease-based expiration, which allows for the automatic removal of data based on client activity, and asynchronous key change monitoring, which provides real-time event notifications for data modifications. These capabilities are supported by a persistent B-tree-based storage engine and write-ahead logging to ensure durability across system crashes. Beyond its core storage functions, the project provides a comprehensive suite of tools for cluster management, including automated peer discovery via DNS or service registries and robust security enforcement. It includes built-in mechanisms for transport layer security, role-based access control, and certificate management to protect data in transit and at rest. Operational reliability is further maintained through snapshot-based disaster recovery, cluster health monitoring, and granular performance tuning for disk and network resources. The system is configured through structured files or command-line flags, allowing for flexible deployment across diverse infrastructure environments. - [envoyproxy/envoy](https://awesome-repositories.com/repository/envoyproxy-envoy.md) (27,630 ⭐) — Envoy is a high-performance, cloud-native service proxy designed for service-to-service communication in distributed architectures. It functions as a service mesh data plane, providing a centralized mechanism for managing, securing, and observing network traffic between microservices. The project is distinguished by its ability to perform dynamic traffic management and configuration updates in real-time without requiring service restarts or downtime. It utilizes a non-blocking, event-driven architecture to handle high-concurrency connections and supports hot-restart process management, which maintains continuous service availability by transferring active connection sockets during binary or configuration updates. The proxy offers a comprehensive suite of operational capabilities, including advanced traffic routing, load balancing, and upstream health checking to ensure reliable distribution of requests. It also features a pluggable filter chain and extensibility modules that allow for custom request processing logic, alongside integrated tools for traffic tapping, mirroring, and the enforcement of transport layer security. Extensive observability is built into the core, enabling the collection and export of granular metrics, logs, and distributed traces to monitor system health and performance. Administrative utilities are provided to manage proxy lifecycles, monitor operational status, and perform configuration changes through a centralized control plane. - [chainlit/chainlit](https://awesome-repositories.com/repository/chainlit-chainlit.md) (12,213 ⭐) — Chainlit is a Python framework designed for building and deploying interactive, stateful conversational AI interfaces. It provides a backend-driven platform that connects language models and agent frameworks to a web-based chat frontend, managing the complexities of session state, message history, and real-time communication. The framework distinguishes itself by offering a component-based UI builder that allows developers to inject interactive widgets, rich media, and data visualizations directly into the chat stream. It supports the visualization of complex agent workflows, enabling users to inspect intermediate reasoning steps and tool usage in real-time. Additionally, the platform includes built-in support for secure user authentication, persistent conversation history, and the ability to embed chat widgets into existing web applications with bidirectional communication. The system covers a broad range of capabilities, including document processing, vector database integration for context-aware retrieval, and comprehensive observability tools for debugging and monitoring model interactions. It also provides extensive configuration options for interface customization, localization, and access control, ensuring that applications can be tailored to specific organizational requirements. The project is distributed as a Python library and includes a command-line interface to facilitate project setup, configuration, and deployment. - [rathole-org/rathole](https://awesome-repositories.com/repository/rathole-org-rathole.md) (12,845 ⭐) — Rathole is a reverse proxy tunneling tool designed to expose local services behind firewalls and network address translation to the public internet. It functions as a secure tunneling infrastructure that enables remote access to private network resources without requiring manual router port forwarding configurations. The system utilizes a client-server architecture where a public-facing gateway coordinates with a private-network agent. It distinguishes itself by multiplexing multiple logical service connections through a single persistent TCP stream, which reduces the overhead of maintaining individual connections. To ensure security, the platform employs a dedicated control plane that manages service registration and verifies agent identity through token-based authentication before establishing any tunnels. The software handles high-concurrency traffic by utilizing non-blocking input and output operations within an asynchronous event loop. Data transmission is optimized through zero-copy buffer forwarding, which relays packets between network endpoints using shared memory to minimize processing requirements. - [westernmagic/rust-in-hpc](https://awesome-repositories.com/repository/westernmagic-rust-in-hpc.md) (0 ⭐) — Rust is a new open-source systems programming language created by Mozilla and a community of volunteers, designed to help developers create fast, secure applications which take full advantage of the powerful features of modern multi-core processors. It combines performance, reliability and… - [rust-lang/this-week-in-rust](https://awesome-repositories.com/repository/rust-lang-this-week-in-rust.md) (2,569 ⭐) — This project is a community newsletter curation system that collects and organizes links, projects, and news into a structured weekly digest for the Rust ecosystem. It monitors the status of language proposals and core tooling updates to keep developers informed of official changes. The system utilizes a Git-based editorial workflow where community-submitted links and project updates are collected via pull requests for manual filtering. It features a markdown-to-static generation pipeline that transforms these drafts into HTML pages for hosting and chronological historical archiving. The curation surface covers developer event aggregation, open source contribution discovery for beginners, and the distribution of technical job opportunities. It also includes mechanisms for email digest delivery to registered subscribers.