Gen 3 mapStart here Why NE Execution model Inspect + debugDocumentation Get source

NEXT.JS ENGINE · GENERATION 3 · 3.0.0-alpha.0

Compile the page. Inspect the plan. Ship less browser work.

Generation 3 turns typed schema into a deterministic execution plan: durable content stays server-first, browser work becomes targeted islands, shared scheduling controls expensive runtime work, EngineSEO owns crawler output, and EngineDebug now exposes the plan during development.

Download Gen 3

Read Gen 3 docs

Default download: main-3 source · ▾ exposes main-3-package and main-2-package

Compiler · Server-first · Scheduler · EngineDebug · EngineSEO · EngineMarkdown · NENC · Compatibility

CURRENT MAIN-3

Phase D is complete, and EngineSEO now keeps sitemap dates honest.

EngineDebug D.5–D.10 completes the development workbench, while the newest EngineSEO update gives automatically discovered static routes trustworthy per-route Git modification dates instead of stamping every sitemap entry with a fake build time.

PHASES A–C COMPLETE · PHASE D D.1–D.22 COMPLETE

During next dev, /_engine/debug exposes the route explorer, live preview, compiler-node picker, STATIC/SERVER/CLIENT/DEFERRED overlay, scheduler transition feed and device simulator. Production removes the generated route before route discovery; CI verifies the workbench is absent from production output.

ENGINESEO UPDATE · automatic sitemap lastModified defaults to Git history · explicit CMS/content dates win · unknown dates are omitted · build timestamps are opt-in

Read EngineSEO →Read Phase D hardening →

CURRENT MAIN-3

The project page follows the Engine that actually exists.

D.5–D.10 are merged on main-3. EngineDebug joins the existing compiler, compatibility, SEO and Markdown work instead of remaining a roadmap placeholder. The documentation bridge reads main-3 directly, so the detailed reference stays tied to the repository.

ENGINEDEBUG

Development gets a real workbench.

The dev-only /_engine/debug route combines route exploration, same-origin preview, compiler-node inspection, runtime-boundary overlays, scheduler state and device simulation.

D.5–D.10 complete · generated in dev · absent from production

Read the current docs →

ENGINESEO

SEO is part of the schema.

EngineSEO bridges Engine schemas into Next.js metadata, canonical/OpenGraph/Twitter output, verification, sitemap/robots routes, safe JSON-LD and social previews.

custom image · generated ImageResponse · website screenshot preview

Read the current docs →

ENGINEMARKDOWN

Markdown stays server-first.

The safe CommonMark/GFM AST handles tables, task lists, images, nested formatting, fenced and indented code, blockquotes and deterministic heading anchors while raw HTML stays disabled.

schema Markdown → EngineServerRenderer → semantic markup

Read the current docs →

PHASE D

Compatibility is explainable and measurable.

Used-feature manifests, ordered fallback plans, inspector metadata, incremental artifacts, budgets, security diagnostics, tree-shaking proofs and browser/device/network test matrices now sit alongside EngineDebug.

D.1–D.22 complete on main-3

Read the current docs →

PHASE D.5–D.10 · ENGINEDEBUG

The execution plan finally has a workbench.

EngineDebug is generated only during next dev. It lets developers explore application routes, inspect the compiler decision behind rendered nodes, watch scheduler state, and simulate viewport capabilities without turning the debugger into a production endpoint.

DEVELOPMENT WORKBENCH

npm run dev ↓ /_engine/debug ├─ route explorer + same-origin preview ├─ compiler-node picker ├─ STATIC / SERVER / CLIENT / DEFERRED overlay ├─ live scheduler tasks + transition history └─ Desktop / Tablet / Phone / Custom simulator next build ↓ generated debug route removed ↓ production output contains no EngineDebug endpoint

Read Phase D implementation →

D.6

Route explorer + live preview

Discovers App Router and Pages Router pages while excluding private framework paths and the debug route itself.

D.7 + D.8

Node picker + boundary overlay

Inspect compiler id/path, runtime reason, hydration, capabilities and rendered STATIC, SERVER, CLIENT or DEFERRED boundaries.

D.9

Scheduler inspector

Shows live VISIBLE/RUNNING, NEAR/PRELOADING, SLEEPING and DEFERRED work with bounded transition history and frame pressure.

D.10

Device + viewport simulator

Desktop, tablet, phone and custom profiles model viewport, DPR, refresh target, touch/hover, orientation and VisualViewport availability.

PRODUCTION ABSENCE GUARANTEE

EngineDebug is not protected by pretending a hidden production route is safe. The plugin removes its generated route before production route discovery, cleans stale development route types, and CI proves the debug route/workbench do not enter the production output.

CURRENT API + TOOLING SHAPE

Author declaratively. Resolve early. Inspect what remains.

EngineSEO and EngineMarkdown push more work into deterministic server output; EngineDebug explains compiler/runtime decisions during development without becoming production surface area.

ENGINESEO · PAGE SCHEMA

const seo = EngineSEO.create(pageSchema); export const generateMetadata = seo.generateMetadata; export default createPage(pageSchema);

The builder can also emit JSON-LD, sitemap/robots helpers and generated or captured social previews.

ENGINEMARKDOWN · GEN 3

Markdown source ↓ CommonMark + GFM AST ↓ EngineServerRenderer ↓ semantic HTML + collected CSS ↓ no Markdown parser island

Direct component imports retain compatibility, while schema Markdown takes the server-first path.

ENGINEDEBUG · DEVELOPMENT ONLY

next dev ↓ /_engine/debug ↓ explore · pick · overlay inspect scheduler · simulate device next build ↓ route removed

Production safety is implemented as absence: the generated debugger is removed before production route discovery and CI checks the compiled output.

GEN 3 EXECUTION MODEL

The browser only owns the work that needs the browser.

compilePage classifies work, records used capabilities and assets, and produces a deterministic plan that rendering, scheduling, compatibility and now EngineDebug can all consume.

01 · COMPILER

One deterministic plan.

Runtime class, priority, capabilities, assets and client boundaries are decided before rendering guesses what to hydrate.

02 · SERVER-FIRST

Durable content stays durable.

Static branches—including schema Markdown—can render to semantic server markup instead of becoming browser work by default.

03 · SCHEDULER

Spend work where it matters.

Critical, visible, near, deferred, idle and sleeping work share pooled visibility and frame-pressure signals.

04 · ADAPTIVE

Device-aware without quality hacks.

Layout and scheduling can adapt while the runtime avoids silently dropping media, Canvas, Shader or geometry quality to chase FPS.

05 · NENC

Private commands stay server-owned.

Opaque commands, device proof, replay protection, permission checks and EngineAPIResolver keep private backend authority off the client.

06 · ENGINESEO

Crawler output from schema.

Metadata, structured data, social previews and crawler routes can share the Engine's typed source of truth.

07 · MARKDOWN

GFM without raw HTML.

A shared AST renderer supports rich Markdown while URL validation and disabled raw HTML preserve the safety boundary.

08 · COMPATIBILITY

Fallbacks follow actual usage.

The feature manifest records only capabilities a page uses; the fallback plan chooses native, fallback or honestly unavailable strategies.

09 · ENGINEDEBUG

See why the plan behaves that way.

Development metadata, boundary overlays, scheduler snapshots and simulated device profiles turn compiler decisions into an inspectable workbench.

LIVE ENGINE DEMOS

The runtime still has somewhere to play.

These scenes exercise the Kastrick integration—navigation, EngineScroll, Transitions+, Canvas, APIStatic and browser state. In a development build, EngineDebug can now inspect the rendered Engine boundaries and scheduled work behind pages like these.

LIVE WEBSITE · MEDINEST

Browse it like a site, not a screenshot.

Navigate Home, Shop, Orders and Refill. Search products, filter categories, add to cart and expand the same live app without losing its state.

01 / 05

https://medinest.store

MEDINEST · SAME-DAY CARE

Care that moves with you.

A complete miniature storefront: browse products, manage refill requests and revisit orders without leaving the demo.

Delivery windowToday · 6–8 PMGandhinagar · 18 min estimate

Popular right now

WellnessDaily Essentials₹149

MedicinesCold & Flu Care₹219

First aidFirst Aid Kit₹399

Care services

Pharmacist chatAvailable from your account

Recurring refillAvailable from your account

Home diagnosticsAvailable from your account

GEN 3 PIPELINE

Schema is the input. The execution plan is the product.

Generation 3 separates authoring, compilation, server rendering, scheduled enhancement, metadata/crawler output, secure runtime work and development-time inspection instead of treating every feature as one browser bundle.

GENERATION 3 PIPELINE

4 LAYERS · ONE EXECUTION PLAN

SCHEMACOMPILESERVERSCHEDULEENHANCE

COMPILER

GEN 3

Plan the page before runtime.

compilePage turns the schema into a deterministic graph of runtime ownership, work priority, assets, capabilities and diagnostics.

compilePage()enginePlanfeatureManifestfallbackPlan

SERVER

GEN 3

Keep durable UI on the server.

Static and server-owned branches render first. Interactive behavior is isolated instead of pulling unrelated content into one client boundary.

server-firstclient islandsserver childrencreateComponent

SCHEDULER

GEN 3

Prioritize useful work.

One shared scheduler coordinates visibility, near-viewport preparation and frame pressure without silently reducing visual fidelity.

6 work statespooled observersframe pressureadaptive layout

SECURE RUNTIME

GEN 3

Put private work behind one boundary.

NENC, EngineCookies, device proofs and EngineAPIResolver provide a server-owned command path while compatibility is compiled from actual feature use.

/_static/commandEngineCookiesdevice prooffallback compiler

DEVELOPMENT + RELEASE TRACK

Development + release track

Current track

Gen 3 development on main-3 is tracked separately from the published release archive, so an alpha branch is never mislabeled as a stable release.

Reading main-3 through NENC…

Compile the page. Inspect the plan. Ship less browser work.

Phase D is complete, and EngineSEO now keeps sitemap dates honest.

The project page follows the Engine that actually exists.

Development gets a real workbench.

SEO is part of the schema.

Markdown stays server-first.

Compatibility is explainable and measurable.

The execution plan finally has a workbench.

Route explorer + live preview

Node picker + boundary overlay

Scheduler inspector

Device + viewport simulator

Author declaratively. Resolve early. Inspect what remains.

The browser only owns the work that needs the browser.

One deterministic plan.

Durable content stays durable.

Spend work where it matters.

Device-aware without quality hacks.

Private commands stay server-owned.

Crawler output from schema.

GFM without raw HTML.

Fallbacks follow actual usage.

See why the plan behaves that way.

The runtime still has somewhere to play.

Care that moves with you.

Popular right now

Care services

Schema is the input. The execution plan is the product.

Plan the page before runtime.

Keep durable UI on the server.

Prioritize useful work.

Put private work behind one boundary.

Current track

We use cookies to make your experience better.