The React Framework
for the Rust and Bun Era.
Used by performance-obsessed teams to build full-stack web applications with React 19 Server Components, streaming SSR at 0.90ms median latency, four switchable rendering modes, and a single Rust binary at deploy.
import { cacheLife, cacheTag } from "swift-rust/cache";
import { SafeHtml, sanitizeHtml } from "swift-rust/security";
import Image from "swift-rust/image";
export default async function ProductPage() {
"use cache";
cacheLife("hours");
cacheTag("catalog");
const metrics = await loadTelemetry();
return (
<section className="grid gap-6">
<Image src="/hero.avif" width={1200} height={630} />
<SafeHtml html={sanitizeHtml(metrics.summary)} />
</section>
);
}What's in Swift Rust?
Everything you need to build great products on the web.
Full Next.js App Router familiarity paired with Rust systems engineering—zero config gymnastics, zero runtime bloat.
Built-in Optimizations
Automatic Image, Font (2,071 Google fonts + 8 local stacks), Video, and Script optimizations for instant Core Web Vitals and zero layout shift.
Dynamic HTML Streaming
Instantly stream UI from the Rust + JavaScriptCore runtime, integrated with the App Router, nested React Suspense boundaries, and loading.tsx skeletons.
React Server Components
Add rich data-driven components without sending additional client-side JavaScript. Built on React 19 with selective WebAssembly island hydration.
Data Fetching & use cache
Make your React component async and await your data directly. Combine granular "use cache" directives, cacheLife, cacheTag, and Partial Prerendering.
CSS & Swift Rust UI
First-class Tailwind CSS v4, CSS Modules, and @swift-rust/ui — 12 accessible components across 6 visual design worlds (flat, 3d, glass, neo, brutal, gradient).
Client & Server Rendering
Flexible rendering and caching options per project or per route, including Incremental Static Regeneration (ISR) and 0.90ms median SSR latency.
Server Actions & <Form>
Run server code by calling a function. Skip the API boilerplate and mutate state with progressive enhancement, optimistic UI, and single-roundtrip revalidation.
Route Handlers & Pipeline
Build strongly-typed Web Standard API endpoints, and co-locate guard.ts, schema.ts, loader.ts, and variant.ts for structured RFC 0001 route pipelines.
Swift Rust 1.11
The power of full-stack React 19 compiled to a single Rust executable. Migrate in one command with @swift-rust/codemod.
Systems-Grade Architecture
Built on a foundation of fast, production-grade tooling.
React 19
The library for web and native user interfaces. Swift Rust is built on the latest React 19 features, including Server Components, Actions, and Suspense streaming.
Rust Hyper + JSC
Native Rust HTTP server, zero-copy radix router, SIMD image pipeline, and embedded JavaScriptCore worker pool delivering 0.90ms p50 SSR latency.
SWC + Bun Bundler
Rust-based TypeScript and TSX compilation with automatic RSC boundary splitting, compile-time SR-E* diagnostics, and standalone single-binary packaging.
19.6× faster SSR.
Zero Node.js overhead.
Measured head-to-head against Next.js 16.4 (Turbopack) across identical 12-route applications under 16-connection sustained load. Native Rust HTTP routing + pre-warmed JavaScriptCore workers eliminate V8 cold-start jitter.
Swift Rust v1.11.3 vs. Next.js 16.4
12 routes · Dynamic SSR + RSC + API · Lower bar is faster / leaner
Adaptive Rendering Architecture
Four rendering modes. One line of config.
Set your default mode in swift-rust.config.ts or override per route with export const mode = "ssr". Never ship client JavaScript to routes that don't need it.
ssr-wasmDefaultSSR + WASM Islands
Server-rendered HTML streamed from Rust, paired with a lightweight WASM router and selective client hydration only where "use client" is declared.
Best for: Full-stack SaaS, e-commerce, and interactive web products.
ssr0 KB Client JSZero-JS SSR
Pure server-rendered HTML with zero client JavaScript bundles. Instant First Contentful Paint and 100/100 Core Web Vitals out of the box.
Best for: Documentation sites, blogs, marketing pages, and editorial publishing.
ssr-htmxHypermediaSSR + HTMX
Server-rendered HTML enhanced with declarative partial DOM swaps and progressive form mutations without managing client state trees.
Best for: CRUD back-offices, internal tools, and server-driven workflows.
wasmClient AppFull WASM SPA
Complete client-side application mode with sub-millisecond in-memory route transitions and offline-ready asset caching.
Best for: Dense interactive dashboards, canvas editors, and local-first tools.
Components with a third dimension.
Every component libraries gives you variant and size. Swift Rust UI adds design—letting you switch between six complete visual languages without changing a single JSX prop tree.
flat· Editorial precision3d· Tactile depthglass· Frosted translucencyneo· Soft surface reliefbrutal· Hard offset inkgradient· Luminous mesh$ bunx @swift-rust/ui add button card dialogExplore Swift Rust UI2,071 Google Fonts + 8 Local Stacks
Inspect live font specimens rendered with zero FOUT and automatic CSS variable injection.
Rust Image Pipeline & Blur Placeholders
On-demand AVIF/WebP transcoding, responsive srcsets, and zero-CLS blurDataURL previews.
Streaming Video & Client Islands
Aspect-ratio locked video players, poster preloading, and interactive client island controls.
Engineering Journal
From the blog.
Deep dives into our Rust Hyper server, JavaScriptCore worker pool, SWC compiler pass, and real-world benchmark methodology.
Read all engineering postsIntroducing Swift Rust: 19.6x Faster React SSR on a Rust + JSC Runtime
A full-stack React 19 framework powered with Rust + Bun. 0.90ms median SSR latency, 1,092 req/s throughput, four rendering modes, and single-binary deployment.
Why We Shipped Four Rendering Modes in One Config Line
SSR + WASM, Zero-JS SSR, SSR + HTMX, and Full WASM SPA. Pick the right architecture per project or per route without rewriting components.
Streaming SSR in Rust at 0.90ms p50 Latency
How we combined Hyper, an embedded JavaScriptCore worker pool, and React 19 renderToReadableStream for sub-millisecond median latency.
Ready to build at Rust speed?
Join engineering teams shipping full-stack React 19 applications as a single self-contained binary in seconds.