Mission-critical SSR for the agentic web
HTML at API speed.
Proa pushes server-side rendering (SSR) toward the theoretical limits of hardware: native HTML in microseconds, zero garbage collection, and flat tail latency under load. It's a Rust-based island-architecture framework and component system built from the ground up for speed.
Airbnb-scale home page benchmark
212x
faster than React SSR
Proa native render
P50 latency
4.62 µs
Proa P99 under load
tail latency stays flat
6.50 µs
React 19 renderToString (Node.js)
P50 latency
981 µs
React P99 renderToString (Node.js)
GC pauses visible at tail
6.85 ms
Identical 158 KB HTML output. Single-threaded, 50 concurrent connections for P99. Apple M4 Max.
Why this exists
The agentic web needs fast SSR.
Agents make SSR mandatory, then bring traffic your SSR stack can't handle.
The pages that go down first are the pages Proa is built to keep live.
Commerce
Merch drops that stay live under load.
Free Run 5.0
University Red
Prediction markets
Live odds, not a cached shell.
Will BTC close above $95k today?
63%chance
Yes
$100 → $159
No
$100 → $270
Ticketing
Seat maps that survive the onsale.
Nova Set — World Tour
Kia Forum · Los Angeles · Fri 8 PM
Sec 112 · Row F
2 tickets
See It Ship
Real Airbnb and Nike pages, not toy benchmarks.
Pixel-perfect Airbnb and Nike pages running on Proa, backed by the same native render path as the benchmark.
Modern Web Stack
Everything people want from a modern web app, without the render tax underneath it.
Proa is a component system, not a templating engine. It feels like writing JSX but in Rust: composable components, props, children, layouts. Plus routing, typed islands, Turbo-style navigation, and progressive enhancement. It changes the economics under the page, not the ambition of the product.
Navigation
SPA-like smoothness, still driven by HTML.
Pair Proa with Turbo and Idiomorph for instant-feeling navigation without turning every page into a client bundle.
SSO, OpenGraph & metadata
Authentication flows, nested layouts, and dynamic OpenGraph images compose like a real web framework — SSO callbacks, meta tags, and static assets included.
Forms + mutations
Post forms, return HTML, and progressively enhance only where the flow actually benefits.
Deploy where the data lives
Run at origin for pages that need fresh database reads. Use Workers/WASM for edge-friendly routes like geo-aware landing pages, auth gates, and lightweight personalization.
React island
SearchBar.tsxRust SSR
React island
MapPanel.tsx
React island
BookButton.tsx
Interactivity
A real islands framework for high-traffic pages.
Proa keeps most of the page as native SSR HTML and hydrates only the interactive pieces as typed React islands. Think Astro or Fresh, but with a native Rust render path underneath.
Islands for any CSR framework
Bring your own client framework — React, Solid, Svelte, Vue, or vanilla JS. Proa extracts typed props at compile time so the JavaScript boundary stays explicit, no matter which runtime hydrates the island.
Selective hydration, native SSR
Use the same selective-hydration mental model as Astro-style islands, but keep the full page render path in native code.
Proa render core
6.96 usAdoption
Keep the stack you already have. Move one route first.
Go Axum-native when you want the full framework, or call Proa over FFI from Node, Go, Python, Ruby, or Java.
Run alongside your existing app
Proxy one route to Proa, leave the rest on Next.js or Rails. Compare latency and cost in production before migrating another page.
Security by default
CSP nonces, CSRF tokens, SSRF protection, and auto-escaped output are built into the framework — not bolted on after the first audit.
Accessibility at compile time
111 WCAG 2.2 and WAI-ARIA 1.2 checks run during cargo build — missing alt text, invalid ARIA roles, nesting violations. No separate linter to install or CI step to forget.
Component System
Plain Rust structs. Typed props. Zero runtime.
Every component is a Rust struct with compiler-checked fields. Compose them inside html! with loops, conditionals, and real Rust logic — no templating language, no runtime overhead.
Card, Badge, Button — composable structs with typed variants. The syntax works natively with Rust syntax highlighting and LSPs, so go-to-definition, type hover, and find-all-references work out of the box in your IDE.
Islands in three lines
Point #[island] at a TSX file and Proa generates typed props, serialization, and hydration glue at compile time. The rest of the page stays as zero-JS native HTML.
Drop in one route first
Proa compiles to a native library with a C FFI. Keep your existing backend, move one expensive page, measure the delta, then decide how far to go.
Delete The Workaround Stack
When SSR gets cheap, half the architecture turns optional.
Keep the features you actually want. Lose the ones that only exist to protect the renderer from itself.
Before
After
Incoming request
dynamic, personalized, uncached
Native Proa render
microsecond SSR on the request path
Fresh HTML response
no page cache or regeneration queue
One request in. One native render call. One fresh HTML response out.
Optional now
No ISR or PPR as survival tactics
Prerender when it helps the product, not because request-time rendering collapses under real traffic.
Optional now
No HTML page cache dependency
Fresh renders get cheap enough that cache invalidation stops being the architecture.
Optional now
No streaming shell to hide latency
Stream when the experience wants it, not because the renderer is too slow to send a full page.
Optional now
No server components as a performance bailout
Use islands or client code where interactivity helps, not because the server cannot render fast enough.
Optional now
No dedicated SSR fleet or regen queue
A native render call replaces workers, warm pools, and background rebuild plumbing.
Optional now
No GC tuning on the hot render path
The critical path stays free of the pauses and long-tail variance that cause incident cascades.
Industry Signal
The largest companies already discovered the same opportunity.
Google, Airbnb, Netflix, and Vercel all spent real platform capital on the rendering layer. The specifics differ, but the conclusion is consistent: interpreted rendering gets expensive faster than most teams expect.
Multi-year platform effort
Compiled Soy templates to JVM bytecode
They still accepted the JVM and GC model. Proa takes the same instinct to native code and removes the garbage collector from the equation.
Read case study →
Multiple platform rewrites
Airbnb
Repeatedly rewrote SSR infrastructure
Hypernova, worker pools, and eventually server-driven UI all point to the same root issue: interpreted SSR is expensive at scale.
Read case study →
TTI cut roughly in half
Netflix
Removed client-heavy React from the landing page
React stayed valuable on the server, but the shipped experience moved closer to static HTML and lightweight interaction.
Read case study →
A roadmap built around managing render cost
Vercel
Turned SSR workarounds into product categories
SSG, ISR, PPR, and Fluid Compute all optimize around the same premise: request-time rendering is too expensive in the default stack.
Read case study →
One Component, Two Outputs
HTML for browsers. Markdown for agents.
The same component tree can serve browsers, assistants, and inline previews without inventing a second content system.
Ready To Test It
Put one route on Proa and measure the difference.
Start with the page that makes your current stack nervous: the personalized landing page, the high-traffic listing view, the request-time dashboard. Keep the rest of the system exactly where it is.