DinouBuild with React 19Deploy Everywhere
The ejectable React 19 framework built on web standards. Build full-stack apps and deploy anywhere with zero vendor lock-in.
React Server Components. Zero Black-Box Magic.
Dinou was engineered from the ground up for React 19 primitives: native Server Components, direct Server Functions, and streaming Web standards.
0kb JavaScript Shipped for Server Code
Render markdown parsers, database queries, and heavy backend dependencies exclusively on the server. Dinou streams progressive React Flight chunks over standard W3C Web Streams directly into the DOM.
// Pure Server Component: 0kb sent to browser
import { db } from "@/lib/db";
import { MarkdownParser } from "@/lib/heavy-parser";
import { InteractiveChart } from "./client-chart"; // "use client"
export default async function DashboardPage() {
// Direct database query on server
const reports = await db.reports.findLatest();
const summaryHtml = MarkdownParser.render(reports.raw);
return (
<main className="space-y-6">
<h1>Production Analytics</h1>
<div dangerouslySetInnerHTML={{ __html: summaryHtml }} />
{/* Only this interactive leaf downloads client JS */}
<InteractiveChart data={reports.metrics} />
</main>
);
}Deploy Everywhere. Zero Platform Lock-in.
Build your application once with React 19 Server Components. Dinou compiles it ahead-of-time to any production infrastructure in the world.
Cloudflare Workers
Global Edge RuntimeSub-millisecond global cold starts across 300+ cities with native Cloudflare KV integration.
- ✓Pure W3C Web Streams (ReadableStream / TransformStream)
- ✓Native workerd runtime with zero Node.js server dependencies
- ✓Static assets served directly via Cloudflare global CDN (env.ASSETS)
- ✓Automatic ISR route caching & revalidation backed by Cloudflare KV
Intuitive File-Based Routing. Zero Boilerplate.
Every folder with a page.tsx in src/ maps directly to a public route. Nested layouts, dynamic params, route groups, and parallel slots work right out of the box.
Nested Layouts with Zero Remounting
Every folder with a page.tsx in src/ maps directly to a public route. Nested layout.tsx files wrap child pages without remounting during navigation, preserving client state, audio playback, and scroll positions.
src/layout.tsx wraps every route with shared HTML and body shells.reset_layout / no_layout, or park folders completely with _folder.import { Link, type LayoutProps } from "./dinou";
// Nested layout wraps all /dashboard/* child pages
export default function DashboardLayout({ children }: LayoutProps) {
return (
<div className="flex min-h-screen">
{/* Persistent sidebar: never remounts across child route changes */}
<aside className="w-64 border-r border-slate-800 p-4">
<nav className="space-y-2">
<Link to=".">Overview</Link>
<Link to="analytics">Analytics</Link>
<Link to="settings">Settings</Link>
</nav>
</aside>
{/* Dynamic page content transitions smoothly */}
<main className="flex-1 p-6">{children}</main>
</div>
);
}Zero-Boilerplate Type-Safe Routing
Eliminate dead links, catch route typos at compile time, and get instant IDE autocompletion for routes, parameters, parallel slots, and relative navigation.
Instant IDE Autocomplete & Dead-Link Prevention
Dinou generates TypeScript route definitions in real time. Your IDE autocompletes static routes, dynamic [param] patterns with validated params, and strict relative targets inside <Link> and useRouter().
<Link href=" or to=" to autocomplete static routes, [param] patterns, and relative targets._folder flags broken links immediately.to="/blog/[slug]" enforces a typed params object and URL-encodes segments safely.import { Link, useRouter } from "dinou";
export default function Navigation() {
const router = useRouter();
return (
<nav className="flex gap-4">
{/* ✅ Instant autocompletion of static & dynamic routes */}
<Link href="/docs/routing">Routing Guide</Link>
<Link to="/blog/[slug]" params={{ slug: post.slug }}>View Post</Link>
{/* ✅ Strict relative paths with from, queries & hashes */}
<Link href="/demo?tab=settings#profile">Settings</Link>
<Link from="/docs/routing" to="../navigation">Navigation</Link>
{/* ❌ TypeScript error in IDE on invalid/dead links */}
{/* <Link href="/unknown-route">Broken Link</Link> */}
<button onClick={() => router.push("/docs/api-reference")}>
API Reference
</button>
</nav>
);
}Static by Default. Incremental at Scale.
Every route compiles to pre-rendered HTML and Flight payloads by default. Seamlessly scale with build-time SSG, time-based ISR, on-demand ISG, and tag-based cache purges.
Maximum Velocity with Zero Component Re-Execution
Dinou is Static by Default: static routes compile into HTML and React Flight wire payloads at build time automatically, while getStaticPaths pre-renders specific pages on dynamic routes for instant delivery.
import type { RouteParams } from "./dinou";
// 1. Pre-render known slugs at build time (Static by default)
export async function getStaticPaths() {
const posts = await db.posts.findMany({ select: { slug: true } });
return posts.map((post) => post.slug);
}
// 2. Fetch post data at build time and pass as props to page.tsx
export async function getProps(params: RouteParams) {
const post = await db.posts.findUnique({ where: { slug: params.slug } });
return { post };
}Three-Dimensional Layered Segmentation
Eliminate all-or-nothing caching. Dinou breaks rendering and caching into independent horizontal, vertical, and temporal (PPR) dimensions for ultra-fast, granular web applications.
Decoupled Layout ISR with Persistent Navigation State
Layouts can declare their own data fetching and revalidation rules via layout_functions.ts. Changing routes never re-renders cached parent layouts, keeping media playback and search inputs alive.
// Independent layout caching: Shell cached for 1 hour
export const revalidate = 3600;
export const getCacheTags = ["dashboard-shell", "nav-links"];
export async function getProps() {
const navStats = await fetchGlobalStats();
return { navStats };
}Universal Middleware & Webhooks. Zero SSR Overhead.
Configure global runtime behavior, intercept webhooks, inject request contexts, and enforce security policies with standard Web APIs in dinou.config.ts.
Short-Circuit Webhooks with Zero SSR Overhead
Handle high-frequency webhooks (Stripe, Clerk, GitHub) directly at the HTTP layer. Returning a standard Web Response short-circuits the request pipeline and completely bypasses React component rendering.
import { defineConfig } from "dinou";
export default defineConfig({
plugins: [
{
name: "stripe-webhooks",
async onRequest(request, context) {
// Fast-path webhooks: short-circuit before React renders
if (context.req.path === "/api/webhooks/stripe") {
const signature = request.headers.get("stripe-signature");
const payload = await request.text();
await stripe.events.verify(payload, signature);
// Returns pure Web Standard Response in < 2ms
return Response.json({ received: true }, { status: 200 });
}
},
},
],
});Lightning-Fast Developer Experience. Instant Iteration.
Built from scratch for ~260ms E2E Hot Module Replacement (HMR), 2.09s dev cold starts, 6.5s production builds, and instant terminal feedback.
Instant HMR That Never Drops Component State
Dinou's custom WebSocket HMR server and React Refresh integration patch updates from file save to live browser DOM seamlessly. Active form fields, counters, and scroll positions stay perfectly intact.
"use client";
import { useState } from "react";
export function Counter() {
// ✅ State is 100% preserved during live component editing!
const [count, setCount] = useState(42);
return (
<div className="flex items-center gap-4 p-6 rounded-2xl bg-slate-900 border border-slate-800">
<span className="text-3xl font-bold font-mono text-amber-400">{count}</span>
<button
onClick={() => setCount((c) => c + 1)}
className="px-4 py-2 bg-amber-500 hover:bg-amber-400 text-slate-950 font-semibold rounded-xl transition-colors"
>
Increment
</button>
</div>
);
}Choose Your Bundler. Swap Whenever You Want.
Never be locked into a single proprietary compiler. Dinou supports pre-configured, zero-config pipelines for the three premier JavaScript bundlers.
esbuild
Instant Local Development
2.09s dev cold starts, ~260ms E2E HMR feedback loops, and 6.5s full production builds.
Rollup
Pristine ES Module Output
Surgical code-splitting and dead-code elimination. The optimal choice for Cloudflare Workers and edge runtimes.
Webpack
Maximum Package Compatibility
Universal CommonJS/ESM npm package compatibility, dedicated vendor-react chunk splitting, and battle-tested enterprise tooling.
Identical Dual-Bundle & React Compiler Parity Across All Three Engines
Swap bundlers anytime with full Tailwind v4, React Compiler, and Dual-Mode Vendoring (31 pre-bundled vendors or -u) parity.
Eject Anytime. Own Your Entire Stack.
Zero vendor lock-in. A single command extracts Dinou's complete compiler, server runtime, and React 19 flight pipeline directly into your project.
Web Standards request pipeline, Flight serializer, PPR, ISR, and router.
Native entrypoints for Cloudflare Workers, Netlify, Bun, Deno, and Node.js.
Pre-configured Dual-Bundle client and server build pipelines.
Zero-fork dev server with WebSocket HMR and AOT target builders.
31 pre-bundled toolchain packages for instant cold starts (or bypass via -u).
Freedom to Evolve Your Architecture
Zero Lock-In & 1-Command Uneject
Ejecting is never a one-way door. Inspect or customize your stack freely, and run npm run uneject anytime to return cleanly to node_modules/dinou.
Custom Server & Middleware Control
Add custom HTTP headers, edge telemetry, WebSockets, or caching policies directly inside your server loop with standard Node or web APIs.
Built for Modern AI Workflows
AI coding assistants can inspect and modify your exact compiler and streaming code directly, eliminating black-box roadblocks.
Engine Architecture. Engineered for Pure Performance.
Dinou is built from the ground up on Web Standards and React 19. A unified in-process engine with direct memory streaming, low and predictable memory usage, and zero subprocess overhead.
Dinou CoreModern AOT
Streamlined & UniversalBuilt as a unified in-process engine using native W3C Web Streams and React 19 standards. Server Components (RSC) and SSR stream directly in memory with instant response times and zero subprocess overhead.
| Architectural Dimension | Dinou Implementation |
|---|---|
| RSC & SSR Architecture | Native in-process streaming via React 19 Web Streams |
| Runtime Standards | 100% W3C Web APIs (Request, Response, ReadableStream) — zero Express |
| Process & Memory Model | Single-process unified engine with low memory usage (275 MB idle / 492 MB peak @ 200 conns) |
| Deployment Flexibility | Universal: Cloudflare Workers, Netlify v2, Bun, Deno, Node.js, native binaries & Static Export (SSG) |
| Dev Server & DX | In-memory 0-fork compilation (~2.09s cold start, ~260ms E2E HMR, 6.5s prod build) |
| Rendering & Caching Model | 3D Layered Segmentation (PPR, layout_functions & <DinouCacheSlot>) |
| State Persistence on Navigation | Persistent nested layouts across sibling transitions (zero layout remounting) |
Ready to build without boundaries?
Experience the power of React 19 Server Components, Streaming SSR, and Server Functions with total freedom of infrastructure.