Open-source alternatives to Compojure

Iris is a high-performance web framework and API toolkit for the Go programming language. It provides the infrastructure necessary to build HTTP/2 web applications, REST APIs, and MVC-based websites. The project distinguishes itself through a flexible architectural model that supports multiple isolated application instances within a single process and allows for binary-embedded asset loading to eliminate external filesystem dependencies. It features dynamic router hot-reloading and a pluggable view engine for rendering dynamic HTML content. The framework covers a broad range of capabilities,

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

web.py is a minimal Python web framework that provides the core components needed to build web applications: URL routing, template rendering, database access, form handling, and session management. The framework uses a convention-based approach where URL patterns are automatically mapped to handler classes based on their names, eliminating the need for manual route configuration. It exposes applications as WSGI callables, making them deployable with any WSGI-compliant server. The framework distinguishes itself through its metaclass-driven auto-discovery system, which automatically registers h

Connexion is a specification-driven framework for building APIs that automatically maps OpenAPI specifications to application logic. It uses these specifications to automate routing, request validation, and response serialization, linking API operations to backend handler functions via operation IDs. The project differentiates itself by providing a schema-driven mock server that simulates API behavior using example responses from the specification without requiring backend logic. It also includes a dynamic documentation hosting system that translates the API specification into a live interact

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

Pyramid is a Python web framework and WSGI toolkit designed for building web applications. It functions as a URL routing engine that maps incoming HTTP requests to specific view callables using both pattern-based routing and hierarchical resource tree traversal. The framework is distinguished by its hybrid dispatch system, allowing developers to combine regular expression URL matching with the ability to resolve requests by navigating a tree of nested objects. It implements a flexible component architecture that supports application registry management, deferred configuration execution, and t

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

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 showcase application and reference implementation for the Spring MVC framework. It serves as a demonstration of how to build web applications by separating business logic from user interfaces using a model-view-controller architectural pattern. The application provides examples of HTTP request handling, including the capture of request data, the processing of file uploads, and the generation of formatted HTTP responses. It implements REST API endpoints that map requests to handler methods and return data in formats such as JSON and XML. The project covers core web developme

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

httprouter is a high-performance HTTP request router for Go that maps incoming network requests to specific handler functions using a radix tree. It functions as a request dispatcher and path parameter parser, organizing URL paths in a tree structure to ensure efficient lookups. The router specializes in capturing dynamic segments and catch-all wildcards from URL paths to pass directly into request handlers. It implements method-specific routing and automatically manages responses for unsupported HTTP methods. The library covers broader capabilities including request normalization through tr

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

This project is an NGINX module that embeds the Lua scripting language directly into the server environment. It functions as a request processor and response filter, enabling the execution of scripts to handle HTTP requests, generate dynamic content, and manage server behavior without external application calls. The module provides a shared memory dictionary and cache manager, allowing data to be stored and retrieved across all active worker processes. This capability supports the collection of high-performance server metrics and the synchronization of information across concurrent processes.

Koa is a lightweight web framework for Node.js designed for building HTTP applications and servers. It functions as an asynchronous middleware engine that processes network requests through a sequence of functions sharing a common context. The framework distinguishes itself by using an onion-model middleware stack and promise-based flow control. This architecture allows requests to flow downstream and responses to flow back upstream through the same chain, enabling non-blocking request cycles and a modular approach to handling network traffic. The system provides high-level capabilities for

ThinkJS is a server-side web framework designed for building applications on the Node.js runtime. It serves as a development platform that supports TypeScript and the latest ECMAScript standards to create stable and maintainable backend services. The framework employs a layered application architecture that separates concerns into controller, service, and model tiers. It utilizes a dependency-injected service model to manage singleton services and a middleware-based system for request handling and route dispatching. Development is supported by a build pipeline that transpiles modern JavaScri

Bottle is a lightweight Python web micro-framework and template engine. It functions as a WSGI web framework that routes HTTP requests to Python functions to generate dynamic content. The framework is distributed as a single Python file with no external dependencies. This minimalist distribution model allows for rapid application prototyping and the creation of web services with a small footprint. The project provides capabilities for dynamic request routing, REST API development, and dynamic HTML rendering. It includes a built-in HTTP development server for web application hosting and a plu

Crow is a minimalist C++ micro web framework designed for building fast web servers and REST APIs. It provides a lightweight toolkit for web development in C++, offering core routing and request handling capabilities. The framework includes a built-in JSON parser for converting strings into structured data and an HTML template engine for generating dynamic web pages on the server. It also functions as a WebSocket server library to enable bidirectional, real-time communication between servers and web clients. Additional capabilities include a middleware-based request pipeline for executing sh

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

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

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

Fiber is a high-performance web framework designed for building scalable HTTP services with minimal memory overhead. It provides a comprehensive runtime environment for managing the full request lifecycle, utilizing an optimized radix tree for high-speed route matching and an object pooling system to reduce garbage collection pressure during traffic processing. The framework distinguishes itself through its multi-process architecture, which supports prefork socket reuse to distribute incoming traffic across all available CPU cores. It offers a modular approach to application development, feat

This is a full-stack web development framework for Node.js based on the model-view-controller architecture. It provides a comprehensive platform for building applications with an integrated dynamic view engine for HTML markup, a WebSocket communication server for bidirectional real-time messaging, and an embedded NoSQL database for persisting flexible data structures without external dependencies. The framework includes a background task processor that offloads computationally intensive operations to separate worker threads to maintain application responsiveness. It also features an internati

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

go-restful is a framework for building RESTful web services in Go. It functions as a toolkit for managing API endpoints, providing a request router that maps incoming HTTP requests to handler functions using path parameters and custom URL patterns. The framework includes a data conversion layer that transforms Go structures into JSON or XML formats for request and response bodies. It also provides a system for organizing related web services into containers to manage endpoint prefixing and shared configuration. The project covers request lifecycle management through middleware filters for va

Hono is a minimal JavaScript HTTP framework designed for building web servers across multiple runtimes, including Node.js, edge runtimes, and serverless platforms. It functions as a cross-runtime web server and a web standard API wrapper, normalizing various runtime request and response objects into standard Web API signatures. The project serves as an HTTP middleware orchestrator and request handler, utilizing a middleware-based request pipeline and hierarchical route mounting to create modular server structures. It distinguishes itself through a runtime-agnostic event wrapper that ensures c

Plug is a specification and set of primitives for building composable middleware pipelines in Elixir web applications. It provides a system for managing HTTP request pipelines and a routing engine that dispatches incoming requests to specific handlers based on methods and URL patterns. The project enables the creation of interchangeable web middleware for tasks such as authentication, logging, and session management. It also includes mechanisms for upgrading standard HTTP requests to full-duplex WebSocket connections. The capability surface covers request body parsing, static asset delivery,

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