A powerful and simple Rust web framework

English   简体中文   繁體中文

Features

• Simple & Powerful - Minimal boilerplate. If you can write a function, you can write a handler.
• HTTP/1, HTTP/2 & HTTP/3 - Full protocol support out of the box.
• Flexible Routing - Tree-based routing with middleware support at any level.
• Auto TLS - ACME integration for automatic certificate management.
• OpenAPI - First-class OpenAPI support with auto-generated documentation.
• WebSocket & WebTransport - Real-time communication built-in.
• Built on Hyper & Tokio - Production-ready async foundation.

Quick Start

Create a new project:

cargo new hello-salvo
cd hello-salvo
cargo add salvo tokio --features salvo/oapi,tokio/macros

Write your first app in src/main.rs:

use salvo::prelude::*;

#[handler]
async fn hello() -> &'static str {
    "Hello World"
}

#[tokio::main]
async fn main() {
    let router = Router::new().get(hello);
    let acceptor = TcpListener::new("127.0.0.1:7878").bind().await;
    Server::new(acceptor).serve(router).await;
}

Run it:

cargo run

Why Salvo?

Middleware = Handler

No complex traits or generics. Middleware is just a handler:

#[handler]
async fn add_header(res: &mut Response) {
    res.headers_mut().insert(header::SERVER, HeaderValue::from_static("Salvo"));
}

Router::new().hoop(add_header).get(hello)

Tree Routing with Middleware

Apply middleware to specific route branches:

Router::new()
    // Public routes
    .push(Router::with_path("articles").get(list_articles))
    // Protected routes
    .push(Router::with_path("articles").hoop(auth_check).post(create_article).delete(delete_article))

JSON APIs

Salvo handlers can deserialize request bodies and return typed JSON responses:

use salvo::http::ParseError;
use salvo::prelude::*;
use serde::{Deserialize, Serialize};

#[derive(Deserialize)]
struct CreateTodo {
    text: String,
}

#[derive(Serialize)]
struct Todo {
    id: u64,
    text: String,
}

#[handler]
async fn create_todo(req: &mut Request) -> Result<Json<Todo>, ParseError> {
    let payload = req.parse_json::<CreateTodo>().await?;
    Ok(Json(Todo {
        id: 1,
        text: payload.text,
    }))
}

For this pattern, add Serde's derive feature:

cargo add serde --features derive

OpenAPI in One Line

Just change #[handler] to #[endpoint]:

#[endpoint]
async fn hello() -> &'static str {
    "Hello World"
}

Auto HTTPS with ACME

Get TLS certificates automatically from Let's Encrypt:

let listener = TcpListener::new("0.0.0.0:443")
    .acme()
    .add_domain("example.com")
    .http01_challenge(&mut router)
    .quinn("0.0.0.0:443"); // HTTP/3 support

CLI Tool

cargo install salvo-cli
salvo new my_project

Learn More

• Official Website
• API Documentation
• Examples
• Feature-specific crates

Recommended Projects

• Savhub - Easily manage your AI skills. A platform built with Salvo for organizing and sharing AI capabilities.
• Palpo - A Matrix server implementation in Rust, powered by Salvo.

Check out the full list of community projects in our ECOSYSTEM.md.

Performance

Salvo consistently ranks among the fastest Rust web frameworks:

• Web Frameworks Benchmark
• TechEmpower Benchmarks

Support

If you find Salvo useful, consider buying me a coffee.

License

Licensed under Apache License 2.0.