📜🦀Rullst is smashing all the other frameworks!

Understanding the Numbers
Here are the numbers of Rullst vs Competitors in average execution time per operation measured by criterion (optimized version):

1. SSR Rendering (Dynamic Rendering with Loops)
   Rullst (macro html!): ~1.07 µs (microseconds)
   Tera Template Engine (e.g. used by Loco): ~2.14 µs (2x slower than Rullst)
   Dioxus (Virtual DOM to String): ~4.54 µs (4.2x slower than Rullst)
   Leptos (View macro to String): ~9.10 µs (8.5x slower than Rullst)
   Rullst crushes them all here thanks to macro expansion done 100% at compile time.

2. In-Memory Routing and Handlers
   Axum Router (Plain Text): ~946 ns (nanoseconds)
   Rullst Router (Plain Text): ~974 ns (Practically a tie, margin of error or microscopic overhead of Rullst's zero-cost encapsulation)
   Rullst Router (JSON): ~1.53 µs
   Axum Router (JSON): ~1.59 µs
   Rullst remained identical to raw Axum! Showing that the framework's macros deliver a Rails/Loco syntax while keeping Zero Cost on the Base architecture.

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:

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

Know more about Rullst here: https://rullst.github.io/