Actix Tower

Modern extensions for Actix Web — Tower compatibility, ergonomic extractors, production middleware, and developer utilities.

Overview

Actix Tower extends the Actix Web ecosystem with reusable components focused on compatibility, ergonomics, and production development.

Instead of replacing Actix Web, this crate builds on top of it by providing:

Tower middleware compatibility
Ergonomic extractors
Production-ready middleware
Typed utilities
Validation helpers
Cleaner APIs
Zero-cost abstractions where practical

The goal is to let Actix developers reuse more of the Rust web ecosystem while reducing boilerplate.

Highlights

✅ Tower middleware compatibility
✅ Ergonomic extractors
✅ Production middleware
✅ Typed API responses
✅ Validation helpers
✅ Feature-gated architecture
✅ Comprehensive integration tests
✅ Modular design

Why Actix Tower?

Actix Web is one of the fastest and most mature Rust web frameworks.

However, many projects repeatedly implement the same utilities:

middleware
request extractors
validation
response wrappers
request IDs
caching
rate limiting
Tower compatibility

Actix Tower packages these common components into a reusable crate while remaining fully compatible with Actix Web.

Installation

[dependencies]
actix-tower = "0.1"

Enable optional features as needed.

[dependencies]
actix-tower = { version = "0.1", features = [
    "tower",
    "middleware",
    "extract",
    "validation"
] }

Quick Example

use actix_tower::prelude::*;
use actix_web::{web, App, HttpServer, Responder};

#[derive(serde::Deserialize)]
struct User {
    username: String,
}

async fn create_user(
    body: AutoJson<User>,
) -> impl Responder {
    format!("Hello {}", body.username)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/users", web::post().to(create_user))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

Tower Compatibility

Reuse many existing Tower middleware directly inside Actix Web.

use actix_tower::compat::tower::TowerLayerCompat;
use tower_http::trace::TraceLayer;

App::new()
    .wrap(
        TowerLayerCompat::new(
            TraceLayer::new_for_http()
        )
    );

The compatibility layer is designed to integrate cleanly with the broader Tower ecosystem.

Examples include:

tower
tower-http
tower-governor
tower-sessions
tower-cookies
compatible future Tower middleware

Ergonomic Extractors

Instead of repeatedly calling .into_inner():

async fn create_user(
    body: web::Json<CreateUser>,
) {
    let body = body.into_inner();

    println!("{}", body.username);
}

Use:

async fn create_user(
    body: AutoJson<CreateUser>,
) {
    println!("{}", body.username);
}

Available extractors include:

AutoJson
AutoQuery
AutoPath
AutoForm
AutoMultipart
AutoData
AutoState

Middleware

Included middleware includes:

Request ID
Authentication
Authorization
Compression
Timeout
Rate Limiting
Response Cache
Metrics
Tracing

Each middleware is feature-gated to minimize compile times and dependencies.

Utilities

Developer utilities include:

Typed API responses
Standard error types
Validation helpers
Response builders
Extension helpers
Prelude module

Feature Flags

Feature	Description
tower	Tower compatibility layer
middleware	Built-in middleware
extract	Ergonomic extractors
validation	Validation helpers
cache	Response caching
compression	Compression middleware
tracing	Tracing integration
metrics	Metrics middleware
auth	Authentication utilities
macros	Procedural macros

Reliability

The crate is continuously validated through automated testing.

The test suite includes:

Integration tests
Tower compatibility tests
Concurrent request tests
Middleware short-circuit tests
Cache correctness tests
Rate limiting tests
Request cancellation tests
Large request body tests
Property-based tests
Stress tests

The development process emphasizes reproducing correctness issues with executable tests before applying fixes.

Design Principles

Actix Tower follows several guiding principles:

Actix-first design
Tower ecosystem compatibility
Zero-cost abstractions where practical
Feature-gated compilation
Small composable APIs
Minimal runtime overhead
Idiomatic Rust
Comprehensive automated testing

Examples

Run the included examples:

cargo run --example basic
cargo run --example tower
cargo run --example auth
cargo run --example tracing
cargo run --example extractor
cargo run --example validation

MSRV

Minimum Supported Rust Version (MSRV):

Rust 1.80+

The MSRV may increase only in future minor releases and will be documented in the changelog.

Documentation

API documentation is available on docs.rs.

Additional guides and examples are planned for future releases.

Contributing

Contributions are welcome.

Areas of interest include:

Documentation
Examples
Middleware
Tower integrations
Performance improvements
Testing
Benchmarks

Please open an issue before making large architectural changes.

License

Licensed under the Apache License, Version 2.0.

Status

Version 0.1.0

The crate is available on crates.io.

The public API follows semantic versioning (SemVer). Future breaking changes will be introduced only in major releases.

Feedback, bug reports, and pull requests are welcome.

actix_tower 0.1.1