SSR HTML + stateServer
View tree, data-r-on hooks, and resumability state — ready before any JS runs.
v1.3.1 · Full Rust · UI + API + jobs
The lightest path to instant interactivity in Rust
1021 B to resume. Zero Resuma JS on static pages.
Resuma renders UI once on the server, serialises signals into HTML, and lazy-loads only the handlers you touch. No WASM hydration. Pages, APIs, auth, and jobs — one crate.
cargo install resuma · resuma new my-app --template todo · no Node.js for app development
This site’s Theme menu is a native <Popup>; Search is a <Modal>.
what ships (gzip)
Static page0 B JS
Interactive page — loader1021 B
First click — loader + core + handler9.90 KiB
Next.js counter (default scaffold)142.43 KiB
143× smaller initial payload than a default Next.js app — same counter UX. Methodology →
Zero-cost static
Marketing pages ship no JavaScript
Docs, blogs, and landing sections without signals or handlers compile to pure HTML. No runtime. No hydration tax. Deploy to the edge and forget about bundle budgets.
Static vs interactive pages →Payload anatomy
Every byte has a job
Hydration frameworks ship the whole app up front. Resuma ships HTML plus a resumability payload — handlers and core load only when needed.
Loader1021 B
Bootstraps signals from SSR. Enough for the page to feel alive.
Core runtime8.78 KiB
DOM updates, Show/For, effects — fetched on first interaction or prefetch.
Handler chunksPer component
onClick lives in a handler chunk — you pay only for what users touch.
Measured
Counter page — initial load (gzip)
Same UX everywhere: SSR heading + one increment button. Bar width is relative to Next.js (142.43 KiB).
Initial load, first interaction, and static-page JS — gzip
| Framework | Initial load | First interaction | Static page |
|---|---|---|---|
| Resuma | 1021 B | 9.90 KiB | 0 B |
| Leptos | 79.02 KiB | 79.02 KiB | — |
| Next.js | 142.43 KiB | 142.43 KiB | — |
| React (Vite) | 57.99 KiB | 57.99 KiB | — |
| Astro | 57.76 KiB | 57.76 KiB | — |
| SvelteKit | 27.71 KiB | 27.71 KiB | — |
| Qwik | 1.96 KiB | 22.32 KiB | — |
| SolidStart | 16.75 KiB | 16.75 KiB | — |
| templ + HTMX | 16.21 KiB | 16.21 KiB | — |
Hydration frameworks load the same JS on page load — initial and first click match. Resuma static pages ship 0 B client JS. node benchmark/run.mjs
Try it in the docs
Live demos — inside the documentation
Interactive examples run on every docs page: workers, signals, forms, and server functions. The homepage stays lean — open a guide and click.
LIVE
Resuma OS workers
Run a real #[worker], watch the execution graph, pause and cancel.
→LIVESignals & reactivity
Increment a counter — fine-grained updates, no full re-render.
→LIVEServer functions
Call Rust from the browser without a page reload.
→LIVEForms & #[submit]
Progressive enhancement — works as HTML POST before JS loads.
→LIVEControl flow
Show, For, Match — conditional UI with lazy boundaries.
→LIVELoaders & streaming
#[load] data fetching with cache headers and streaming SSR.
→One binary
Frontend speed. Backend included.
Qwik, React, Angular, and Next.js still need a second stack for APIs, jobs, and auth. Leptos hydrates with WASM. Resuma resumes a few kilobytes of JS — and the rest is Rust: typed actions, file routes, SQL, sessions, queues, cron, and WebSockets.
Hydration stacks
Ship a client runtime (React, Angular, Next, Leptos WASM). Interact later. Your API lives in another service.
Qwik
Resumable JS — closest mental model. Still a JavaScript framework; workers and APIs are a separate deploy.
Resuma
Resumable Rust SSR + lazy JS handlers. Pages, RPC, jobs, and realtime in one cargo install. No WASM by default.
Performance model
Interactive from the first click
The client never re-runs your component tree. State and handlers are already in the HTML.
HTML first
Static pages ship no Resuma JS. Interactive pages resume a loader; core and handlers arrive on the click that needs them.
Full Rust stack
#[server] RPC, #[submit] forms, #[load] data, workers, queues — axum-native. One process, no adapter maze.
Progressive enhancement
<Form submit> works as plain HTML POST before JS loads; runtime enhances in place.
Resumable by default
Every #[component] is a lazy boundary. Handlers live in /_resuma/handler/{Component}.js.
Components
Write UI once — on the server
view! with JSX-like syntax, fine-grained signals, and onClick handlers that compile to lazy JavaScript.
- signal for reactive state
- computed! / effect! for client replay
- #[component] props builder generated for you
#[component]
fn Counter() {
let count = signal(0);
view! {
<button onClick={count.update(|c| *c += 1)}>
"Count: " {count}
</button>
}
}
// Handler lazy-loads from /_resuma/handler/Counter.jsResuma OS
Durable workers — self-hosted
#[worker] functions, disk-backed queues, cron scheduler, and an ops dashboard. No Redis, no external orchestrator — same binary as your app.
- Execution graphs with SSE event streams
- Pause, resume, cancel from the Flow UI
- Queue recovery and checkpointed state
#[worker(intent = "enrich page")]
async fn enrich(input: Input, ctx: WorkerContext) -> Result<Value> {
ctx.log("fetching");
let page = ctx.tool("fetch", json!({ "url": input.url })).await?;
ctx.progress(50);
let summary = ctx.tool("ai", json!({
"prompt": "Extract key facts",
"data": page
})).await?;
Ok(summary)
}Why Resuma?
Everything you need for modern SSR
Resumable SSR in Rust — one install, progressive enhancement, full-stack Flow when you need it.
Resuma Flow
File-based pages, #[load], #[submit], layouts, middleware — built into the same crate.
Deploy
Same Docker image on Fly, DigitalOcean, AWS App Runner, or a VM. Not Lambda, not Workers.
Dev experience
resuma dev with HMR WebSocket, resuma new templates (basic, todo, flow, production).
JS bridge
view! translates Rust closures via rs2js. js!{} for escape hatches when you need raw client code.
Islands (optional)
#[island(load = "visible")] for heavy widgets — most UI only needs #[component].
Security built in
Crypto CSRF, security headers, rate limits — see examples/todo for production patterns.
One package
Resuma¹ + Flow²
Two layers, one dependency. Core stays stable; Flow adds routing, data loading, and forms.
RESUMA¹ — CORE
Components & resumability
- view!, #[component], signal
- computed! / effect! / debounce!
- #[server], ResumaApp, 8.78 KiB runtime
+
FLOW² — FULL-STACK
Pages, loads & submits
- FlowApp, src/pages/, #[layout]
- #[load], #[submit], #[middleware]
- Streaming SSR, cache headers
AI assistants
Build faster with Cursor, Codex, or Gemini
Install the Resuma agent skill in one command — view!, HtmlTheme, Popup/Modal, Flow, SeoKit, and the debugging checklist. After a CLI upgrade: resuma install skill --force.
resuma install skill
Integrations
Database, auth, and tooling
Integration guides for SQLx, Turso, auth, validation, i18n, and E2E testing.