Open-source alternatives to Actix Web

Japronto is an asynchronous web framework and Python HTTP server toolkit. It functions as a multi-worker HTTP server and request router, utilizing non-blocking asynchronous handlers to manage high concurrency and throughput. The project implements a master-multiworker forking model to distribute network traffic across multiple CPU cores. It incorporates a fast event loop and a specialized C-extension for high-speed HTTP request parsing, while supporting request pipelining over single TCP connections. The framework covers a broad range of request handling capabilities, including URL pattern r

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

Ktor is a framework for building asynchronous server applications and cross-platform network clients using the Kotlin programming language. It provides a lightweight, modular architecture that allows developers to construct services and communication layers by composing independent components and plugins. The framework is defined by its pipeline-based plugin system, which enables the injection of custom logic into request processing stages, and a type-safe domain-specific language for defining application routing. By utilizing an asynchronous execution model, it handles concurrent network ope

Starlette is a lightweight ASGI web framework and asynchronous HTTP toolkit used to build high-performance HTTP and WebSocket services. It functions as a WebSocket server framework and a collection of ASGI middleware components for managing network requests through non-blocking asynchronous logic. The framework provides tools for real-time communication via persistent bidirectional channels and infrastructure for high-performance APIs. It includes specialized capabilities for response compression, incremental data streaming, and the execution of non-blocking background tasks after a response

Hug is a Python API framework used for building web services by mapping functions to HTTP endpoints via decorators and type annotations. It functions as a type-based validator that automatically converts and validates incoming request data based on Python type hints and serves as a WSGI-compliant web framework for deployment on production servers. The project is distinguished by its ability to automatically generate API specifications and user-facing documentation derived from function signatures. It further extends the utility of internal logic by exposing functions as terminal commands thro

Oatpp is a high-performance C++ web framework and API development kit used for building REST APIs and web services. It functions as an asynchronous HTTP server that utilizes coroutines to handle thousands of simultaneous connections without blocking threads. The toolkit includes a native C++ object-relational mapping layer for executing SQL queries and transforming database results into data objects. It also provides a WebSocket communication library for establishing full-duplex channels to support real-time data streaming and live media. The framework covers a broad range of capabilities, i

Warp is a Rust HTTP web framework designed for building high-performance web servers. It provides a system for managing request pipelines, implementing WebSocket servers for bidirectional communication, and serving static assets from the local filesystem. The framework is characterized by its use of type-safe request pipelines and routing. It utilizes a filter-based approach to extract and validate metadata from headers, query strings, and request bodies before they reach the application handler. Broad capability areas include HTTP API development, asynchronous task execution, and state-base

Drogon is a high-performance, cross-platform C++ framework designed for building asynchronous web services and server-side applications. It functions as a multi-threaded, event-driven server engine that manages concurrent network traffic and WebSocket connections with minimal latency. By leveraging non-blocking input/output and native code compilation, the framework provides a foundation for scalable applications that operate efficiently across diverse hardware architectures. The framework distinguishes itself through its compile-time template rendering, which transforms dynamic HTML views in

koa2-note is a project focused on Koa2 web server development and Node.js asynchronous programming. It provides a framework for building web servers and APIs using an asynchronous middleware pipeline to handle request and response cycles. The project emphasizes a layered backend architecture that decouples routing, business services, and data models. It distinguishes itself through the integration of relational databases for persisting user sessions and application data, alongside a build process that includes JSX-to-JavaScript compilation for frontend assets. The capability surface covers b

This project serves as a comprehensive educational repository and technical reference collection, documenting a wide range of software engineering practices and modern development technologies. It provides a structured learning path for developers, curating tutorials and practical examples that cover the full lifecycle of application development, from initial project scaffolding to deployment and maintenance. The repository distinguishes itself by offering deep technical insights into complex architectural patterns, including actor-based concurrency models for managing parallel tasks and cont

This project is a reference implementation of a production-ready backend API built with Rust and the Actix-Web framework. It serves as a codebase demonstrating the development of a newsletter subscription service, encompassing the management of subscriber sign-ups, email confirmations, and campaign delivery. The project highlights a layered architecture that separates concerns into handler, service, and repository layers. It utilizes an actor-based concurrency model for handling HTTP requests and employs trait-based abstractions to decouple business logic from external dependencies, such as e

Hapi is a configuration-driven web framework for building secure and scalable HTTP servers and APIs on the Node.js runtime. It functions as a REST API development framework and an enterprise server implementation focused on stability, security, and comprehensive input validation. The framework is built around a plugin-based architecture, allowing core functionality and custom logic to be organized into modular, registerable plugins. It serves as an HTTP request lifecycle manager, enabling the interception and modification of requests through pre-handlers and extensions before they reach the f

This project is a comprehensive educational resource and learning roadmap for mastering the Node.js runtime. It provides a structured curriculum that guides developers from basic syntax through advanced asynchronous patterns and professional architectural practices. The resource covers the internal architecture of the engine, specifically explaining how the event loop and thread pool handle non-blocking I/O and concurrency. It includes tutorials on the evolution of asynchronous flow control, moving from callbacks and promises to modern syntax patterns. The guide also addresses various applic

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

Salvo is a comprehensive Rust web framework for building asynchronous HTTP servers and web applications. It features a hierarchical web router that uses a tree-based structure to map requests to handlers and an asynchronous middleware pipeline based on the onion model for request and response pre- and post-processing. The framework is distinguished by its native support for modern network protocols, including a QUIC-based HTTP/3 implementation alongside HTTP/1 and HTTP/2. It includes an integrated OpenAPI documentation generator that extracts schemas directly from handler signatures to produc

This project is a comprehensive sample library and implementation guide for ASP.NET Core. It provides a collection of practical examples and projects that demonstrate how to build web applications, RESTful APIs, and high-performance services. The repository focuses on a variety of architectural patterns, including the development of Minimal APIs, contract-first gRPC services, and real-time communication using WebSockets and Server-Sent Events. It includes detailed implementations for user identity and security, such as token-based authentication and CSRF protection. The codebase covers a bro

TanStack Table is a headless, framework-agnostic engine designed for building complex data grids and managing tabular state. By decoupling data processing logic from the visual rendering layer, it allows developers to implement custom user interfaces while offloading sophisticated operations like sorting, filtering, grouping, and pagination to a unified, performant core. The library distinguishes itself through its commitment to type safety and environment flexibility. It leverages strict type definitions to ensure data integrity across the entire application and utilizes an adapter pattern t

Grape is a RESTful web service framework for Ruby designed for building structured APIs. It provides a declarative syntax for routing and parameter validation, allowing developers to map HTTP verbs to logic through a domain specific language. The framework is distinguished by its built-in support for service versioning, which can be managed via URL paths, custom headers, or request parameters. It also features a modular architecture that allows large services to be constructed by nesting smaller API definitions. The project covers comprehensive API lifecycle capabilities, including schema-dr

brpc is a high-performance C++ RPC framework and network programming library designed for building distributed systems. It functions as a multi-protocol RPC server capable of hosting and detecting multiple communication protocols, including gRPC, Thrift, HTTP, Redis, and Memcached, on a single TCP port. The project distinguishes itself through high-throughput data transport and memory efficiency, utilizing RDMA-based transport to bypass the kernel TCP stack and zero-copy memory management to eliminate data duplication. It also implements the Raft algorithm for consensus-based state replicatio

Grav is a flat-file content management system that eliminates the need for a traditional database by storing site content and configuration in human-readable Markdown and YAML files. Built as a modular PHP web framework, it uses a hierarchical page routing system where the physical directory structure directly determines the site's URL paths. The platform is distinguished by its event-driven plugin architecture and a command-line interface that prioritizes system administration, deployment, and maintenance tasks. It utilizes a blueprint-driven system to generate administrative forms from stru

Python is a high-level, interpreted programming language designed for readability and versatility. It operates via a bytecode-based virtual machine and manages memory automatically through reference-counting garbage collection. The language supports multiple programming paradigms, including object-oriented, imperative, and functional styles, and provides a comprehensive standard library for system operations, networking, and data handling. The language is distinguished by its dynamic nature, allowing for runtime object introspection and metaclass-driven class creation. It utilizes protocol-ba

Vibora is an asynchronous Python web framework and built-in HTTP server designed for building high-performance web applications. It utilizes an asynchronous event loop and coroutines to process network requests and serve responses without requiring external server wrappers. The project features a high-performance asynchronous schema validator for request integrity, a non-blocking template engine with support for hot-reloading, and a WebSocket communication server for bidirectional real-time data exchange. The framework covers a broad range of capabilities, including modular route management

Perfect is a server-side Swift framework designed for building high-performance web applications, REST APIs, and backend services. It provides an asynchronous HTTP server that handles web traffic through an event loop, alongside a web template engine for generating dynamic HTML pages. The project includes a WebSocket communication library for implementing bidirectional, real-time data exchange between clients and servers. It also provides a database connector to establish connections and exchange data between Swift applications and external database stores. The framework's capabilities cover

Quart is an asynchronous Python web framework that implements the ASGI specification. It is used to build high-performance HTTP and WebSocket services, JSON REST APIs, and web applications using async and await syntax for non-blocking request handling. The framework supports persistent bidirectional communication via WebSocket API servers and enables the proactive delivery of assets through HTTP server push. It also includes a template engine for rendering dynamic HTML web pages and supports incremental request and response streaming to manage large payloads. General capabilities cover reque

Gunicorn is a production-grade WSGI HTTP server designed for deploying Python web applications. It functions as a process manager that utilizes a pre-fork worker model, where a master process initializes the application and spawns multiple child processes to handle incoming requests in parallel. This architecture ensures high performance and stability by isolating application execution within persistent worker processes. The server distinguishes itself through its flexible concurrency models and robust process lifecycle management. It supports interchangeable worker types, including synchrono

Kitura is a server-side web framework for building HTTP services and web applications using the Swift programming language. It functions as an HTTP server that handles incoming requests, routes traffic, and serves responses. The framework serves as a Codable REST API framework, enabling the encoding and decoding of native Swift data types for web service communication. It also provides a FastCGI web interface to connect Swift applications to external web servers for improved scalability. The system includes capabilities for secure web communication through SSL/TLS network encryption, server-

Akka is an actor model framework and distributed systems platform used to build concurrent and distributed applications. It provides a toolkit for managing multi-threaded state and behavior through asynchronous message passing, allowing developers to create concurrent applications without manual locks or synchronization. The system functions as a cluster management and event sourcing framework, automating the scaling and coordination of high-availability clusters. It enables the deployment of elastic services that coordinate workloads across multiple network nodes and ensures fault tolerance