rust's powerful actor system and most fun web framework

Type Safe

Forget about stringly typed objects, from request to response, everything has types.

Feature Rich

Actix provides a lot of features out of box. HTTP/2, logging, etc.

Extensible

Easily create your own libraries that any Actix application can use.

Blazingly Fast

Actix is blazingly fast. Don't take our word for it -- see for yourself!

use actix_web::{web, App, HttpRequest, HttpServer, Responder};

fn greet(req: HttpRequest) -> impl Responder {
    let name = req.match_info().get("name").unwrap_or("World");
    format!("Hello {}!", &name)
}

fn main() {
    HttpServer::new(|| {
        App::new()
            .route("/", web::get().to(greet))
            .route("/{name}", web::get().to(greet))
    })
    .bind("127.0.0.1:8000")
    .expect("Can not bind to port 8000")
    .run()
    .unwrap();
}

Flexible Responders

Handler functions in actix can return a wide range of objects that implement the Responder trait. This makes it a breeze to return consistent responses from your APIs. 

#[derive(Serialize)]
struct Measurement {
    temperature: f32,
}

fn hello_world() -> impl Responder {
    "Hello World!"
}

fn current_temperature() -> impl Responder {
    web::Json(Measurement { temperature: 42.3 })
}

Powerful Extractors

Actix comes with a powerful extractor system that extracts data from the incoming HTTP request and passes it to your view functions. Not only does this make for a convenient API but it also means that your view functions can be synchronous code and still benefit from asynchronous IO handling. 

#[derive(Deserialize, Serialize)]
struct Event {
    id: Option<i32>,
    timestamp: f64,
    kind: String,
    tags: Vec<String>,
}

fn capture_event(evt: web::Json<Event>) -> impl Responder {
    let new_event = store_in_db(evt.timestamp, &evt.kind, &evt.tags);
    format!("got event {}", new_event.id.unwrap())
}

Easy Form Handling

Handling multipart/urlencoded form data is easy. Just define a structure that can be deserialized and actix will handle the rest. 

#[derive(Deserialize)]
struct Register {
    username: String,
    country: String,
}

fn register(form: web::Form<Register>) -> impl Responder {
    format!("Hello {} from {}!", form.username, form.country)
}

Request Routing

An actix app comes with a URL routing system that lets you match on URLs and invoke individual handlers. For extra flexibility, scopes can be used. 

fn index(_req: HttpRequest) -> impl Responder {
    "Hello from the index page!"
}

fn hello(path: web::Path<String>) -> impl Responder {
    format!("Hello {}!", &path)
}

fn main() {
    App::new()
        .route("/", web::get().to(index))
        .route("/{name}", web::get().to(hello));
}