Rust web framework for REST APIs

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

Tower is a modular service abstraction layer for the Rust programming language, providing a framework for building asynchronous request-response pipelines. It serves as a set of core components for managing backpressure, balancing loads, and abstracting service discovery. The project distinguishes itself through a layer-based middleware composition model, allowing services to be wrapped in recursive chains of decorators. This enables the declarative application of cross-cutting concerns, such as timeouts, rate limiting, and retries, in a protocol-agnostic manner. The library covers a broad r

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

This toolkit provides an asynchronous interface for interacting with relational databases, offering a unified driver-agnostic layer for managing connection pools and executing transactions. It is designed to integrate with asynchronous runtimes, enabling non-blocking database operations while maintaining secure, encrypted communication between the application and the database server. The project distinguishes itself through its compile-time validation capabilities, which use procedural macros to inspect SQL syntax and parameter types against a live database schema during the build process. Th

Iron is a Rust web framework used for building concurrent web applications and APIs. It functions as a concurrent HTTP server and provides a stateless route dispatcher to map incoming URL paths and globs to specific handler functions. The project is centered around a middleware-based request pipeline, which allows the request-response cycle to be extended via plugins and modifiers. It utilizes a thread-safe state container to store shared application memory accessible across all concurrent handlers and middleware. The framework covers broad capability areas including dynamic API routing, sta

Actix Web is an asynchronous web framework designed for building high-performance network services. It provides a foundation for processing concurrent requests through a non-blocking execution model, utilizing an actor-based concurrency system to manage lightweight processes and message passing. The framework includes a low-level networking layer that handles the parsing and serialization of HTTP traffic according to standard specifications. The framework distinguishes itself through a type-safe routing engine that enforces strict data types at compile time, ensuring that request parameters a

Rocket is a type-safe web framework designed for building server-side applications. It provides a high-performance asynchronous routing engine that maps incoming network traffic to concurrent handler functions, while managing the full lifecycle of web requests. The framework emphasizes compile-time verification, ensuring that request parameters, response types, and routing logic remain consistent throughout the development process. The framework distinguishes itself through its use of request guards, which act as a validation layer to intercept and transform incoming data into structured type

utoipa is a Rust API documentation tool used to generate machine-readable OpenAPI specifications. It functions as a specification generator and schema mapper that converts Rust structs and enums into compliant OpenAPI schemas. The project distinguishes itself by using procedural macros and traits to automate metadata extraction from code. It supports complex data modeling, including generics, polymorphism, and recursive type resolution, while synchronizing field renaming and tagging from serialization attributes. It also enables the composition of modular specifications, allowing multiple sma

Axum is a web framework for the Rust programming language designed for building scalable and high-performance backend services. It provides a modular, asynchronous programming model that centers on a declarative routing engine, allowing developers to map HTTP requests to handler functions using a type-safe API. The framework distinguishes itself through a robust request extraction system that leverages trait-based reflection to automatically parse and validate incoming data into strongly typed function arguments. By utilizing a standardized service abstraction, it enables the composition of m

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

Django REST Framework is a toolkit for building standards-compliant web services that map complex data models to structured HTTP responses. It provides a modular architecture for handling the request lifecycle, including authentication, permission checks, and content negotiation. The framework is designed to facilitate the development of robust APIs by transforming complex data types into native formats and validating incoming request payloads against defined schemas. The project distinguishes itself through a highly modular, class-based design that allows developers to build complex views an