Server-rendered React,
powered by the engine.
PRISM is bext’s own server-first React framework — its own JSX runtime, fine-grained signals, and islands in any runtime. It compiles your TSX into V8 bundles and renders them inside the same bext process that handles TLS, routing and caching. Full Next.js parity, zero Node.js.
Where PRISM fits in a request
bext is the engine. PRISM is the rendering stage inside it — not a separate tool you run or deploy.
Request
- HTTP/1.1 · 2 · 3
- Any hostname
bext
- TLS termination
- Routing + reverse proxy
- Cache · compression · WAF
PRISM render
- V8 isolate pool
- Stream React → HTML
- Hydrate islands
Bring your framework, or go PRISM-native
Point PRISM at a Next.js or React app and it renders it. Or write to PRISM’s own runtime for the full surface — same engine, your call per project.
Bring your framework
Your existing React / Next.js App Router code renders server-side in V8 — no rewrite, no Node.js.
- Async server components, <Suspense> and the use(promise) hook
- "use client" islands hydrated automatically
- React Server Components & server actions
- next/font, next/image, next/link
- Most Next.js App Router apps migrate with minimal changes
Go all-in on PRISM
Drop React entirely and use PRISM’s own primitives for a lighter, server-first stack.
- Its own h() JSX runtime — light, server-first, no React required
- Fine-grained signals + <List> / <Show> / <Switch>
- Bext Query, server-action <Form>s, native Tailwind
- Signed sessions, OAuth, role gating, object storage, SSE, MDX
- Islands in React, Preact, Solid, or signals — your choice per component
From page.tsx to streamed HTML
Write a page.tsx
File-based routing, async server components, layouts, loaders and route handlers — the conventions you already know.
Turbopack compiles it
Your TSX is bundled to a V8-ready module — RSC graph, client islands split out, React Compiler memoization applied.
Render in V8
bext renders it in a pooled, snapshot-warmed V8 isolate — streaming, with Suspense and use(promise) working natively. No Node.js.
Stream + hydrate
HTML streams to the browser as it renders; “use client” islands hydrate on arrival; hot pages are served from the ISR cache.
Write the React you already know
Server components, client islands, and route handlers — same conventions, no Node.js underneath.
'use server'; // async server component export default async function Page() { const posts = await db.posts.all(); return ( <Suspense fallback={<Spinner />}> <Feed posts={posts} /> </Suspense> ); }
'use client'; import { useState } from 'react'; // auto-detected island export function Counter() { const [n, setN] = useState(0); return ( <button onClick={() => setN(n + 1)}> count: {n} </button> ); }
export async function GET(req) { const data = await load(); return Response.json(data, { headers: { 'cache-control': 's-maxage=60', }, }); }
A complete framework, built in
Streaming SSR
Async server components, <Suspense>, and use(promise) render to a stream driven by a custom event loop inside V8 — HTML flushes as it’s ready.
Islands, any runtime
Hydrate interactive components with React, Preact, Solid — or PRISM’s native signals. “use client” islands are detected automatically.
Fine-grained signals
A built-in reactive runtime — signal / computed / effect with keyed <List>, <Show> and <Switch>. Solid-style reactivity, server-rendered and hydrated.
Bext Query
A TanStack-Query-style data layer built on signals — createQuery / createMutation with caching, status, and background revalidation.
Server-action Forms
<Form> posts to a “use server” action and works with JavaScript off — progressive enhancement, optimistic UI, and validation built in.
React Server Components
A real Flight payload pipeline via react-server-dom-parcel — server-only React inlined, evaluated in its own cached V8 context.
ISR + fragment cache
Page-level ISR with stale-while-revalidate and a stampede guard, plus an <ISR> component to cache individual fragments with their own TTL.
Native Tailwind
Utility classes are scanned from the rendered HTML and inlined as a per-route stylesheet — no PostCSS, no build step, zero CPU when unused.
Object storage
Presigned S3 / R2 / MinIO uploads and downloads from a single import — presignPut, presignGet, uploadDirect — configured in bext.config.toml.
OG image generation
Dynamic Open Graph images rendered server-side with a Taffy CSS layout engine and text rasterization. No external service.
Snapshot cold starts
Heap-snapshot-baked isolates make a new worker render-ready instantly — no JIT warm-up, no cold-start penalty.
Lives in the binary
No Node.js, no separate SSR service, no sidecar. PRISM runs in the same bext process that terminates TLS, routes, caches and protects.
The conventions you already know
PRISM implements the App Router file conventions one-for-one — so muscle memory carries over.
runnable examples, live
Every primitive on this page is wired up and running at demo.bext.dev — signals, server actions, streaming, caching, auth, storage and more. Read the source, see the output.
Explore the demos