Introducing Proa: A High-Velocity Rust Framework for Multi-Target Rendering

Proa is a comprehensive, "batteries-included" web framework written in Rust. It is engineered for extreme performance and introduces a novel programming paradigm that allows developers to create composable components capable of rendering to multiple targets.

🎯 The Power of Multi-Target Rendering

Unlike traditional frameworks that tie a component to a single output, Proa allows a single typed component to generate HTML, Markdown, and other formats.

Implementation Example

Below is how a ProductCard might be implemented to support both Web and Markdown outputs:

// A single component serving multiple render targets
impl L: DataLoader WebRenderSync L for ProductCard {
    fn render(self, cx: mut WebContext L) -> Result<(), WriteError> {
        html_sync! {
            <article data-product-card>
                <h2>{self.product.name}</h2>
                { Link::new("Buy now", self.product.url) }
            </article>
        }
    }
}

impl L: DataLoader MdRenderSync L for ProductCard {
    fn render_md(self, cx: mut WebContext L) -> Result<(), WriteError> {
        md_sync! {
            ### {self.product.name}
            { Link::new("Buy now", self.product.url) }
        }
    }
}

---

🚀 Performance & Benchmarks

Proa is designed for information-dense applications where speed is critical. It eliminates the "render tax" associated with modern JavaScript frameworks.

Speed Comparison

Measured on an 8-vCPU AMD EPYC-Milan VPS, the difference in server-side rendering (SSR) is staggering:

$\text{Performance Gain} = \frac{\text{React Render Time}}{\text{Proa Render Time}} \approx 237\times$

Rendering Pipeline

---

🛠️ The Component Ecosystem

Proa provides a library of 58 components, each featuring live examples, detailed props tables, and copy-pasteable Rust code.

Component Catalog

---

🏗️ Framework Architecture

Proa is not merely a templating engine; it is a full-surface framework.

"Everything people want from a modern web app, without the render tax underneath it."

Core Technical Pillars

• Unified WebContext: Proa integrates streaming, request data, routing, and metadata into a single typed WebContext shared by all components.
• Advanced Streaming SSR:
  • In-order: Flush HTML sequentially when the document structure is strict.
  • Out-of-order: Use Suspense boundaries to stream ready chunks, ensuring slow data fetches don't block the rest of the page.
• DataLoader Integration: Every render cycle has typed access to:
  • Request-scoped data
  • Response metadata
  • Route state
  • Loader caching
• Type-Safe Semantics: Layouts, mutations, and progressive navigation are handled via the Rust component model rather than "template glue."

Selective Interactivity (The "Island" Model)

Proa maintains a "Server-render by default" philosophy. You only ship JavaScript when interactivity is required.

• Native SSR: The bulk of the page is static HTML.
• RSJS Islands: Specific interactive zones (e.g., a SearchIsland or MapViewport) are hydrated with rsjs handlers.
• Compiler Verified: Because components are typed Rust, edits are checked by the compiler before they ever reach the user.

---

🖼️ Showcase

Proa's capabilities are demonstrated through high-fidelity re-creations of complex platforms:

• GitHub: Complex code views and issue tracking.
• Sentry: Dense telemetry dashboards and trace waterfalls.
• Airbnb: High-performance listing grids and booking calendars.

(Note: Proa is not affiliated with or endorsed by GitHub, Sentry, or Airbnb.)