🐙 Tako — Multi-Transport Rust Framework for Modern Network Services

Tako ("octopus" in Japanese) is a pragmatic, ergonomic and extensible Rust framework for services that go beyond plain HTTP. Build one cohesive application across HTTP/1.1, HTTP/2, HTTP/3, WebSocket, SSE, gRPC, TCP, UDP, Unix sockets, and WebTransport with a single routing, middleware, and observability model.

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"

Why Tako

Tako is built for teams that want fewer moving parts in production:

• One service, many transports — Serve REST, WebSockets, SSE, gRPC, raw TCP/UDP, Unix sockets, and QUIC-based workloads without switching frameworks.
• One mental model, two runtimes — Use the same framework style on Tokio or Compio depending on the deployment constraints.
• Application primitives included — Middleware, auth, metrics, signals, queues, graceful shutdown, and streaming are part of the framework story, not an afterthought.
• Performance knobs when they matter — SIMD JSON, optional zero-copy extractors, compression, jemalloc, and HTTP/3 support are available without fragmenting the API.
• Strong fit for real systems — API backends, realtime apps, protocol gateways, internal platforms, and edge-facing services.

✨ Highlights

• Multi-transport by design — HTTP/1.1, HTTP/2, HTTP/3 (QUIC), WebSocket, WebTransport, SSE, gRPC, TCP, UDP, Unix sockets, and PROXY protocol.
• Dual runtime support — First-class support for both Tokio and Compio, including TLS and HTTP/2 on both sides where supported.
• Built-in platform primitives — Background job queue, in-process signals, metrics hooks, graceful shutdown, static files, and stream helpers.
• Rich middleware and auth — JWT, Basic, Bearer, API key, CSRF, sessions, body limits, request IDs, security headers, upload progress, rate limiting, CORS, idempotency, and compression.
• Strongly typed extraction — 22+ extractors for JSON, form, query, path, headers, cookies, JWT claims, API keys, Accept, Range, protobuf, multipart, and more.
• Performance paths included — SIMD JSON (sonic-rs / simd-json), optional zero-copy extractors, brotli/gzip/deflate/zstd, and jemalloc support.
• Realtime-ready — Streaming responses, SSE, WebSockets, GraphQL subscriptions, HTTP/3, and WebTransport under one crate.
• Docs and API surface included — OpenAPI via utoipa or vespera, GraphiQL support, and a growing example suite for common deployment patterns.

Best Fit

Choose Tako when your service needs one or more of these:

• More than REST — You need HTTP APIs plus WebSockets, SSE, gRPC, TCP, UDP, or QUIC in the same application.
• Realtime coordination — You want built-in signals, queues, and streaming primitives instead of composing everything manually.
• Framework consolidation — You would rather depend on one coherent crate than glue together several partially overlapping libraries.
• Protocol-heavy infrastructure — Gateways, internal platforms, telemetry collectors, control planes, or edge services are a particularly strong fit.

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/

Baseline Hello World Benchmark

Hello world throughput is not the whole story, but the current branch lands in this range on a clean local run:

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

Benchmarks are machine- and thermal-state-dependent, so treat these as local baselines, not universal claims. Axum and Actix were rerun with minimal temporary hello-world servers using the same wrk command.

📦 Installation

Add Tako to your Cargo.toml:

[dependencies]
tako-rs = "1"

🚀 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.