Rullst - Rust Fullstack Web Framework

💡 The Rullst Philosophy

Unlike other frameworks, Rullst strives to be simultaneously simple and complete, with a relentless focus on security and developer experience (DX).

The origins of this philosophy can be traced back to the very creation of the Rust programming language. Graydon Hoare, the original creator of Rust, lived in a building with an elevator that kept crashing due to software bugs in its underlying C/C++ code. Frustrated by having to climb the stairs because of memory safety vulnerabilities, he set out to create a language that was incredibly fast, yet guaranteed memory safety by design.

Rullst was forged with this exact mindset. We believe that web development shouldn't be a constant struggle against the framework, the language, or runtime bugs.

Our Core Tenets

Simple yet Complete: We solve the hardest web development problems out-of-the-box securely, without sacrificing simplicity or completeness.
Built for Humans and AIs: Rullst is architected to be highly legible. It empowers both human developers and AI coding agents to collaborate and build production-ready systems rapidly, even without deep prior framework knowledge.

Feature	Rullst	Loco	Topcoat	Dioxus / Leptos	Axum / Actix
HTTP & Routing	✅	✅	✅	✅ (SSR)	✅
Built-in ORM	✅ (Rullst-ORM)	✅ (SeaORM)	✅ (Toasty)	❌	❌
Interactive CLI Dashboard	✅ (Rullst Studio)	❌	❌	❌	❌
Auto-Generated Admin Panel	✅ (Rullst Nexus)	❌	❌	❌	❌
Wasm Islands (Frontend)	✅ (Pure Rust)	❌	❌	✅ (Core focus)	❌
Reactive SSR (No-JS)	✅ (Pure Rust)	❌	✅ (Signals)	❌	❌
Mobile/Desktop Apps	✅ (Tauri Integration)	❌	❌	✅ (Dioxus)	❌
Hybrid Hot-Reloading	✅ (Built-in)	❌	❌	✅ (Dioxus)	❌
Zero-Panics Policy	✅ (Enforced)	❌	❌	❌	❌
TypeScript SDK Generator	✅ (Built-in)	❌	❌	❌	❌
OpenTelemetry Integration	✅ (Built-in)	❌	❌	❌	❌

The Interactive Experience

Stop memorizing flags. The Rullst CLI guides you through project setup, database migrations, authentication, and cloud deployment interactively.

bash

██████╗ ██╗   ██╗██╗     ██╗     ███████╗████████╗
██╔══██╗██║   ██║██║     ██║     ██╔════╝╚══██╔══╝
██████╔╝██║   ██║██║     ██║     ███████╗   ██║   
██╔══██╗██║   ██║██║     ██║     ╚════██║   ██║   
██║  ██║╚██████╔╝███████╗███████╗███████║   ██║   
╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚══════╝╚══════╝   ╚═╝

The Ultimate Full-Stack Rust Framework v5.0.0
⚡ Security · Speed · Developer Experience ⚡

? Navigate with ↑↓, confirm with Enter
>
> ✨ Create New Project (API, Fullstack or Dockerized)
  📁 Already have a project? (Dev, Scaffold, DB, Auth, Deploy...)
  💡 View Help & Commands (Framework Reference)
  ❌ Exit (Close interactive menu)

Official Benchmarks & Performance

Rullst is designed to offer a "Best of Both Worlds" approach: the extreme productivity and feature-rich environment of full-stack frameworks combined with the memory safety and high throughput of Rust.

✨ View New Benchmarks ✨

Requests per Second (JSON)

Higher is better (Containerized, 125 Conns)

Rullst (Rust)

10,847 req/s

Spring Boot (Java)

3,480 req/s

NestJS (JS)

1,565 req/s

Django (Python)

692 req/s

Laravel Octane

536 req/s

SSR Engine Speed

Lower is better (CPU time per render)

Rullst (html!)

1.11 µs

Tera Template

2.07 µs

Dioxus (VDOM)

4.72 µs

Leptos (View)

9.54 µs

Black-Box HTTP Load Tests (Tier 1)

Official bombardier v2.0.2 load test suite running containerized applications under massive concurrent load (125 connections, 10s duration).

Framework	Language	Plaintext (Reqs/s)	Plaintext Latency	JSON (Reqs/s)	JSON Latency
Fiber (Go)	Go	114,878.31	1.08ms	110,825.31	1.12ms
Loco	Rust	90,338.83	1.38ms	103,706.65	1.20ms
Leptos	Rust	43,919.60	2.86ms	61,585.17	2.03ms
Gin (Go)	Go	34,484.73	3.61ms	35,856.79	3.48ms
Zap (Zig)	Zig	29,933.82	4.17ms	25,616.38	4.87ms
Axum	Rust	27,418.26	4.55ms	19,468.15	6.46ms
Actix-web	Rust	25,250.49	5.00ms	21,216.37	6.03ms
Rullst	Rust	13,063.31	9.71ms	10,847.17	11.58ms
Spring Boot	Java	7,483.75	16.74ms	3,480.63	37.72ms
Ruby on Rails	Ruby	5,084.95	34.94ms	62.88	2.00s
NestJS	JavaScript	1,084.24	116.34ms	1,565.11	82.38ms
Laravel Octane	PHP	566.08	218.65ms	536.45	233.78ms
Django	Python	489.30	254.28ms	692.12	179.23ms
Next.js	JavaScript	82.00	1.39s	190.91	799.50ms

The Honest Conclusion on Throughput

Rullst is built on top of Axum and Tokio. As the data clearly shows, adding a massive suite of developer tools (dynamic routing macros, security middlewares, resilience shields, database ORMs) introduces a measurable "Framework Tax."

Under raw load, Rullst caps out at around ~13,000 Reqs/s for Plaintext and ~10,800 Reqs/s for JSON. While it does not beat the raw micro-framework speeds of pure Axum, Actix-web, or Fiber, it still delivers massive performance compared to mainstream industry standards.

How Rullst Compares (JSON)

~3x faster than Spring Boot
~7x faster than NestJS
~15x faster than Django
~20x faster than Laravel Octane
~57x faster than Next.js
~172x faster than Ruby on Rails

*Note: Laravel Octane was benchmarked with Swoole. Ruby on Rails struggled heavily in JSON serialization under 125 concurrent connections, leading to deadlocks/timeouts similar to PHP workers under heavy load.

Final Verdict

If your goal is to build an API that does absolutely nothing but return a string 120,000 times per second, use Axum, Actix-web, or Fiber.

If your goal is to build a full-fledged, secure, and maintainable SaaS product with databases, queues, AI integrations, Hot-Reloading, and an Auto-CMS in a matter of days—while still comfortably supporting over 10,000 requests per second—Rullst is your framework.

Performance vs. DX Scorecard

Framework	Language	Performance	DX	Notes
Axum / Actix	Rust	⭐⭐⭐⭐⭐	⭐⭐	Absolute maximum speed, but you must build everything from scratch.
Fiber / Gin	Go	⭐⭐⭐⭐⭐	⭐⭐⭐	Very fast and simple, but lacks the massive built-in features of a true fullstack framework.
Rullst	Rust	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	High-level fullstack APIs, ORM, Auth, and Hot-Reloading with Rust's memory safety.
Loco	Rust	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	Rails-like experience in Rust, excellent speed but slightly steeper learning curve.
Leptos	Rust	⭐⭐⭐⭐	⭐⭐⭐⭐	The king of Rust fullstack WASM frontend, but backend API patterns are tied to SSR.
Spring Boot	Java	⭐⭐⭐	⭐⭐⭐	Enterprise standard, decent speed, but heavy memory footprint and boilerplate.
Ruby on Rails	Ruby	⭐⭐	⭐⭐⭐⭐⭐	The original "batteries included" framework. Beautiful DX, but scales poorly under high load.
NestJS	JS/TS	⭐⭐	⭐⭐⭐⭐	Beautiful architecture, but heavily bottlenecked by Node.js single thread under load.
Laravel	PHP	⭐	⭐⭐⭐⭐⭐	Incredible ecosystem and DX, but poor raw throughput under high concurrency.
Django	Python	⭐	⭐⭐⭐⭐⭐	Great "batteries included" framework, but heavily bottlenecks under high load.
Next.js	JS/TS	⭐	⭐⭐⭐⭐	Fantastic for frontend SSR, but backend API routes are very slow under load.
Zap	Zig	⭐⭐⭐	⭐	Extremely low-level C-like performance, but almost non-existent ecosystem/DX for web.

Why Rullst? Key Architectural Benefits

While Rullst competes closely in performance with bare-metal Rust frameworks like Axum and Actix-web, it stands out due to its unique architectural choices designed for modern software development and AI collaboration:

🚀 Hybrid Hot-Reloading

Sub-millisecond UI updates via WebSockets for your html! views, paired with Zero-downtime Dynamic Library (.dll/.so) hot-swapping for backend business logic. Enjoy Vite-like DX with a stateful Rust backend.

🛡️ Enterprise-Grade Security Matrix

Rullst is "Secure by Design", natively shipping with OWASP ZAP DAST scanning, OSSF Scorecards, cargo-fuzz, cargo-mutants, and hardcore mitigations against Timing Attacks, WAF bypasses, and CSRF DoS vectors out-of-the-box.

⚡ Auto-Migrations in Dev Server

Experience unmatched Developer Experience (DX). cargo rullst dev now automatically and silently runs your database migrations before hot-reloading your application, ensuring your schema is always perfectly synced with your code.

🤖 AI-Native & Code-Reasoning Optimization

Rullst is architected to be highly readable and predictable. By avoiding runtime magic, implicit reflection, or dynamic dependency injection, AI coding assistants (like Gemini/Claude) and developers can easily parse, trace, and modify the application without fear of runtime bugs.

🛡️ Compile-Time Guarantees

Rullst prioritizes catching structural bugs, route definition issues, and middleware mismatches at compile time rather than relying on runtime failures or comprehensive test suites.

🔒 Strict Type Safety (No Dynamic Traits)

Rullst avoids heavy usage of dyn Trait in favor of static dispatch and strong typing. This leads to better compiler optimizations (monomorphization), smaller binaries, and robust memory/concurrency safety guarantees.

🗺️ Explicit API Design

There is no hidden state or magical middleware sequencing. Everything (routes, shared state, filters, extensions) is explicitly declared and wired, preventing side effects and making codebase maintainability simple.

⚖️ Balanced DX & Performance

Rullst delivers high throughput and low latencies comparable to microframeworks like Axum, but provides a structured scaffold reminiscent of full-stack frameworks (like Loco or NestJS) without sacrificing performance.

🔄 Autonomous Upgrades

Never fear breaking changes again. cargo rullst upgrade performs AST-based codemods in the background to automatically update your syntax when the framework evolves.

🌍 Edge Fusion & Replication

Compile to WebAssembly for Cloudflare Workers globally, backed by built-in Turso/libsql replication for 1ms database read latency worldwide.

📱 Omni-Frontend Wasm

Write frontend interactive components strictly in Rust (#[client_component]). They compile to lightweight Wasm, eliminating the need to write JavaScript for SPAs or Desktop apps.

Documentation

Getting started is simple. Explore Rullst's batteries-included features below or visit our GitHub for the full guide.

Declarative Active Record ORM

Define your models with simple macros. No need for separate schema files or manual SQL queries. Features built-in multitenancy support.

use rullst_orm::Orm;
use rullst::db::FromRow;

#[derive(Debug, Clone, FromRow, Orm)]
#[orm(table = "posts", global_scope = "apply_tenant_scope")]
pub struct Post {
    pub id: i32,
    pub tenant_id: String,
    pub title: String,
    pub body: String,
}

// Global scopes apply automatically to all queries!
impl PostQueryBuilder {
    pub fn apply_tenant_scope(self) -> Self {
        if let Some(tid) = rullst::multitenant::current_tenant_id() {
            self.where_eq("tenant_id", tid)
        } else {
            self
        }
    }
}

Blazing Fast SSR with html!

Write type-safe HTML directly in Rust. It compiles to zero-allocation String concatenation, beating traditional templating engines by 2x-5x.

use rullst::html;

fn render_post_list(posts: &[Post]) -> String {
    if posts.is_empty() {
        html! {
            <div class="empty-state">
                "No posts published yet. Be the first to share a story!"
            </div>
        }
    } else {
        posts.iter().rev().map(|post| {
            html! {
                <div class="post-card">
                    <h3 class="post-title">{&post.title}</h3>
                    <p class="post-body">{&post.body}</p>
                </div>
            }
        }).collect()
    }
}

Intuitive Routing & Middleware

Declare your routes elegantly. Wrap your entire application with tenant-aware context, auth layers, and more using an Axum-compatible foundation.

use rullst::routes;

#[unsafe(no_mangle)]
pub extern "C" fn rullst_router_init() -> *mut rullst::Router {
    // Configure multitenancy by HTTP header
    let config = rullst::TenantConfig::new(rullst::TenantStrategy::Header)
        .with_header_name("X-Tenant-ID");

    // Define routes
    let router = routes![
        get("/" => index_handler),
        post("/posts" => store_post_handler),
        get("/api/health" => health_check),
    ]
    .layer(rullst::tenant_layer(config));

    Box::into_raw(Box::new(router))
}

WebSockets & Live Components

Build reactive components (like Phoenix LiveView) directly in Rust, powered by WebSockets. State stays on the server, UI updates seamlessly.

pub async fn live_demo() -> impl IntoResponse {
    let component = rullst::live::Live::mount::<CounterComponent>("/_live").await;
    
    Html(html! {
        <html lang="en">
        <head>
            <script src="https://unpkg.com/htmx.org@1.9.11"></script>
            <script src="https://unpkg.com/htmx.org@1.9.11/dist/ext/ws.js"></script>
        </head>
        <body>
            { rullst::html::RawHtml(component) }
        </body>
        </html>
    })
}

pub async fn live_ws(ws: axum::extract::ws::WebSocketUpgrade) -> impl IntoResponse {
    rullst::live::live_ws_handler::<CounterComponent>(ws).await
}

📖 Read on mdBook 📝 Read on GitHub

Rust for those who want to build, not suffer.

💡 The Rullst Philosophy

Our Core Tenets

How to build a SaaS with Rullst

The Full-Stack Feature Matrix

The Interactive Experience

Official Benchmarks & Performance

Requests per Second (JSON)

SSR Engine Speed

Black-Box HTTP Load Tests (Tier 1)

The Honest Conclusion on Throughput

How Rullst Compares (JSON)

Final Verdict

Performance vs. DX Scorecard

Why Rullst? Key Architectural Benefits

🚀 Hybrid Hot-Reloading

🛡️ Enterprise-Grade Security Matrix

⚡ Auto-Migrations in Dev Server

🤖 AI-Native & Code-Reasoning Optimization

🛡️ Compile-Time Guarantees

🔒 Strict Type Safety (No Dynamic Traits)

🗺️ Explicit API Design

⚖️ Balanced DX & Performance

🔄 Autonomous Upgrades

🌍 Edge Fusion & Replication

📱 Omni-Frontend Wasm

Documentation

Declarative Active Record ORM

Blazing Fast SSR with html!

Intuitive Routing & Middleware

WebSockets & Live Components

💡 The Rullst Philosophy

Our Core Tenets

How to build a SaaS with Rullst

The Full-Stack Feature Matrix

The Interactive Experience

Official Benchmarks & Performance

Requests per Second (JSON)

SSR Engine Speed

Black-Box HTTP Load Tests (Tier 1)

The Honest Conclusion on Throughput

How Rullst Compares (JSON)

Final Verdict

Performance vs. DX Scorecard

Why Rullst? Key Architectural Benefits

🚀 Hybrid Hot-Reloading

🛡️ Enterprise-Grade Security Matrix

⚡ Auto-Migrations in Dev Server

🤖 AI-Native & Code-Reasoning Optimization

🛡️ Compile-Time Guarantees

🔒 Strict Type Safety (No Dynamic Traits)

🗺️ Explicit API Design

⚖️ Balanced DX & Performance

🔄 Autonomous Upgrades

🌍 Edge Fusion & Replication

📱 Omni-Frontend Wasm

Documentation

Declarative Active Record ORM

Blazing Fast SSR with html!

Intuitive Routing & Middleware

WebSockets & Live Components

Privacy & Cookies