Open-source alternatives to Routing

This repository is a collection of implementation patterns, tutorial code, and practical examples for building web applications with the Gin framework in Go. It serves as a guide for learning how to structure Go web servers, specifically focusing on mapping URL paths to handler functions and managing request flow. The project provides demonstrations of middleware implementation for tasks such as authentication, logging, and rate limiting. It also includes reference examples for developing REST APIs, with a focus on structuring data and sending JSON responses to clients.

koa-router is a routing middleware for Koa applications that maps incoming HTTP requests to specific handler functions based on URL patterns and HTTP methods. It provides the foundation for organizing web endpoints and developing REST APIs by linking request paths to their corresponding controller actions. The project enables the organization of complex endpoints through recursive router nesting, allowing multiple router instances to be mounted as middleware to create logical route hierarchies. It supports dynamic URL generation via named route mapping, which allows the creation of URL string

Racket is a general-purpose, multi-paradigm programming language in the Lisp family designed for language creation. It functions as a language workbench, providing a platform for designing and implementing custom programming languages through a flexible system of macros and modules. The system distinguishes itself by offering a comprehensive suite for semantics engineering, allowing for the construction of specialized language subsets and educational layers. It includes tools for custom language design, such as lexer and parser generation, as well as the ability to define module expansion rul

FastRoute is a PHP request router that maps incoming HTTP request URIs to specific handlers. It functions as a regular expression router, matching dynamic request paths against patterns to extract variables and route traffic. The project operates as a cached route dispatcher, storing pre-computed routing tables to eliminate the overhead of parsing definitions on every request. It utilizes regular expression grouping to combine multiple route patterns into a single operation, reducing the total number of matching steps required for resolution. The library covers dynamic API endpoint managemen

Compojure is a routing library for Ring web applications that maps HTTP requests to handler functions using composable route definitions. It serves as a middleware component for the Ring ecosystem, directing web traffic to specific application logic by matching incoming request methods and paths against defined URI patterns. The router utilizes a modular architecture that allows related endpoints to be grouped into decoupled modules. This composition model enables the construction of larger applications from smaller, independent routing contexts. The library provides capabilities for process

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

Chi is a lightweight, idiomatic router and middleware framework for building web services in Go. It is designed to integrate directly with the standard library, providing a set of utilities for managing HTTP request routing, context propagation, and modular service composition. The project distinguishes itself through a radix-tree-based routing system that supports recursive nesting, allowing developers to mount independent sub-routers onto specific path prefixes. This hierarchical structure enables the creation of organized, modular applications where request handlers are grouped and managed

This project is a request router and web framework for the Go programming language. It provides a toolkit for matching incoming HTTP network requests to specific handler functions by evaluating criteria such as URL paths, request methods, headers, and hostnames. The framework distinguishes itself through its flexible matching capabilities, which include support for regular expressions and dynamic variable extraction from URL segments. It allows developers to organize routes into logical hierarchies, share common path prefixes, and maintain a central registry of named routes to facilitate prog

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 project is a headless music streaming service proxy that provides a server-side interface for interacting with a specific music platform. It functions as a middleware layer, translating standard web requests into the proprietary communication protocols required by the remote service. By acting as a network traffic interceptor, the system enables programmatic access to music metadata, user playlists, and playback controls. The architecture operates as a middleman that intercepts client requests and relays them to the target service while managing necessary headers and parameters. It utili

Nancy is a lightweight .NET HTTP web framework used for building web services and APIs on .NET and Mono. Its core identity consists of a routing system for matching URL paths to handlers, a content negotiation engine for selecting response data formats, and a dependency injection container for resolving module requirements. The framework provides a cross-platform web host abstraction that allows applications to run within various web servers or as standalone self-hosted processes. It further decouples components by mapping requested service types to specific implementations at runtime. The s

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

Sylar is a high-performance C++ asynchronous server framework and event-driven network library. It functions as a coroutine scheduler and HTTP server implementation designed to build network services using non-blocking I/O. The project distinguishes itself through a system call interceptor that hooks blocking socket and sleep APIs, transforming synchronous operations into non-blocking asynchronous events. It employs a user-space threading system to distribute lightweight tasks across a worker thread pool to maximize CPU utilization. The framework covers a broad range of networking and system

This project is a lightweight PHP framework designed for building web applications using the model-view-controller architectural pattern. It provides a structured environment that separates business logic, data management, and user interface presentation into distinct layers to improve code maintainability. The framework utilizes a front-controller to intercept all incoming web traffic, routing requests to specific controller actions based on defined URL patterns. It incorporates middleware-style request interception, allowing for the execution of custom logic such as authentication, security

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,

This project serves as the core integration layer for building full-stack web applications in PHP. It provides a unified foundation by connecting essential infrastructure components, including a dependency injection container, an event dispatcher, and a request routing engine. The framework operates through a kernel-based request lifecycle that transforms incoming HTTP requests into responses via prioritized middleware stages. The system distinguishes itself through a highly modular architecture that relies on configuration-driven service wiring and metadata-driven attribute mapping. During t

sw-precache is a service worker build tool and precaching generator that produces JavaScript code to version and store static assets. It functions as a command-line interface and node module designed to enable offline functionality and improve load times for web applications. The project distinguishes itself by combining build-time asset discovery with a runtime caching orchestrator. It uses content-hash-based versioning to trigger updates only when file contents change and employs template-based code generation to inject custom routing rules and handler libraries into the resulting service w

The Event Gateway is a unified routing layer designed to connect HTTP requests and cloud events to serverless functions across multiple providers and infrastructure environments. It functions as a centralized platform for managing event-driven architectures, enabling developers to register, map, and trigger remote functions in response to incoming web traffic or asynchronous system events. The platform distinguishes itself through a plugin-based middleware pipeline that allows for custom logic execution during the request lifecycle, enabling developers to intercept, validate, or transform eve

This project is a Node.js HTTP reverse proxy middleware designed to route incoming HTTP and WebSocket traffic to target backend services. It functions as a dynamic routing engine and API gateway tool, providing the capability to consolidate multiple backend services behind a single entry point. The middleware features a WebSocket proxy bridge that manages protocol upgrade handshakes to maintain persistent bidirectional communication. It also includes a request and response transformer used to intercept and modify headers, bodies, and URL paths during transit. The system provides broad traffi

ServiceStack is a high-performance .NET web framework designed for building type-safe APIs using strongly-typed request and response objects. It functions as a message-based API engine that decouples business logic from the transport layer, allowing services to be exposed via multiple protocols including HTTP, gRPC, and various message queue providers. The framework is distinguished by its type-safe API generator, which produces native client SDKs and data transfer objects from service metadata across multiple languages. It also includes a distributed service gateway for microservices orchest

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

This project provides a routing library for the Koa web framework, designed to map incoming HTTP requests to specific handler functions. It serves as a core infrastructure for organizing application logic into modular endpoints, utilizing declarative route registration and middleware-based request pipelines to process traffic. The library distinguishes itself through its support for hierarchical router nesting, which allows for the creation of scalable, modular application architectures and distinct API versioning. It offers granular control over request matching, including support for regula

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

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

tts-server-android is a system-level text-to-speech service for Android that routes synthesis requests to external cloud APIs or local engines. It functions as an HTTP speech synthesis gateway, converting system speech requests into customizable HTTP requests for remote cloud services. The project includes a narrative dialogue parser that uses quotation marks to differentiate between narration and dialogue, allowing for different reading styles. It also features a voice manager and synthesis interface to implement text replacement rules and automatic retries to improve voice output accuracy.

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 emp

Director is a routing library for JavaScript that handles URL and command-line pattern matching across client-side, server-side, and CLI environments. It provides a unified approach to defining routes as nested object literals, where each key maps to a URL segment and its handler, supporting both hash fragment monitoring and the HTML5 History API for browser navigation without page reloads. The library distinguishes itself through its ability to operate in multiple contexts with a single routing paradigm. It supports asynchronous handler queue execution for sequential tasks like authenticatio