Roadmap
Krate is in public beta. This roadmap is outcome-based: scope and order can change, but the v1 gate does not. Every claim below is tied to a test, a matrix entry, or a migration report.
The v1 bar
Compatibility is a product contract. These four rules decide what ships.
Compatibility is measured
Every claim comes from a public matrix and a corpus of real React and Next.js apps. A feature is supported when it passes, not when it compiles.
Migrations are reversible
Every migration step produces a report, a diff, and a rollback path. Unsupported code is surfaced before files are written.
Agents use the compiler graph
MCP tools operate on routes, symbols, diagnostics, and staged edits rather than guessing from raw text.
Runtime tradeoffs are explicit
Preact is the only island runtime. React 19 support is implemented in the compiler and compat layer for source components, with known limits documented.
React and Preact compatibility
React 18 parity for source components, React 19 source semantics, and production-grade compiled islands.
Today
Source components match React 18 and React 19 in a browser differential against React itself: effects, class lifecycles, error boundaries, events, forms, keys, refs, Suspense, use, and the action hooks. Radix primitives run as Preact islands, and controlled primitives are covered by a real Chromium, Firefox, and WebKit conformance harness.
Target
A published matrix for source, islands, and SSR. React 19 support is implemented in the compiler and compat layer; Preact remains the only island runtime. Unsupported package semantics are diagnosed, never hidden.
Phases
Conformance foundation
Build the corpus and the public matrix that gate every release.
Exit: Corpus includes a shadcn dashboard, the Radix suite, a Next.js app, class components, and forms; CI runs Chromium, Firefox, and WebKit plus the supported Preact versions.
React 18 source parity
Close the remaining semantic gaps for source components: dependency arrays, effect ordering, class lifecycle, error boundaries, events, forms, keys, refs, and Suspense.
Exit: No P0 or P1 divergence in the source-component corpus; failures have actionable diagnostics.
React 19 source semantics
Build the React 19 action hooks (useActionState, useOptimistic, useFormStatus) on top of the server-action transport, plus use, ref-as-prop, and async transitions.
Exit: The React 19 reference app passes the same browser conformance suite as React 18.
Island and SSR parity
Support local components inside islands, SSR island hydration, per-island chunks, island error boundaries, and a shared state bridge.
Exit: A page containing source components, compiled packages, and SSR renders consistently in production and development.
Hardening and release
The version matrix is CI-tested, performance budgets are enforced, diagnostic docs and safe codemods are gated, partial compatibility rows document their divergences, and pnpm check:release verifies the whole contract. The v1 gate closes at release.
Exit: The matrix is green, budgets are enforced, and migration paths have no silent failures.
MCP overhaul
From a collection of tools to an agent workspace over the compiler graph.
Today
krate mcp provides stdio and Streamable HTTP, structured results, transactions, undo, safe codemods, diagnostics, semantic workspace symbols, project search, pagination, progress, resource subscriptions, evaluated agent prompts, run_task, cancellation, a project policy, redacted audit logs, rate limits, and hosted health/metrics.
Target
A hardened MCP workspace with semantic graph operations, automatic diagnostic fixes and codemods, stronger remote operations, and reviewable agent workflows.
New tools
get_diagnosticswith stable codes and fixesapply_patch,batch_edit, andundosearch_project,read_files, andimpactrun_taskfor build, check, test, and typecheck
Acceptance
- In-repo protocol and HTTP conformance suite
- Cancellation, reconnect, and SSE replay tests
- No stdout contamination in stdio mode
- Authenticated HTTP transport
- Structured results and pagination
Protocol and transport
stdio and Streamable HTTP with persistent sessions, bearer auth, structured results, pagination, progress, structured logging, resource subscriptions, cancellation, and SSE reconnect replay.
Exit: The in-repo protocol and HTTP conformance suite passes, including sessions, progress, subscriptions, cancellation, and reconnect.
Security and operations
writeRoots, project policy, localhost binding, bearer auth, redacted JSONL audit logs, secret redaction, HTTP rate limits, host/origin isolation, and /healthz plus /metrics observability are implemented.
Exit: Remote MCP can be offered without exposing project secrets or cross-tenant state.
Safe editing
Source editing, atomic multi-file patches, batch operations, undo, expected-hash conflicts, dry-run previews, writeRoots, diagnostic-linked codemods, and filtered apply_safe_fixes are implemented.
Exit: Every write is atomic or rolled back; concurrent edits are detected and explained.
Workspace graph
search_project and read_files span multi-root workspaces; structured diagnostics and site-graph impact are joined by an incremental semantic symbol index with declarations, imports, exports, JSX references, and workspace_symbols.
Exit: An agent can answer what breaks before editing without reading every file.
Agent workflows
Diagnostic repair, refactor, dependency audit, component scaffold, add-page, publish-content, fix-checks, and explore prompts; run_task for build/check/test/typecheck; and a prompt evaluation suite covering registration, required arguments, defaults, tool order, and safety constraints.
Exit: A complete fix, refactor, and check workflow is reviewable and repeatable.
Migration CLI
krate migrate nextjs turns a Next.js project into a reviewable Krate migration, not a best-effort rewrite.
Command shape
krate migrate nextjs --report migration-report.json
krate migrate nextjs --json
krate migrate nextjs --apply --verify --force --update-package
krate migrate rollback .krate/migrate/nextjs-<timestamp>Dry run is the default. Existing targets require --force, every apply is backed up, and the report lists routes, dependencies, and manual work before anything is written.
What moves
- App/Pages Router routes, layouts, loading, error, API, and middleware
- Links, images, head/metadata, navigation, headers, and dynamic imports
- tsconfig, path aliases, public env, redirects, rewrites, headers, and images
- Package scripts and Krate dependencies
- App-local relative import graphs
What is guaranteed
- A JSON report before any file is written
- Every unsupported construct listed with a diagnostic
- Backups and rollback for applied migrations
- Route inventory with dependencies and per-route status
- No silent drops and no overwrite without a flag
Phases
Inventory and report
Detect Next.js App Router and Pages Router routes, layouts, loading/error boundaries, API routes, middleware, config, NEXT_PUBLIC_* environment values, fonts, and images.
Exit: Dry run writes migration-report.json with routes, dependencies, manual items, warnings, and per-route status.
Routing, shell, and config
Move routes and layouts, rewrite links, images, head/metadata, navigation, headers, dynamic imports, public env, redirects, rewrites, headers, tsconfig, aliases, and package scripts. NEXT_PUBLIC_* values are inlined at migration time.
Exit: Routing, shell, and config migration is covered by unit tests; end-to-end reference-app validation remains N5.
Components and app semantics
next/cache (revalidatePath, revalidateTag, tagged fetch, unstable_cache), async server components, "use client" boundaries, template.tsx, route groups, parallel and intercepting routes, catch-all routes, per-segment not-found and error pages (a client error boundary per directory with reset), and a reworked SPA router with layout persistence are native Krate features the migrator maps onto. A real migrated App Router app runs in the browser conformance suite on Chromium, Firefox, and WebKit.
Exit: A migrated Next.js app with async data, revalidation, client islands, a template, and an intercepting modal passes browser conformance.
Actions, RSC, and route handlers
Server actions, form actions in server components, route-handler params, common next/server helpers rewritten onto the standard Request/Response API (there are no NextRequest/NextResponse classes), server-component error boundaries, out-of-order sibling Suspense streaming, and useParams/useSelectedLayoutSegment(s) are implemented.
Exit: Forms and mutations work without a client-side React runtime; unsupported RSC features are reported. A no-JS action post carries its returned state across the redirect in a flash cookie, but pre-rendered pages do not display it without script.
Verification and rollback
Verification is implemented: krate migrate nextjs --verify builds the migrated app, runs checks, diffs the route inventory and API targets, and keeps the rollback manifest. App Router, Pages Router, and client/dynamic reference apps are covered, and the complex app runs browser conformance. The v1 gate closes at release.
Exit: Three reference apps migrate with build and check green, zero silent drops, and a working rollback.
Serverless and edge status
What runs where today, stated plainly. The same portable server handler serves every target below; it is tested against krate startrequest for request on Node, and the Cloudflare worker has been run in a local workerd. Vercel and Netlify output is validated against the platform file formats and by calling the handlers directly, not by a live deployment.
- Node (
krate deploy --target node): SSR, ISR, streaming, API routes, actions, middleware. No Go binary needed. - Vercel, Netlify, Cloudflare: the same features through one function or worker; caches are per instance.
- Not on serverless: Go API routes, Go components, a custom API sidecar, community plugins with serve hooks.
krate deployrefuses them and points at Docker. - Planned: a shared cache store for ISR and revalidation across instances (the handler already takes an
isrStore).
What else has to be true
These are not side quests. They are the conditions that make the three tracks credible.
Public compatibility matrix
One page listing every surface, its source/island/SSR status, and the exact known divergence. It becomes the support contract.
Corpus and scoreboard
Real applications run on every release. Regressions are release blockers, not issue reports.
Server-rendered islands
Compiled packages render their initial markup with Preact, hydrate in place, and keep local components, error boundaries, and the page signal bridge.
Diagnostics and codemods
Every unsupported pattern gets a stable diagnostic code and, where safe, a codemod. No generic unresolved-component warnings.
Performance budgets
Enforce island JavaScript, hydration time, and route output budgets in CI so compatibility work cannot silently regress the static-first story.
Security and release policy
CSP guidance, remote MCP authentication, migration supply-chain checks, a beta channel, semver, and a documented deprecation policy.
Not planned for v1
- A second React island runtime. Preact remains the only island runtime; React 19 support is compiler and compat work.
- Reimplementing React's reconciler for source components. Krate stays signal-based and reports unsupported semantics.
- Bit-for-bit Next.js parity. The migration targets the common App Router surface, not every experimental feature.
- Native desktop or mobile targets. Those remain separate plans.
- Requiring Node.js to build a Krate app.
- Silent best-effort migrations. Unsupported code is always reported.
Follow the work
Milestones are the source of truth. Compatibility claims and migration reports will link back to the tests that prove them.