Axum has become the default Rust web framework for new services, and for good reason: it leans on Tokio, Tower, and Hyper instead of reinventing them, skips the macro magic that made earlier Rust frameworks hard to debug, and produces compiler errors that actually point at the problem. Actix-web still edges it on raw throughput, but Axum wins on ergonomics and ecosystem fit. The real cost is Rust itself: the borrow checker and compile times are the tax you pay for memory safety without a garbage collector. For teams already in Rust, it is the pick.
- Built directly on Tokio, Tower, and Hyper, no custom runtime
- Macro-free routing and extractors, readable compiler errors
- Full Tower middleware ecosystem works out of the box
- Memory-safe with no garbage collector, predictable latency
- Maintained by the Tokio team, the center of async Rust
- Rust's borrow checker is a steep onboarding curve
- Compile times are slow versus Go or Node iteration loops
- Actix-web handles roughly 10-15% more requests under load
- Pre-1.0 (0.8.x), minor versions still ship breaking changes
Axum is an ergonomic, modular web framework for Rust, written and maintained by the Tokio team. It builds directly on Tokio (the async runtime), Tower (composable middleware), and Hyper (the HTTP layer), so it inherits a battle-tested foundation rather than shipping its own. The pitch is Rust’s performance and memory safety with an API that stays readable.
Where it fits
Axum suits teams that want Rust’s guarantees, no garbage collector, no data races, predictable tail latency, for the parts of their system that need them: high-throughput JSON APIs, latency-sensitive services, and backends that already share async code across the Tokio ecosystem. Its handlers are plain async functions, and request data arrives through extractors rather than macros, so a route reads like ordinary Rust. Because it sits on Tower, any Tower middleware (timeouts, tracing, rate limiting, auth) composes without waiting for a framework-specific port. It is a common landing spot for a Go or Node service that has hit a throughput or memory ceiling.
Cost to adopt
Axum is free and MIT-licensed, so there is no license or hosting fee. The real cost is Rust. The borrow checker and ownership model are a genuine learning curve for teams coming from garbage-collected languages, and compile times are slower than a Node or Go edit-run loop. In exchange you get memory safety without runtime overhead, and the Tower ecosystem means middleware is mostly assembly rather than authoring. Compared to Actix-web, Axum trades a slice of raw throughput for gentler ergonomics and tighter Tokio alignment.
How it compares
Gin, Go’s most popular HTTP framework, ships faster to first endpoint thanks to Go’s simpler model. Axum wins where memory safety and no-GC latency matter more than iteration speed.
Express, the JavaScript default, is far quicker to learn but runs on a single-threaded event loop. Axum is the choice when CPU-bound work or strict latency budgets rule Node out.
FastAPI pairs Python ergonomics with auto-generated OpenAPI docs. Axum gives up that batteries-included polish for an order-of-magnitude performance and safety gain.
Actix-web is Axum’s closest Rust rival: it posts roughly 10 to 15 percent higher throughput under heavy load, but its actor model and heavier macro use raise the learning curve. Axum is the more common default for new Rust services.
What changed recently
Axum 0.8.0 landed on 2025-01-01, switching path parameter syntax to OpenAPI-style braces (/{id} instead of /:id), reworking Option<T> extractors so rejections can become real error responses, and dropping the #[async_trait] macro now that Rust supports return-position impl Trait in traits. The 0.8.x line has shipped steadily since, with 0.8.9 released on 2026-04-14 adding more flexible WebSocket subprotocol selection and raising the minimum Rust version to 1.80. The team is now working toward 0.8 stability ahead of an eventual 0.9, while Axum’s roughly 26,000 GitHub stars and its position as the Tokio team’s framework keep it the center of gravity for async Rust web work.
Sources
- tokio-rs/axum on GitHub, retrieved 2026-06-05
- Announcing axum 0.8.0, tokio.rs, 2025-01-01
- axum on crates.io, 0.8.9 published 2026-04-14
- Rust Web Frameworks in 2026: Axum vs Actix Web, 2026