Projects sharing features with Iron

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

Tide is an asynchronous web server framework and HTTP toolkit for the Rust programming language. It provides a system for building high-concurrency network applications and REST APIs using non-blocking I/O and asynchronous runtimes. The framework is centered around a middleware-based request pipeline, allowing developers to intercept and process HTTP requests and responses through pluggable logic layers. It supports a hierarchical route tree to organize endpoints into nested groups that share common path prefixes and scoped middleware. Capability areas include real-time communication via Web

Cowboy is a high-performance HTTP server for Erlang and OTP. It is designed to handle web traffic with low memory usage and can be used as a standalone server or as an embedded networking library integrated directly into an existing application. The project implements modern transport protocols, including HTTP/3, QUIC, and WebTransport, to enable faster connections and bidirectional data streaming. It also functions as a real-time communication server supporting Server-Sent Events for pushing asynchronous updates to clients. Broad capabilities include path and content-type based request rout

Polka is a minimalist Node.js web framework and HTTP routing engine. It provides a small-footprint server implementation designed for low overhead, mapping URL paths and HTTP methods to specific handler functions. The project utilizes a middleware-based architecture, processing requests through a sequence of functions to handle tasks such as logging, authorization, and data modification. It allows for the organization of these functions into global and path-filtered groups to control execution order. The framework covers core web capabilities including route parameter extraction, request URL

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

Crawlee is a web scraping framework designed for building scalable, reliable, and distributed data extraction pipelines. It provides a unified interface for managing headless browser automation and lightweight HTTP requests, allowing developers to handle complex web navigation, dynamic content rendering, and large-scale data collection within a single, modular architecture. The project distinguishes itself through its resource-aware concurrency controller, which dynamically scales task execution based on real-time CPU and memory usage to prevent host machine exhaustion. It also features a rob

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

Nickel is a web framework for the Rust programming language designed to handle HTTP requests and responses. It functions as a server-side toolkit that provides integrated routing, middleware, and JSON deserialization. The framework utilizes a middleware-based request pipeline to insert custom logic and state management into the request-response cycle. It also includes a server-side template engine for generating dynamic HTML pages by merging data with markup templates. The project covers high-level capabilities for REST API development, web application routing, and global error handling to i

node-lessons is a comprehensive Node.js programming course and instructional guide. It provides a collection of guided lessons and code examples designed to teach the fundamentals of the Node.js runtime and server-side JavaScript development. The project serves as a practical guide for building web servers and backend applications, specifically covering the implementation of HTTP servers, request routing, and middleware chains. It includes specialized instructional material on managing asynchronous JavaScript workflows through promises and flow control, as well as guides for integrating NoSQL

This repository is a collection of reference implementations and project scaffolds for the Koa web framework. It provides a set of boilerplates and examples for building Node.js web applications, including predefined project structures with database integrations and containerization. The project demonstrates the implementation of REST APIs and the use of HTTP middleware patterns for composing request handlers. It includes practical guides for designing structured endpoints and resource management patterns. The provided examples cover a range of capabilities including server-side rendering, r

Poem is a comprehensive toolkit for building type-safe web applications, APIs, and servers using the Rust programming language. It provides a foundation for developing web servers that handle HTTP requests with strong type safety. The framework distinguishes itself by supporting multiple communication protocols through a protocol-agnostic handler mapping. This allows a single internal logic to be exposed across HTTP, gRPC services using protobuf definitions, and the Model Context Protocol for AI model integration. Additionally, it includes built-in tooling for generating OpenAPI v3 specificat

This is a streamlined Ruby on Rails framework designed for building lightweight backend services and JSON endpoints. It utilizes a model-view-controller architecture to separate data models and business logic from API responses, specifically omitting browser-centric views to reduce system overhead. The framework provides a system for rapidly generating models, controllers, and routes through JSON API scaffolding. It maps HTTP verbs to controllers to ensure consistent resource routing and data modeling for RESTful API backends. The project includes capabilities for HTTP request management, su

Choo is a functional frontend framework for building web applications. It consists of a suite of tools including a client-side router, a DOM diffing engine, and an isomorphic JavaScript library. The project utilizes an event-driven architecture to decouple business logic from rendering, coordinating state updates and view refreshes through a central event emitter. It employs isomorphic rendering to generate HTML output using a single logic path for both server-side strings and client-side DOM manipulation. The framework manages a shared state object that synchronizes data across handlers and

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

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

Buffalo is a comprehensive MVC web framework and full-stack toolchain for building web applications in Go. It provides a structured development environment that separates models, views, and controllers, integrating a web framework with a dedicated object-relational mapper wrapper for database schema and record management. The project distinguishes itself through a set of development utilities for bootstrapping project structures, managing assets, and building production-ready containers. It features a sophisticated routing system that supports convention-based RESTful resource generation, dom

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

Spark is a lightweight Java web framework and embedded server designed for building web applications with minimal boilerplate. It functions as an HTTP routing engine that maps URL paths and methods to handler functions, providing a specialized domain specific language for web development in Kotlin. The framework enables the implementation of REST APIs and web services through the definition of HTTP routes. It supports the extraction of dynamic path parameters and the transformation of response data into formats such as JSON. Additional capabilities include the ability to serve static files a

Slim is a PHP micro-framework designed for building web applications and APIs by routing incoming network requests to specific callback functions. It provides a lightweight foundation that emphasizes low memory overhead, allowing developers to construct backend systems by integrating only the necessary components. The framework distinguishes itself through a middleware-based request pipeline and full support for standardized HTTP message interfaces. By utilizing these standard interfaces, the system enables modular application logic and ensures interoperability with a wide range of third-part

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-

Martini is a web framework for the Go programming language that provides a toolkit for building web applications. It functions as a routing engine and an HTTP middleware pipeline to map network requests to specific handler functions. The framework is distinguished by its dependency injection system, which automatically resolves and provides requested service types as arguments to handler functions. This allows for the decoupling of business logic from infrastructure by matching requested types against a registry of available services. The project covers a broad range of web capabilities, inc

Jetzig is a full-stack web framework built in the Zig programming language. It provides a structured environment for developing web applications and programmatic APIs by mapping incoming HTTP traffic directly to files on the filesystem. The framework distinguishes itself through a compile-time approach to template rendering, which ensures type safety and performance during the build phase. It manages application state and cross-cutting concerns through a middleware-based interception system and encrypted, session-based cookie storage. The platform includes integrated support for persistent d

RoadRunner is a high-performance application server and process manager designed to serve PHP applications using a persistent worker model. It eliminates bootload overhead and initialization time by keeping application processes alive between requests, acting as a protocol-agnostic proxy that routes traffic to a pool of supervised workers. The server is built with a plugin-based modular architecture, allowing it to be extended with custom Go plugins and compiled into tailored binaries. It distinguishes itself by providing a unified execution model for a wide array of communication protocols,

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

deployd is a realtime API framework and MongoDB backend as a service that allows for the creation of networked interfaces synchronizing data and events between clients and servers. It functions as a JavaScript API middleware that can be integrated with HTTP servers to provide authentication, request interceptors, and realtime capabilities. The project features a self-hosted API management dashboard for configuring resource settings, managing data collections, and monitoring server status through a web-based interface. It includes a realtime data synchronization engine that pushes live databas

Revel is a full-stack web framework and toolkit for building applications with the Go language. It implements a model-view-controller architecture to separate business logic from user interface rendering, providing a comprehensive system for routing, parameter binding, and session management. The project distinguishes itself with a high-productivity development environment featuring automatic code compilation and hot-reloading, which refreshes the application state and templates upon file changes without requiring manual restarts. It also employs reflection-based parameter binding to automati

This project is an educational framework designed to teach the fundamentals of building core distributed systems and web services from scratch in Go. It provides a collection of modular implementations that demonstrate how to construct essential infrastructure components, including web servers, remote procedure call systems, distributed caches, and database abstraction layers. The framework distinguishes itself by focusing on the internal mechanics of these systems rather than providing a high-level abstraction for production use. It covers the implementation of complex architectural patterns