The page does not state a license or repository status, though component and framework source is described as living in your repo in typed Rust.

How much does Proa cost?

No pricing is published on the site. Proa UI components are individually labeled 'Free' or 'Pro', indicating a paid tier for part of the component catalog, but no prices are listed.

What does the Proa UI component library include?

58 components, each with a live example, a props table, and copyable Rust — ranging from primitives (Button, Field, Card, Table) to product surfaces (Calendar, Chart, Input OTP, Chat, Code Block). Components are themed and composed in Rust source in your repo.

How does Proa handle accessibility and security?

WCAG and WAI-ARIA checks run during cargo build so common markup defects fail before deploy. Security defaults include auto-escaped output, cross-origin request protection, security headers, and fixed-upstream proxying.

Proa — A Rust web framework for fast, multi-target rendering

Proa is a batteries-included web framework written in Rust, built around a programming model where a single typed component can render to multiple targets — HTML, Markdown, and others. It renders on the server by default and only compiles explicitly opted-in interactive controls ('RSJS islands') into small vanilla-JS modules. Beyond rendering, it includes framework primitives like streaming SSR, routing, layouts, metadata, forms, and a Shadcn-style component catalog (Proa UI). It can run Axum-native or be called over FFI from Node, Go, Python, Ruby, or Java, so it can be adopted one route at a time alongside an existing stack.

Key Features

Multi-target rendering from one component

A single typed component implements multiple render traits (e.g. MdRenderSync and WebRenderSync), producing HTML, Markdown, and other targets from the same code via macros like html_sync! and md_sync!.

Server rendering by default

Pages ship as server-rendered HTML; interactivity is opt-in per control rather than a default client bundle.

RSJS islands with tiny JavaScript

Add interactivity with signal(...), bind_value, typed events, and named handlers in Rust; the compiler lowers client behavior into a small vanilla-JS module plus seed state per island, with a shared runtime of around 1.3 KB gzipped.

Streaming SSR

Flush HTML in document order when sequence matters, or use Suspense boundaries to stream ready chunks out of order so slow data doesn't block the page.

Typed framework context

Every render gets typed access to request-scoped data, response metadata, route state, and loader caching through a DataLoader-backed WebContext.

Proa UI component system

58 Shadcn-style components (Accordion, Table, Card, Calendar, Chart, Input OTP, Chat, Code Block, and more), each with a live example, props table, and Rust source that lives in your repo. Many ship zero JavaScript; charts are drawn as pure SVG on the server.

Adoption without a rewrite

Run Axum-native for Proa routing and responses, or call the Proa render core over FFI from Node, Go, Python, Ruby, or Java; proxy one route from Next.js or Rails to compare latency and cost in production.

Security and accessibility built in

Auto-escaped output, cross-origin request protection, security headers, and fixed-upstream proxying are part of the framework surface; WCAG and WAI-ARIA checks run during cargo build so markup defects fail before deploy.

Pros & Cons

Pros

Extremely fast server rendering — the site reports a warm production p50 of 23.5 µs for Proa versus 5.56 ms for React renderToString (237x faster) on an 8-vCPU AMD EPYC-Milan VPS
Minimal JavaScript by default: CSS-only components ship no JS at all, and hydrated islands use a shared runtime of roughly 1.3 KB gzipped
One typed component can serve multiple render targets (HTML, Markdown), avoiding duplicated rendering code
Full framework surface, not just templating: streaming SSR, routing, layouts, metadata, forms, mutations, and progressive navigation
Accessibility (WCAG/WAI-ARIA) and security checks run at compile time or as framework defaults

Who It's For

Best for

Rust teams building server-rendered, information-dense web apps where render latency and payload size matter
Teams that want a Shadcn-style component system with source in their own repo instead of a node_modules dependency
Organizations incrementally introducing Rust rendering into an existing Node, Rails, Go, Python, Ruby, or Java stack
Projects that need one component to output multiple formats, such as HTML pages and Markdown

Not ideal for

Teams unwilling to write Rust — there is no indication of a non-Rust authoring path
Applications that require heavy, always-on client-side interactivity typical of SPAs

Use Cases

Fast, information-dense apps such as dashboards, code hosts, observability tools, and booking sites — the showcase includes re-creations of GitHub, Sentry, and

Teams that want server-rendered HTML with selective islands of interactivity instead of a full client-side SPA

Adding a fast Rust-rendered route to an existing Node, Rails, Go, Python, or Java application via proxying or FFI

Building a typed design system in Rust that lives in your own repo and can be edited and checked by the compiler (including AI-agent edits)

FAQ

What is Proa?

An extremely performant, batteries-included Rust web framework built around a programming model for composable, multi-target rendering, where one typed component can render to HTML, Markdown, and other targets.

Does Proa require shipping JavaScript?

Not by default. Pages are server-rendered HTML, and many components are CSS-only with no JavaScript at all (for example, the Accordion uses radio inputs and CSS). When you opt a control into interactivity via RSJS islands, Proa compiles only the moving pieces into a small vanilla-JS module, with a shared runtime around 1.3 KB gzipped.

How fast is Proa's rendering?

The site reports a warm production p50 render of 23.5 µs for Proa versus 5.56 ms for React renderToString — a claimed 237x difference — measured on an 8-vCPU AMD EPYC-Milan VPS, with additional render speed, HTTP capacity, and suspense-under-load benchmarks published.

Can I adopt Proa without rewriting my existing app?

Proa