KASTRICK / PROJECTS
Two runtimes. Different boundaries.
Nextjs Engine focuses on how interface work is compiled, rendered and scheduled. RBE focuses on how backend authority, services and infrastructure are executed. They are separate projects that can complement each other without pretending to be one giant framework.
FAST ORIENTATION
FRONTEND / RUNTIME
Nextjs Engine
BACKEND / SERVICES
RBE — Rust Backend Engine
Both are active development projects with live documentation. Nextjs Engine Gen 3 is currently an alpha line; RBE documents unfinished areas explicitly rather than presenting them as complete.
CHOOSE BY PROBLEM
Start with what you need to control.
The project names make more sense after the boundary does. Pick the problem first; the deeper implementation details can come second.
I want schema-driven React/Next.js pages with less unnecessary browser work.
Compile static/server/client ownership, keep durable content server-first, and schedule expensive client work deliberately.
NEXTJS ENGINE
I need SEO, Markdown, navigation, debugging and compatibility to share the page model.
EngineSEO, server-first EngineMarkdown, EngineScroll and the dev-only EngineDebug workbench live in the Gen 3 runtime/tooling line.
NEXTJS ENGINE
I need backend source files to have explicit authority instead of ambient access.
REL roles separate HTTP routes, reusable modules, managed services and whole-server policy; RELC validates those boundaries before execution.
RBE
I need managed backend services, fast existence filters or recoverable infrastructure.
RBE's Service Runtime, quickDB, Video Manager and Cloud Node sit behind explicit runtime authority instead of becoming random application helpers.
RBE
FRONTEND COMPILER + RUNTIME
Nextjs Engine
Generation 3 compiles schema into an execution plan for React 19 and Next.js 16. Static/server content stays server-first where possible, interactive branches become targeted client work, and runtime systems share scheduling, compatibility and developer diagnostics.
AUTHOR WITH
Page schema + Engine components
COMPILES TO
Static / server / client / deferred ownership
CURRENT TOOLING
EngineSEO · EngineMarkdown · EngineDebug · EngineScroll
PHASE D
D.1–D.22 implemented on main-3
BACKEND RUNTIME / RUST
RBE
RBE is a controlled Rust backend runtime built around REL/RELC, immutable Runtime Images, explicit capability boundaries, managed Service processes and supervised infrastructure. Its documentation distinguishes implemented behavior from areas still evolving.
AUTHOR WITH
.route · .module · .service · server.server
LINK WITH
RELC authority validation + compilation
RUNTIME SYSTEMS
Service Runtime · Container/WASM · Runtime Images
SUBSYSTEMS
quickDB · Video Manager · Cloud Node
SIDE-BY-SIDE
Same philosophy. Different layer.
Both projects try to make runtime behavior explicit before it turns into hidden browser or server work. The mechanism and execution layer are different.
NEXTJS ENGINE
Generation 3
RBE
Rust Backend Engine
UI execution
Schema compilation, rendering ownership, client islands, scheduling and browser-facing runtime systems.
Backend execution
Authority-scoped REL programs, managed services, Runtime Images, container execution and infrastructure.
compilePage
Produces a deterministic page plan including runtime ownership, work class, used capabilities, assets and diagnostics.
RELC
Validates source authority, links REL programs and participates in compiling the backend application/runtime image.
EngineDebug
Development-only /_engine/debug workbench with route preview, compiler-node picking, runtime overlays, scheduler inspection and viewport simulation.
Docs + runtime status
Canonical RBE docs expose source roles, subsystem boundaries, error codes and current incomplete/evolving areas.
Gen 3 alpha
Actively developed; current main-3 includes the Phase D hardening/debug work described in its live documentation.
Active development
Core runtime and subsystem work is live, with some areas explicitly documented as partial or evolving.
HOW THEY CAN FIT
Complementary, not coupled.
A project can use Nextjs Engine without RBE, or RBE without Nextjs Engine. When both make sense, they occupy different boundaries instead of competing for the same job.
NEXTJS ENGINE
Page schema → server/client execution plan → interface
→
APPLICATION API
Your HTTP/application contract remains the boundary between the two projects.
→
RBE
REL/RELC → scoped backend authority → services/infrastructure