Server-rendered TSX,
powered by the engine.
PRISM is bext’s server-first TSX framework — a native JSX runtime with no React, a compile pass, fine-grained signals, and islands in the runtime of your choice. It compiles TSX into V8 bundles and renders them inside the same bext process that handles TLS, routing, and caching.
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
- Native TSX → HTML
- V8 isolate pool
- Output to ISR · cache · HTTP
Native PRISM, or bext’s React adapter
PRISM is the native TSX-to-HTML path. For an existing React or Next.js app, bext provides a separate adapter; the measurements on this page apply only to native PRISM.
Existing React / Next.js
Choose [framework] type = "nextjs" to retain React, RSC, and App Router conventions. That path does not use PRISM’s native renderer.
- 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.
The compile pass folds TSX
Static tags and subtrees become HTML fragments; recognized list shapes become loops with one growing accumulator.
Render in V8
The cached bundle runs in a warm V8 isolate. The automatic JSX runtime handles dynamic portions that cannot be folded, with no React or Virtual DOM.
HTML + cache
Safe, byte-validated HTML passes to the ISR and HTTP pipeline; optional interactive islands hydrate separately in the browser.
Native TSX, optional islands
Server rendering does not use React. A client island may still choose React, Preact, Solid, or PRISM signals.
'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 components, generators, and PRISM Suspense produce HTML chunks as their content becomes available.
Islands, any runtime
React “use client” islands are detected automatically; the islands API also supports Preact, Solid, or PRISM’s native signals.
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.
Compile pass
Static TSX subtrees, safe attributes, and recognized list shapes become direct concatenations and loops before V8 execution.
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 adopts familiar App Router file and routing conventions while using its own TSX renderer.
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