🐙 Tako — Lightweight Async Web Framework in Rust

Tako ("octopus" in Japanese) is a pragmatic, ergonomic and extensible async web framework for Rust. It aims to keep the mental model small while giving you first‑class performance and modern conveniences out‑of‑the‑box.

Blog posts:

• Tako: A Lightweight Async Web Framework on Tokio and Hyper
• Tako v.0.5.0 road to v.1.0.0
• Tako v0.5.0 → v0.7.1-2: from "nice router" to "mini platform"

✨ Highlights

• Multi-protocol — HTTP/1.1, HTTP/2, HTTP/3 (QUIC), WebSocket, WebTransport, SSE, gRPC, TCP, UDP, Unix sockets, PROXY protocol.
• Dual runtime — First-class support for both Tokio and Compio async runtimes (including TLS + HTTP/2 on both).
• 22+ extractors — Strongly-typed request extractors: JSON, form, query, path, headers, cookies (signed/private), JWT, Basic/Bearer auth, API key, Accept, Range, protobuf, and more.
• Rich middleware — Auth (JWT, Basic, Bearer, API key), CSRF, sessions, body limits, request IDs, security headers, upload progress, compression, rate limiting, CORS, idempotency, metrics.
• SIMD JSON — Route-level configurable SIMD-accelerated JSON parsing (sonic-rs / simd-json) with automatic size-based dispatch.
• Background job queue — In-memory task queue with named handlers, retry policies (fixed / exponential backoff), delayed jobs, dead letter queue, and graceful shutdown.
• Streaming & SSE — Built-in helpers for Server-Sent Events and arbitrary Stream responses.
• GraphQL — Async-GraphQL integration with extractors, responses, and WebSocket subscriptions.
• OpenAPI — Automatic API documentation via utoipa or vespera integration.
• TLS — Native rustls-based HTTPS with ALPN negotiation.
• Compression — Brotli, gzip, deflate, and zstd response compression.
• Signals — In-process pub/sub signal system for decoupled event-driven architectures.
• Static files & file streaming — Serve directories and stream files with range request support.
• Graceful shutdown — Drain in-flight connections before exit across all server variants.

Feature Matrix

Transports & Protocols

Extractors (22+)

Middleware

Feature Flags

Documentation

API Documentation

MSRV 1.87.0 | Edition 2024

Tako in Production

Tako already powers real-world services in production:

• stochastic-api: https://stochasticlab.cloud/
• shrtn.ink: https://app.shrtn.ink/

🔥 Benchmarking the Hello World

+---------------------------+------------------+------------------+---------------+
| Framework 🦀              |   Requests/sec   |   Avg Latency    | Transfer/sec  |
+---------------------------+------------------+------------------+---------------+
| Tako (not taco! 🌮)       |    ~148,800      |    ~649 µs       |   ~12.6 MB/s  |
| Tako Jemalloc             |    ~158,059      |    ~592 µs       |   ~13.3 MB/s  |
| Axum                      |    ~153,500      |    ~607 µs       |   ~19 MB/s    |
| Actix                     |    ~126,300      |    ~860 µs       |   ~15.7 MB/s  |
+---------------------------+------------------+------------------+---------------+

👉 Command used: `wrk -t4 -c100 -d30s http://127.0.0.1:8080/`

📦 Installation

Add Tako to your Cargo.toml:

[dependencies]
tako-rs = "*"

🚀 Quick Start

Spin up a "Hello, World!" server in a handful of lines:

use anyhow::Result;
use tako::{
    responder::Responder,
    router::Router,
    types::Request,
    Method,
};
use tokio::net::TcpListener;

async fn hello_world(_: Request) -> impl Responder {
    "Hello, World!".into_response()
}

#[tokio::main]
async fn main() -> Result<()> {
    // Bind a local TCP listener
    let listener = TcpListener::bind("127.0.0.1:8080").await?;

    // Declare routes
    let mut router = Router::new();
    router.route(Method::GET, "/", hello_world);

    // Launch the server
    tako::serve(listener, router).await;

    Ok(())
}

📜 License

MIT — see LICENSE for details.

Made with ❤️ & 🦀 by the Tako contributors.