React rendu côté serveur,
propulsé par le moteur.
PRISM est le framework React server-first de bext — son propre runtime JSX, des signaux fins et des îlots dans n'importe quel runtime. Il compile votre TSX en bundles V8 et les exécute dans le même processus bext qui gère TLS, routage et cache. Parité totale avec Next.js, sans Node.js.
La place de PRISM dans une requête
bext est le moteur. PRISM est l'étape de rendu à l'intérieur — pas un outil séparé à lancer ou déployer.
Requête
- HTTP/1.1 · 2 · 3
- N'importe quel domaine
bext
- Terminaison TLS
- Routage + proxy inverse
- Cache · compression · WAF
PRISM render
- Pool d'isolats V8
- Stream React → HTML
- Hydratation des îlots
Votre framework existant, ou PRISM natif
Pointez PRISM sur une app Next.js ou React et il la rend. Ou écrivez directement pour le runtime PRISM — même moteur, votre choix par projet.
Votre framework existant
Votre code React / Next.js App Router s'exécute côté serveur dans V8 — aucune réécriture, sans 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
Aller tout-en-PRISM
Abandonnez React et utilisez les primitives propres de PRISM pour une stack plus légère, server-first.
- 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
De page.tsx à HTML streamé
Écrire un page.tsx
Routage par fichiers, server components async, layouts, loaders et route handlers — les conventions que vous connaissez déjà.
Turbopack le compile
Votre TSX est bundlé en module V8 — graphe RSC, îlots client séparés, mémoïsation React Compiler appliquée.
Rendu dans V8
bext le rend dans un pool d'isolats V8 préchauffés par snapshot — streaming, avec Suspense et use(promise) natifs. Sans Node.js.
Stream + hydratation
Le HTML est streamé au navigateur au fil du rendu ; les îlots « use client » s'hydratent à l'arrivée ; les pages chaudes sont servies depuis le cache ISR.
Le React que vous connaissez déjà
Server components, îlots client et route handlers — mêmes conventions, sans Node.js en dessous.
'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', }, }); }
Un framework complet, intégré
SSR streamé
Les server components async, <Suspense> et use(promise) produisent un stream piloté par une boucle d'événements V8 — le HTML arrive au fil du rendu.
Îlots, n'importe quel runtime
Hydratez des composants interactifs avec React, Preact, Solid — ou les signaux natifs de PRISM. Les îlots « use client » sont détectés automatiquement.
Signaux fins
Un runtime réactif intégré — signal / computed / effect avec <List>, <Show> et <Switch> à clé. Réactivité Solid-style, rendue côté serveur et hydratée.
Bext Query
Une couche de données façon TanStack Query, construite sur les signaux — createQuery / createMutation avec cache, état et revalidation en arrière-plan.
Formulaires server action
<Form> poste vers une action « use server » et fonctionne sans JavaScript — amélioration progressive, UI optimiste et validation intégrées.
React Server Components
Un vrai pipeline Flight via react-server-dom-parcel — React server-only inliné, évalué dans son propre contexte V8 mis en cache.
ISR + cache fragment
ISR au niveau page avec stale-while-revalidate et protection anti-stampede, plus un composant <ISR> pour mettre en cache des fragments avec leur propre TTL.
Tailwind natif
Les classes utilitaires sont extraites du HTML rendu et inlinées en feuille de style par route — sans PostCSS, sans build step, zéro CPU quand inutilisé.
Object storage
Uploads et downloads S3 / R2 / MinIO présignés depuis un seul import — presignPut, presignGet, uploadDirect — configurés dans bext.config.toml.
Génération d'images OG
Images Open Graph dynamiques rendues côté serveur avec un moteur CSS Taffy et rastérisation de texte. Aucun service externe.
Cold starts par snapshot
Des isolats préchauffés par heap-snapshot rendent un nouveau worker immédiatement prêt — pas de warm-up JIT, pas de pénalité de cold start.
Dans le binaire
Pas de Node.js, pas de service SSR séparé, pas de sidecar. PRISM s'exécute dans le même processus bext qui termine TLS, route, met en cache et protège.
Les conventions que vous connaissez déjà
PRISM implémente les conventions de fichiers App Router une à une — la mémoire musculaire reste valide.
exemples exécutables, en direct
Chaque primitive de cette page est câblée et tourne sur demo.bext.dev — signaux, server actions, streaming, cache, auth, storage et plus. Lisez le code source, observez le résultat.
Explorer les démos