Best Rust Web Frameworks (2024)

Rust's popularity has been growing steadily over the past few years, and it has become a popular choice for building web applications. Rust's safety, performance, and concurrency model make it an excellent choice for building high-performance web applications.

For that reason, there has been great development in the Rust web framework ecosystem, with many frameworks available to help you build web applications in Rust.

In this article, we will take a look at some of the top Rust web frameworks to use in 2024. We'll go over the details of each frameworks and their key features with a simple example of code to get you an idea of how each framework works. After that we're going to look up some benchmarks to see a comparison between each framework based on certain metrics. If you want to skip to the benchmarks, you can click here.

With that said, let's explore some of the top Rust web frameworks available in 2024.

Axum is a Rust web framework built on top of Tower and Hyper, designed to be robust, performant, reliable, and ergonomic. It integrates seamlessly with Tokio for asynchronous runtime, allowing for fast and efficient code. Axum leverages the Tower and tower-http ecosystems, providing a rich set of middleware, services, and utilities.

Axum's design emphasizes flexibility, making it easy to build complex web applications by combining simple, modular components. It supports a range of features, including routing, middleware, extracting request data, and handling responses, all while maintaining a focus on type safety and clear, concise APIs.

Axum is built to be scalable and performant, making it a great choice for building high-performance web applications in Rust.

Let's write a simple "Hello, World!" application using Axum:

use axum::{response::Html, routing::get, Router};
 
#[tokio::main]
async fn main() {
    let app = Router::new().route("/", get(handler));
 
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
        .await
        .unwrap();
 
    println!("listening on http://{}", listener.local_addr().unwrap());
 
    axum::serve(listener, app).await.unwrap();
}
 
async fn handler() -> Html<&'static str> {
    Html("<h1>Hello, World!</h1>")
}

The code above simply creates a new Router and accepts a GET request to the root path / and returns a Html response with the content Hello, World!. Axum is designed to be simple and easy to use, allowing you to focus on writing your application logic.

Rocket by far is the most popular Rust web framework. It is known for its simplicity and ease of use. It is known for it's type safety, boilerplate free, and extensibility.

Here are some key features of the Rocket web framework:

• Routing: Maps requests to handlers using route attributes.
• Form Handling: Declarative and type-validated form handling.
• JSON Support: Directly handle JSON with Deserialize and Serialize.
• Templating: Built-in support for templating.
• WebSockets: Create async data streams easily.
• Database Support: ORM agnostic database interactions.
• Middleware: Use Fairings for structured middleware.
• Testing: Comprehensive built-in testing library.

use rocket::{get, launch, routes};
 
#[get("/")]
fn hello_world() -> &'static str {
    "Hello, world!"
}
 
#[launch]
fn rocket() -> _ {
    rocket::build().mount("/", routes![hello_world])
}

This simplicity and ease of use make Rocket a popular choice for many Rust developers. It provides a great balance between performance and productivity, making it an excellent choice for web development.

Rocket also has a strong community and ecosystem, with many plugins and extensions available to extend its functionality. You can get answers to your questions quickly and find many resources to help you get started with Rocket.

Actix web is yet another popular Rust backend framework. It is known for it's Type Safety features from request to response, it's feature-rich comes with HTTP/2, logging, and other built-in features, and it has excellent performance.

Actix web can also be extended with other community library crates to add more features to your application.

use actix_web::{get, web, App, HttpServer, Responder};
 
#[get("/")]
async fn index() -> impl Responder {
    "Hello, World!"
}
 
#[get("/{name}")]
async fn hello(name: web::Path<String>) -> impl Responder {
    format!("Hello {}!", &name)
}
 
#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let server = HttpServer::new(|| App::new().service(index).service(hello))
        .bind(("127.0.0.1", 8080))?
        .run();
 
    println!("Server running at http://localhost:8080");
 
    server.await
}

Actix web is quite popular and has a strong community of developers. It is highly maintained and has a lot of features that make it a great choice for building web applications in Rust.

Loco is another Rust web framework designed specifically for solo developers working on side projects.

I't purpose is to make it easier to build, iterate, and scale Rust applications with confidence.

• Batteries Included: Loco comes with built-in services, data management, email handling, background jobs, tasks, and a powerful CLI, making it easier to get your project up and running quickly.
• Inspired by Rails: Loco draws inspiration from Rails' simplicity and productivity, adapting those concepts to modern Rust development.
• Built for Solo Developers: Optimized for one-person teams, Loco hides complexity and heavy lifting under the hood, allowing you to focus on building and delivering your product.
• Scalable Architecture: Loco allows you to scale by splitting, reconfiguring, or using only the parts of the framework that suit your needs.
• Incremental Development: Loco's modular approach lets you start small and expand as needed, adapting to your workflow without unnecessary overhead.
• Test-Driven Development: Testing is at the heart of Loco, providing simple, effective tools for testing models, controllers, background jobs, and more.

#![allow(clippy::unused_async)]
use loco_rs::prelude::*;
 
pub async fn echo(req_body: String) -> String {
    req_body
}
 
pub async fn hello(State(_ctx): State<AppContext>) -> Result<Response> {
    // do something with context (database, etc)
    format::text("hello")
}
 
pub fn routes() -> Routes {
    Routes::new()
        .prefix("guide")
        .add("/", get(hello))
        .add("/echo", post(echo))
}

Most of the code will be generated by the Loco CLI, this makes it easier to get started with Loco and build your application quickly. Just running loco new can generate a new project with all the necessary files and configurations.

Poem is another Rust web framework to help you build rust server applications. It is designed to be simple, fast, and reliable. It is built on top of the hyper and tokio libraries, making it a great choice for building high-performance web applications.

• OpenAPI Support: Poem provides built-in support for OpenAPI, making it easy to generate API documentation and interact with your API.
• Middleware Support: Poem has a robust middleware system that allows you to add custom logic to your application easily.
• Async Support: Poem is built on top of the tokio async runtime, allowing you to write asynchronous code that is fast and efficient.
• Type Safety: Poem is designed to be type-safe, ensuring that your code is free of common runtime errors.
• Easy to Use: Poem is designed to be simple and easy to use, allowing you to focus on building your application logic.

use poem::{
    get, handler, listener::TcpListener, middleware::Tracing, web::Path, EndpointExt, Route, Server,
};
 
#[handler]
fn hello(Path(name): Path<String>) -> String {
    format!("hello: {name}")
}
 
#[tokio::main]
async fn main() -> Result<(), std::io::Error> {
    if std::env::var_os("RUST_LOG").is_none() {
        std::env::set_var("RUST_LOG", "poem=debug");
    }
    tracing_subscriber::fmt::init();
 
    let app = Route::new().at("/hello/:name", get(hello)).with(Tracing);
    Server::new(TcpListener::bind("0.0.0.0:3000"))
        .name("hello-world")
        .run(app)
        .await
}

We've explored some of the top and most important web frameworks for the Rust programming language, now it's time to look at some data to see how these frameworks compare in terms of performance.

To make these comparisions we're going to use the data from the programatik29/rust-web-benchmarks GitHub repository. This repository contains benchmarks for various Rust web frameworks, including Axum, Rocket, Actix Web, and Poem.

These benchmarks are all based on a simple "Hello, World!" application, that only returns a simple string response without doing anything else, in real life applications you will definitely see different numbers but this is a great way to compare the performance of each framework.

The results show that Actix Web gives the best performance by handling the most requests per second, followed by Axum, Poem, and Rocket.

In terms of memory usage, they're quite close to each other (12-20MB) which is a good sign that they're all efficient in terms of memory usage.

Finally, in terms of latency, Actix Web also has the lowest latency, and Rocket having the highest latency.

We've explored some of the top Rust web frameworks available in 2024, including Axum, Rocket, Actix Web, Loco, and Poem. Each of these frameworks has its own strengths and weaknesses, and the best choice for you will depend on your specific needs and requirements.

If your project requires excellent performance and scalability, Actix Web might be the best choice for you. If you're looking for a simple and easy-to-use framework, Rocket might be the best choice for you.

However, if you're a solo developer working on side projects, Loco might be the most suitable choice for you. It is designed to make it easier to build, iterate, and scale Rust applications with confidence.

At the end, it all comes down to your specific needs and requirements, and the best way to find the right framework for you is to try them out and see which one works best for you.

Thanks for reading this blog post, if you found it useful, you might also like our blog post about the Rust testing libraries 🧪, where we explore some of the top Rust testing libraries available in 2024.

You can also subscribe to our newsletter ✉️ to get the latest updates and articles about Rust and web development.

Thank you for reading, and happy coding!