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.

Public betaLast updated: October 2026Target: v1.0

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.

In progress

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.

Runtime policy. There will be no second React island runtime. React 19 support means source-level semantics plus a tested Preact compat surface, with documented divergences for compiled packages.
Live matrix. The source, island, and SSR status for every surface is published in the compatibility matrix, with its test references and known divergences.

Phases

  1. R1Complete

    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.

  2. R2Complete

    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.

  3. R3Complete

    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.

  4. R4Complete

    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.

  5. R5v1 gate

    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.

Complete

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_diagnostics with stable codes and fixes
  • apply_patch, batch_edit, and undo
  • search_project, read_files, and impact
  • run_task for 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
  1. M1Complete

    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.

  2. M2Complete

    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.

  3. M3Complete

    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.

  4. M4Complete

    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.

  5. M5Complete

    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.

Beta

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

  1. N1Complete

    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.

  2. N2Complete

    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.

  3. N3Complete

    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.

  4. N4Complete

    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.

  5. N5v1 gate

    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 deploy refuses 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.