Skip to content
Back to search

proa

The next era of web interfaces. Built in Rust.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/Proa-Labs/proa with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/Proa-Labs/proa'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/proa-labs--proa/badge.svg)](/listings/proa-labs--proa)

HTML

<a href="/listings/proa-labs--proa"><img src="/api/listings/proa-labs--proa/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 302 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <div align="center">
  2. <img src="assets/logo.svg" width="96" height="96" alt="Proa" />
  3. # Proa
  4. **The next era of web interfaces. Built in Rust.**
  5. Proa is building the next generation of interface infrastructure for the web.
  6. It enables you to create extremely fast, scalable applications and services in
  7. Rust by bringing compiled components, streaming, data
  8. loading, and fine-grained interactive islands into one framework.
  9. [![Axum adapter](https://img.shields.io/badge/proa__framework__axum-0.3.0-DD7627?style=flat-square&logo=rust&logoColor=white)](proa_framework/proa_framework_axum/README.md)
  10. [![Core](https://img.shields.io/badge/proa__core-0.3.0-DD7627?style=flat-square&logo=rust&logoColor=white)](proa_core)
  11. [![Macros](https://img.shields.io/badge/proa__macros-0.3.0-DD7627?style=flat-square&logo=rust&logoColor=white)](proa_macros/README.md)
  12. [![RSJS](https://img.shields.io/badge/rsjs-0.2.0-DD7627?style=flat-square&logo=rust&logoColor=white)](rsjs/README.md)
  13. [![License](https://img.shields.io/badge/license-Apache--2.0-DD7627?style=flat-square)](LICENSE)
  14. [![X](https://img.shields.io/badge/X-DD7627?style=flat-square&logo=x&logoColor=white)](https://x.com/drewhariri)
  15. [![Reddit](https://img.shields.io/badge/Reddit-DD7627?style=flat-square&logo=reddit&logoColor=white)](https://www.reddit.com/r/proa_rs/)
  16. [**Get started**](https://proa.so/docs) ·
  17. [**Explore apps**](https://proa.so/ecosystem/apps#reference-showcases) ·
  18. [See the benchmarks](https://github.com/Proa-Labs/framework-benchmarks)
  19. </div>
  20. ---
  21. ## A programming model for multiple interfaces
  22. Proa's larger vision is one typed, compiled interface layer that produces the
  23. right representation for whoever asks: complete HTML for people, targeted
  24. behavior for browsers, and dense machine-readable output for agents.
  25. This repository provides the compiled renderer, built-in render traits for
  26. HTML and Markdown, browser interactivity, streaming, data loading, and framework
  27. tooling. Other render targets can define their own rendering implementations,
  28. whether for a format such as JSON or for a native rendering backend.
  29. ## Start in five minutes
  30. Install the latest stable CLI through Cargo using a current Rust toolchain:
  31. ```bash
  32. cargo install proa-cli --locked
  33. ```
  34. Once installed, update with `proa update`, or preview the latest stable version
  35. with `proa update --check`.
  36. Follow the [quickstart](https://proa.so/docs) to install the styling tools,
  37. create a site, edit its first route, and run Proa's checks.
  38. ## Your first page is a typed Rust component
  39. Add the application-facing crate:
  40. ```toml
  41. [dependencies]
  42. proa = "0.4"
  43. ```
  44. Use `WebRenderSync` and `html_sync!` for the normal fast path:
  45. ```rust
  46. use proa::{DataLoader, WebContext, WebRenderSync, WriteError};
  47. use proa::html_sync;
  48. struct Greeting {
  49. name: String,
  50. }
  51. impl<L: DataLoader> WebRenderSync<L> for Greeting {
  52. fn render(self, cx: &mut WebContext<L>) -> Result<(), WriteError> {
  53. html_sync! {
  54. <main class="mx-auto max-w-3xl px-6 py-16">
  55. <h1 class="text-4xl font-semibold">"Hello, "{self.name}</h1>
  56. <p class="mt-4 text-zinc-600">"Rendered by Proa."</p>
  57. </main>
  58. }
  59. .render(cx)
  60. }
  61. }
  62. ```
  63. The macro validates the template at compile time, consolidates adjacent static
  64. markup, and preserves the correct escaping behavior for dynamic slots.
  65. When a component genuinely needs to await work, switch to `WebRender` and
  66. `html!`. Markdown follows the same split with `MdRenderSync` / `md_sync!` and
  67. `MdRender` / `md!`.
  68. ## Add interactivity where it belongs
  69. An RSJS island is still a normal server component. Add signals and event
  70. handlers, and Proa emits the server-rendered HTML plus the JavaScript required
  71. for that island:
  72. ```rust
  73. use proa::{DataLoader, WebContext, WebRenderSync, WriteError};
  74. use proa::html_sync;
  75. use rsjs::{rsjs, signal};
  76. struct Counter {
  77. initial: i32,
  78. }
  79. #[rsjs(component, client)]
  80. impl<L: DataLoader> WebRenderSync<L> for Counter {
  81. fn render(self, cx: &mut WebContext<L>) -> Result<(), WriteError> {
  82. let count = signal(self.initial);
  83. html_sync! {
  84. <button
  85. data-counter
  86. type="button"
  87. on_click={|_| count.update(|value| value + 1)}
  88. >
  89. "Count: "{count.get()}
  90. </button>
  91. }
  92. .render(cx)
  93. }
  94. }
  95. ```
  96. The browser starts from the HTML the server already rendered. It does not
  97. re-run the server component tree to make the page interactive. See the
  98. [RSJS guide](rsjs/README.md) for composition, queries, shared state, forms, and
  99. current limitations.
  100. ## Markdown interfaces with MdRender
  101. A component can expose both an HTML page and a Markdown document from the
  102. same data. Give the `Greeting` component above a Markdown implementation:
  103. ```rust
  104. use proa::{DataLoader, WebContext, MdRenderSync};
  105. use proa::md_sync;
  106. impl<L: DataLoader> MdRenderSync<L> for Greeting {
  107. fn render_md(self, cx: &mut WebContext<L>) -> Result<(), WriteError> {
  108. md_sync! { r###"
  109. # Hello, {self.name}
  110. Rendered by Proa.
  111. "###
  112. }
  113. .render_md(cx)
  114. }
  115. }
  116. ```
  117. `MdRenderSync` and `md_sync!` are the synchronous path. Use `MdRender` and
  118. `md!` when a Markdown component needs to await work. Interpolated values are
  119. escaped, and typed children compose into larger documents. Both renderers
  120. use the same component data and define their own output.
  121. For an existing synchronous HTML component, enable the core crate's
  122. `html-to-markdown` feature and delegate with
  123. `proa::to_markdown(self).render_md(cx)`. The adapter captures its HTML and
  124. converts semantic elements to Markdown. It allocates during conversion;
  125. handwritten Markdown remains the fast path and controls custom representations.
  126. See the [HTML-to-Markdown example](proa_core/examples/html_to_markdown.rs).
  127. See the [Markdown rendering guide](https://proa.so/docs/core/markdown) for
  128. composition, async rendering, and serving Markdown alongside HTML.
  129. ## Technical Approach
  130. We treat web rendering as a serialization problem, not a component-tree
  131. reconstruction problem. A server should turn application state into useful HTML
  132. as directly as possible: **emit as much HTML and as little JavaScript as
  133. possible, as fast as possible.**
  134. JavaScript is expensive. The browser must download it, parse it, compile it, and
  135. execute it—often on the main thread. That is expensive on desktop and worse on
  136. mobile CPUs; it can take [6-10x longer](https://github.com/GoogleChrome/lighthouse/blob/main/docs/throttling.md#benchmarking-cpu-power) to execute on lower tier android devices.
  137. It also consumes memory and battery. Proa treats every byte of
  138. client code as work that must justify itself. For more, see [Addy Osmani's "The Cost of JavaScript"](https://www.youtube.com/watch?v=X9eRLElSW1c)
  139. ## Benchmarks
  140. Explore the interactive results at [frameworks.run](https://frameworks.run).
  141. The [benchmark repository](https://github.com/Proa-Labs/framework-benchmarks)
  142. contains the protocol, parity checks, source revisions, and raw captures.
  143. **Proa refreshed November 11, 2026 at `bbbc968`.** The render-only, HTTP, and
  144. cold-start comparisons use an Apple M4 Max. Only Proa was rerun; peer rows retain
  145. their October 21 captures on the same machine. These are dated measurements of
  146. specific workloads, rather than a simultaneous rerun or a claim about every app.
  147. ### Rendering
  148. Proa's P50 was **0.875 µs** for the 32-card component page, **189.375 µs** for
  149. the 1,000-row table, and **10.500 µs** for the 96-card product grid. This lane
  150. includes allocation of a fresh owned `RenderBuffer` and excludes copying it to a
  151. `String`. Routing, data loading, and HTTP are outside this render-only boundary.
  152. [![P50 render latency for seventeen renderers and three workloads; Proa refreshed November 11 on Apple M4 Max, peers retained from October 21](assets/benchmarks/01-canonical-scoreboard.svg)](assets/benchmarks/01-canonical-scoreboard.svg)
  153. [Full renderer measurements and output contracts](https://github.com/Proa-Labs/framework-benchmarks/blob/main/scoreboard.md).
  154. ### Serving pages over HTTP
  155. The product-grid capture measured **20,863 complete responses/s** and **9.6 MiB
  156. peak RSS** for Proa. HTTP parsing, rendering, response serialization, allocation,
  157. and transfer over loopback are included; compression is disabled.
  158. [![Sustained responses per second, CPU per response, and peak memory for Proa, React, Marko, Go html/template, and SvelteKit serving three pages](assets/benchmarks/21-canonical-pages-http.svg)](assets/benchmarks/21-canonical-pages-http.svg)
  159. [HTTP methodology and complete tables](https://github.com/Proa-Labs/framework-benchmarks/blob/main/http-capacity.md#canonical-pages-over-http-one-core-each).
  160. ### Streaming under load
  161. This panel uses the Apple M4 Max Proa/SvelteKit captures: Proa from November 11
  162. and SvelteKit from October 21, with one worker thread or process per server.
  163. **Their HTTP completion boundaries differ:** SvelteKit delivers promised data
  164. for the browser to render, while Proa delivers resolved HTML. Response-end
  165. throughput and latency therefore do not measure the same completed browser work.
  166. [![Proa and SvelteKit HTTP streaming throughput, memory, latency, and failures on Apple M4 Max; response end has different meanings for the two frameworks](assets/benchmarks/20-suspense-load.svg)](assets/benchmarks/20-suspense-load.svg)
  167. [Streaming methodology and browser-completion measurements](https://github.com/Proa-Labs/framework-benchmarks/blob/main/sveltekit.md#browser-completion).
  168. ### Cold start to first response
  169. The dated capture measured Proa at **5.11 ms P50** with **4.6 MiB RSS** after the
  170. first complete product-grid response. Each engine used 15 fresh processes after
  171. two filesystem-cache warmups. This includes process startup and the first render;
  172. it excludes installation and build time. Other work was active on the shared
  173. host, so rerun on an idle machine before using the absolute times for planning.
  174. [![P50, P95, and slowest time from process spawn to a complete product-grid response for five production servers, with RSS after the response](assets/benchmarks/22-cold-start.svg)](assets/benchmarks/22-cold-start.svg)
  175. [Cold-start method and capture conditions](https://github.com/Proa-Labs/framework-benchmarks/blob/main/http-capacity.md#cold-start-to-first-response).
  176. [Chart provenance and refresh instructions](docs/asset-provenance.md#benchmark-charts).
  177. ## Proa in production
  178. - [latency.so](https://latency.so): a server-side rendering speed
  179. leaderboard, server-rendered with Proa.
  180. ## Explore the project
  181. | If you want to… | Start here |
  182. |---|---|
  183. | Build your first Proa site | [Getting started](https://proa.so/docs) |
  184. | Understand the benchmark claims | [Benchmarks](#benchmarks) and the [full evidence repository](https://github.com/Proa-Labs/framework-benchmarks) |
  185. | Author server-rendered components | [`proa_core`](proa_core) and [`proa_macros`](proa_macros/README.md) |
  186. | Build interactive islands | [RSJS](rsjs/README.md) |
  187. | Load data and stream independent boundaries | [`proa_stream`](proa_stream) and the [data-loading guide](https://proa.so/docs/framework/data-loading) |
  188. | Integrate routing, security, and Axum | [`proa_framework_axum`](proa_framework/proa_framework_axum/README.md) |
  189. | Adapt Proa to another HTTP server or runtime | [`proa_framework_core`](proa_framework/proa_framework_core/README.md) |
  190. | Compile documentation and self-hosted fonts | [`proa_docs`](proa_docs) and [`proa_fonts`](proa_fonts) |
  191. | Embed rendering in an existing service | [FFI guide](https://proa.so/docs/ffi) |
  192. | Contribute to Proa | [Contributing guide](CONTRIBUTING.md) |
  193. | Give a coding agent project context | [Agent authoring guide](docs/agent/index.md) |
  194. ## Repository development
  195. Prerequisites:
  196. - Rust 1.93.0 or newer
  197. - Python 3 for repository lint scripts
  198. - Node.js 22 or newer for browser conformance tests and JavaScript comparison
  199. engines
  200. Run the workspace checks from the repository root:
  201. ```bash
  202. cargo fmt --all
  203. cargo check --workspace --all-targets
  204. cargo test --workspace --no-fail-fast
  205. python3 scripts/proa_perf_lint.py
  206. ```
  207. Run the marketing site and documentation locally with:
  208. ```bash
  209. cargo proa run -p proa_marketing --bin proa_marketing
  210. ```
  211. This repository contains the compiled-template engine and its first-party
  212. framework, tooling, examples, and RSJS compiler. Runtime templates and the
  213. `proa_ui` component library are downstream projects with independent release
  214. processes.
  215. Security issues should be reported privately according to
  216. [`SECURITY.md`](SECURITY.md). Generated and captured assets are documented in
  217. [`GENERATED.md`](GENERATED.md).
  218. ## License
  219. Proa is licensed under the Apache License, Version 2.0. See
  220. [`LICENSE`](LICENSE), copyright 2026 Proa Labs, Inc.
  221. Commercial use, including inside closed-source products, is permitted with no
  222. separate agreement. See [`LICENSING.md`](LICENSING.md) for details or contact
  223. `legal@proa.so`. Third-party attributions are collected in
  224. [`THIRD_PARTY_NOTICES.md`](THIRD_PARTY_NOTICES.md).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.