Projects sharing features with Puma

NanoHTTPD is a lightweight, embeddable HTTP server for Java applications. It allows developers to integrate web server capabilities directly into a Java project to handle incoming requests without requiring a standalone installation. The project provides specialized implementations for an HTTPS web server, a WebSocket server for bidirectional real-time communication, and a static file web server. These capabilities enable secure network traffic through SSL certificates and the delivery of local files with automatic MIME type detection. The server includes systems for request routing and hand

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

FastMCP is a Python framework designed for building servers that expose functions, resources, and prompts to AI models using the Model Context Protocol. It simplifies the development process by automatically deriving tool metadata, input schemas, and documentation directly from Python function signatures and type hints. The framework provides a unified container for managing these components, allowing developers to build modular applications that integrate seamlessly with AI assistants. The project distinguishes itself through its support for interactive, server-defined user interface compone

Passenger is a multitenant web server and dynamic process manager designed to host and manage web applications written in Ruby, Python, and Node.js. It functions as an application server that handles process and resource management, ensuring that multiple independent applications can run on a single server instance. The project distinguishes itself through a flexible deployment model, capable of operating as a self-contained standalone web server or as an integration module for existing high-performance external web servers. It employs a language-agnostic interface to provide polyglot hosting

This is a header-only C++ library that provides implementations for HTTP clients, HTTP servers, and a WebSocket framework. It allows for the creation of network services and the consumption of remote APIs without requiring a separate compilation step or external binary linking. The project features backend-agnostic TLS integration for secure HTTPS and WSS communication and employs a thread-pool model to process concurrent requests. It distinguishes itself with a full-duplex WebSocket state-machine and a middleware-based request pipeline that supports regular-expression path routing. The libr

uWebSockets is a high-performance networking engine providing an HTTP web server and a WebSocket server framework. It implements a multi-threaded event loop architecture to deploy isolated application instances across multiple CPU cores and includes an SSL/TLS network layer for secure, encrypted communication. The project features a dedicated WebSocket pub/sub engine for distributing messages to specific groups of connected clients. It optimizes network throughput through syscall corking to reduce kernel overhead and employs payload compression to minimize data transfer sizes. The system cov

Tableflip is a zero-downtime restart library and system utility designed to transfer network sockets and open file descriptors between process instances. It serves as a process lifecycle manager that coordinates the handoff of TCP, UDP, and Unix domain sockets from a parent process to a child process to maintain active sessions during service upgrades. The tool facilitates seamless restarts by utilizing file-based process ID tracking and system signals to trigger the spawning of new process instances. It ensures continuous service availability by handing over network listeners and using readi

Grace is a lifecycle controller and process manager for Go applications designed to coordinate server transitions and implement system-level socket activation. It functions as a tool for managing secure HTTP servers and their transport layer security configurations across multiple ports. The project enables zero-downtime deployments by handing over network sockets to successor processes, allowing existing requests to complete before an old process shuts down. It also provides socket activation management, which allows servers to start lazily only upon receiving connections through an external

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

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

TCP-IP-NetworkNote is a comprehensive technical reference and guide for implementing network communication using TCP and UDP sockets in C and C++. It provides a detailed manual for using the POSIX socket API and covers the implementation of network protocols, synchronous and asynchronous I/O patterns, and concurrent programming models. The project is distinguished by its focus on cross-platform networking, offering a detailed comparison of socket implementation details and adaptation utilities between Linux and Windows Winsock environments. It specifically addresses the differences in header

Atlas is a MySQL database proxy and middleware system designed to manage traffic between clients and database clusters. It functions as a high-availability database gateway and sharding middleware, providing a fault-tolerant entry point for routing, load balancing, and managing database connections. The project differentiates itself through a combination of read-write splitting, which directs queries to primary or replica servers, and data sharding to distribute information across multiple backend instances. It utilizes a connection pooler to reduce the overhead of establishing new sessions a

Connect is an HTTP middleware framework and routing library designed as a wrapper for the Node.js HTTP server. It serves as a middleware composition engine that allows for the creation of chains of request handlers to process HTTP traffic and manage application errors. The framework enables the orchestration of pluggable functions to execute security, logic, and routing rules in a specific sequence. It provides the ability to match incoming request URLs to specific logic handlers based on path prefixes. The system covers broader capabilities including centralized error handling to ensure con

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

Granian is a Rust-based HTTP server written specifically to serve Python web applications. It supports the three major Python gateway interfaces—ASGI for asynchronous apps, WSGI for synchronous apps, and RSGI for async requests—while also handling HTTP/1.1, HTTP/2, and WebSocket connections through automatic protocol negotiation. Architecturally, Granian uses a multiprocess worker model that isolates requests across CPU cores and provides configurable threadpool-limited concurrency to control backpressure per worker. It includes built-in Prometheus metrics exposition for connection counts and

The Rust Programming Language Book is the official technical guide and educational resource for the Rust language. It provides a comprehensive walkthrough of the language's design, focusing on its core identity as a systems programming language that enforces memory safety and high-performance execution without the need for a garbage collector. The project is distinguished by its focus on ownership, borrowing, and lifetime tracking, which allow the compiler to verify memory safety and thread safety at compile time. It covers the language's unique approach to zero-cost abstractions, including t

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

Snowflake is a high-concurrency RPC framework and distributed ID generation service. It provides the infrastructure to create unique, time-ordered identifiers across a network of servers and facilitates the development of network services designed to handle massive volumes of simultaneous requests. The system separates low-level transport logic from application behavior, allowing for the implementation of custom RPC protocols. It includes a distributed request tracing tool to visualize execution flow across network boundaries and a server lifecycle management interface to adjust logging level

Developer Roadmap is a community-driven platform that provides structured, graph-based learning paths for software engineering. It serves as a comprehensive knowledge repository where technical domains are organized into visual sequences to guide professional skill acquisition and career growth. The project distinguishes itself through a collaborative ecosystem that enables users to contribute roadmaps, curate industry best practices, and maintain professional profiles. It integrates diagnostic assessment frameworks to evaluate technical proficiency, helping developers identify knowledge gaps

KeyDB is a multithreaded in-memory key-value store and distributed cache. It functions as a NoSQL database utilizing multi-version concurrency control to execute non-blocking queries and scans. The project is a multithreaded fork of Redis that maintains protocol compatibility while utilizing a multithreaded architecture to scale across multi-core hardware. It distinguishes itself with flash-tiered storage, allowing the system to offload data from primary RAM to SSD or flash storage to increase total capacity. The system supports high availability through active-active mesh replication and mu

Gizmo is a microservice development toolkit and HTTP server framework designed for building distributed services. It provides a collection of libraries for managing service lifecycles, including standardized configuration, logging, and health checks. The toolkit includes a PubSub messaging interface that abstracts the publishing and consuming of messages across different brokers and HTTP endpoints, featuring built-in mocking for integration testing. It also provides a security layer for validating inbound authentication tokens using public key signatures and custom decoders. The project cove

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

Oak is a cross-runtime HTTP middleware framework and web server designed to operate across Deno, Node.js, Bun, and Cloudflare Workers. It provides a unified system for building APIs and web servers using a sequential chain of middleware functions and a hierarchical routing engine that maps URL paths to handlers via a nested tree structure. The framework includes a runtime-agnostic serverless adapter that translates diverse cloud provider events into a standard request and response interface. It also features a dedicated WebSocket server implementation for bidirectional real-time communication

This project is an HTTP web server that delivers web content to clients using HTTP/1.1 and HTTP/2 protocols across various operating systems. It functions as a reverse proxy server, a rule-based URL rewriter, an SSL/TLS termination gateway, and a virtual host manager. The server is capable of hosting multiple distinct domains on a single instance by mapping requests to specific directory structures. It encrypts and decrypts network traffic at the server boundary to secure communication between clients and servers. Additionally, it transforms requested URLs into different paths using a regular

NGINX Unit is an open-source application server designed to natively execute code across multiple programming language runtimes and WebAssembly within a single process. It serves as a multi-language application server that can run applications written in Go, Java, Node.js, Perl, PHP, Python, Ruby, and WebAssembly side by side, without requiring separate runtime environments for each language. The server distinguishes itself through a RESTful JSON control API that enables dynamic, zero-downtime configuration changes without restarting the server. It combines event-driven asynchronous I/O with

GCDWebServer is a lightweight HTTP 1.1 server for iOS, macOS, and tvOS. It serves as an embedded network server for Apple platforms, allowing developers to handle incoming requests through custom synchronous or asynchronous handlers. The project includes a WebDAV server implementation for remote file management, directory browsing, and synchronization using standard network clients. It also provides a web-based file manager that enables users to upload, download, and organize files within an application sandbox via a browser. Additional capabilities include gzip compression, JSON processing,

This project is a command-line development web server designed to serve static files and proxy network requests. It functions as a modular, middleware-based server that allows developers to chain custom functions to handle request parsing, response compression, and URL rewriting. The server distinguishes itself through its ability to simulate complex network environments and production-like security configurations. It supports secure encrypted connections via HTTPS and restricts access to hosted resources using basic authentication protocols. Additionally, it provides specialized routing for