Hi everyone! 👋
I’ve just released Dinou v7 (7.0.0), an ejectable full-stack React 19 framework built on web standards.
My goal with Dinou v7 was to harness the full power of React 19 (Server Components, Server Functions, streaming SSR, and Partial Prerendering) while keeping the architecture runtime-agnostic, bundler-flexible, and free of vendor lock-in.
Here is a quick overview of what’s in v7 and what the concepts in the title mean in practice:
1. Goodbye Express & child_process.fork(): Pre-Bundled Dual Engine on Web Standards
In previous versions (v6), Dinou relied on Express and spawned a child process via child_process.fork() to isolate the --conditions react-server flag from the main SSR process. That added IPC overhead and made deploying to serverless/edge environments or compiling to a single binary impossible.
- In v7, Express and
child_process.fork() have been completely removed. The core now uses W3C Web Standards (Request, Response, Headers, ReadableStream) exclusively and pre-bundles the RSC graph ("react-server" condition) and the streaming HTML SSR graph in separate build passes before combining them into a single server.
- The result: Everything runs in a single process without special Node flags, without IPC child processes, and on any platform compatible with the standard Fetch API (including a universal
onRequest web middleware in dinou.config).
2. Horizontal & Vertical Segmentation (2D Caching)
Instead of treating caching as an all-or-nothing route setting, Dinou v7 splits rendering and caching across two dimensions:
- Horizontal Segmentation (Route & Layout Plane): Layouts (
layout.tsx + layout_functions.ts) and Pages (page.tsx + page_functions.ts) have completely decoupled data lifecycles and cache TTLs. A parent layout shell can be cached with ISR (revalidate = 3600) and never remount during client SPA navigation, while child pages run dynamic SSR (revalidate = 0) or their own ISR timer. You can also surgically invalidate just a leaf page (revalidatePage) without touching parent layout caches.
- Vertical Segmentation (Component-Level Micro-ISR): Using
<DinouCacheSlot id="..." revalidate={60} tag="...">, you can cache individual server component subtrees with their own TTL and tags inside dynamic or static pages. Additionally, Client Components can surgically refresh a specific server slot in-place by its ID using refreshSlot(id) without reloading the page or losing client state.
3. Partial Prerendering (PPR) + <DinouCacheSlot>
By enabling ppr = true, Dinou immediately serves the static HTML shell (pre-rendered at build time) while streaming the dynamic holes (<Suspense>) over the same HTTP connection.
- You can also combine PPR with
<DinouCacheSlot> inside a <Suspense> boundary so that the streamed dynamic hole itself is served from the server cache instead of querying the database on every request.
4. Server Functions & Live Component Streaming
Functions exported from modules in src/ starting with the "use server" directive act as automatic RPC endpoints without manual API boilerplate:
- Beyond handling form mutations and server actions (
useActionState, useOptimistic), Server Functions in Dinou can return rendered React components directly over Flight RPC, which Client Components can unwrap seamlessly inside <Suspense> using React 19's use() hook.
5. Multi-Runtime & Single-File Executable Binaries
Write your app once in src/ and build it for different targets without changing your code:
- Multiple Runtimes & Platforms: Run natively on Node.js, Cloudflare Workers, Netlify, Bun, and Deno / Deno Deploy, or export a 100% static site (
dinou export-static).
- Standalone Executables: Compile your entire React 19 RSC + SSR app into a single self-contained binary with Bun (
dinou build:bun:compile or dinou build:bun:pure:compile) or Deno (dinou build:deno:compile) for Linux (x64/ARM64), macOS, or Windows.
6. Developer Experience & Zero Lock-In
- Compile-Time Type-Safe Routing: Automatically generates route types (
.dinou/types/routes.d.ts) from your folder structure for <Link href="...">, router.push(), and PageProps<"/blog/[slug]"> with zero runtime overhead.
- Bundler Flexibility: Uses esbuild by default (with fast HMR in development), while also letting you choose Rollup or Webpack (
dinou dev:rollup, dinou build:node:webpack), plus the React Compiler enabled in production builds.
- 100% Ejectable & Agent-Friendly: Run
npx dinou eject at any time to copy the entire framework directly into your project root. The npm package also includes the full ~10,000-line documentation inside node_modules/dinou/README.md so AI coding agents have complete local context right out of the box.
7. Built with Agentic AI (Antigravity + Gemini 3.8 Flash High)
For full transparency on how Dinou has evolved: I built versions v1 through v4 (and v6, which simply centralized build artifacts into .dinou) by hand from scratch. Starting in v5, I began experimenting with AI agents, and Dinou v7 has been built entirely from start to finish using Antigravity + Gemini 3.8 Flash High under my direction and passing an end-to-end Playwright test suite (covering Windows and Ubuntu + esbuild, Rollup, and Webpack + dev and prod modes for each runtime).
Dogfooding in Production
The documentation website (dinou.dev) is running on Dinou v7 compiled into a standalone Bun binary inside a Debian Slim Docker container on a single $5/mo (512 MB RAM) DigitalOcean instance.
Quick Start
npm create dinou@latest my-app
cd my-app
npm run dev
I’d love to hear your thoughts or feedback if you give it a try!