Tower

Tower is a library of protocol-agnostic middleware built around a single trait — Service, an async function from Request to Result<Response, Error> — that lets you compose cross-cutting concerns like timeouts, retries, load balancing, rate limiting, and buffering as small, independently testable Layers stacked around any client or server.

Because the abstraction is just a function from request to response, the same middleware stack works whether you’re building an HTTP client, a gRPC server, or any other request/response protocol; Tower underpins higher-level frameworks like Axum, Tonic, and Hyper’s ecosystem rather than being an application framework itself.

What You Get

• The Service trait: an async function from Request to Result<Response, Error> that any client or server can implement
• The Layer trait for composing middleware into reusable, stackable wrappers around a Service
• Ready-made middleware: timeout, retry, load_shed, limit (concurrency/rate), balance (load balancing), buffer, hedge, filter, reconnect, and steer
• tower-service and tower-layer are no_std compatible, so the core traits can be used in constrained environments
• tower-test utilities for unit-testing services and middleware in isolation

Common Use Cases

• Adding timeouts, retries, and rate limiting to an HTTP or gRPC client without hand-rolling each concern
• Building a load-balancing client that distributes requests across multiple backend connections
• Composing middleware stacks underneath web frameworks like Axum or RPC frameworks like Tonic
• Writing protocol-agnostic middleware once and reusing it across different network protocols

Under The Hood

Architecture - the workspace splits the abstraction from the implementation: tower-service defines the minimal Service trait (no_std, #![forbid(unsafe_code)]), tower-layer defines the Layer composition trait, and the top-level tower crate provides the actual middleware implementations (balance, buffer, discover, filter, hedge, limit, load, load_shed, ready_cache, reconnect, retry, spawn_ready, steer, timeout, util) plus a ServiceBuilder for stacking them, each middleware living in its own module so consumers can feature-gate in only what they use. Tech Stack - 100% Rust, no_std-compatible core traits with alloc, std-only middleware in the main crate, built on futures/tokio-style async primitives without depending on a specific runtime. Code Quality - the tower crate enforces missing_docs and missing_debug_implementations lint warnings and #![forbid(unsafe_code)] in tower-service, and ships a dedicated tower-test crate for exercising services in isolation, though the low commit velocity (activity_status: moderate, ~0.33 commits/month) reflects the crate’s foundational, mostly-stable nature rather than active feature growth. API Design - the entire library is built from two small traits (Service, Layer), which keeps the conceptual surface tiny and highly composable via ServiceBuilder, but the trait-based, generic-heavy design (especially around poll_ready/backpressure semantics) has a real learning curve for developers new to Rust’s async trait patterns.