Roadmap & status

An honest map of what the framework does today and what's still ahead. The bar for "shipped" is high: implemented, tested, and running on this very site. The guiding principle is win by subtraction — match the capabilities of Next, Vue, and Svelte without a bundler and without a single runtime dependency.

Shipped

• Single static binary, pure std, zero runtime dependencies.
• HTTP/1.1 server — request/response, thread pool, connection upgrade, request

bodies, middleware chain.

• WebSockets (RFC 6455) and Server-Sent Events — from scratch.
• JSON value/parser/serializer; template engine (SSR, if/for/include,

HTML-escaping); Markdown → HTML, with live component previews in docs.

• Embedded database — crash-safe copy-on-write B+tree, atomic commits.

Storage.

• SQL — a from-scratch lexer + parser (SQL) and an

executor that runs CREATE TABLE, INSERT, and SELECT (with WHERE/ORDER BY/LIMIT) over the B+tree and persists. SQL executor.

• Auto-generated REST API — declare collections in collections.toml; get

CRUD endpoints, validation, and a self-describing /api/_meta with no handler code. Collections & auto-API.

• Semantic search — ?search= ranks records by embedding similarity against

any OpenAI-compatible endpoint, with substring search as the fallback. Semantic search.

• Auth & sessions — cookie-based login, a protected page, and logout, on the

storage engine. Auth.

• Dynamic routing — declarative routes.json, :param/*wildcard, params in

templates. Routing.

• Layouts — shared shell templates that wrap pages, composed per route.

Layouts.

• Per-route data loaders — a route names a JSON file whose contents feed the

template. Data loaders.

• Form actions — POST bodies, validation, Post/Redirect/Get, durable

persistence. Forms.

• Client reactivity — a tiny signals + directives runtime in native ES

modules, no build step. Reactivity.

• SSR islands / hydration — server-render, then hydrate only the regions you

mark, seeded from server state with no flicker. Islands.

• Client-side SPA router — link-intercept + content swap with View

Transitions, progressive enhancement. SPA router.

• Middleware — security headers, logging, timing, custom layers.

Middleware.

• SEO — sitemap.xml, robots.txt, per-route metadata. SEO.
• Dev live-reload over SSE, plus akurai update self-update and a

one-line curl … | sh installer. CLI · Updating.

• A documented design system and component catalog. Styling.
• Atomic CSS engine — akurai serve/dev scans your markup and emits a

utilities.css of only the classes you use (regenerated live in dev). Styling.

• Asset pipeline — static assets are fingerprinted and minified, served with

immutable long-cache headers. Asset pipeline.

• Admin UI — a built-in /admin to browse, create, edit, search, and delete

records in any collection through the auto-API. Admin.

• SQL writes — the executor now runs UPDATE and DELETE (with WHERE) in

addition to CREATE/INSERT/SELECT. SQL executor.

• Relations — a relation field references another collection by id, with

?expand= to inline the referenced record. Collections.

• File uploads — multipart/form-data uploads into a content-addressed blob

store, a file field type, and a download endpoint. Uploads.

• Typed client SDK — a generated, JSDoc-typed JS client built from

/api/_meta (the tRPC analog), no build step. Client SDK.

• Static generation + ISR — mark a route prerender/revalidate; rendered

HTML is cached in the storage engine and incrementally regenerated (stale-while-revalidate). SSG.

• Internationalisation — per-locale message catalogs, a {{ t }} template

helper, and Accept-Language negotiation. i18n.

• Error & loading boundaries — a navigation progress bar and a withBoundary()

helper with retry for async data. Boundaries.

• AI chat UI + tool-result components — native-ESM chat primitives, streaming

assistant endpoint, generative UI runtime, receipts, approvals, input flows, progress cards, artifacts, media, and a live gallery. AI components.

Planned — AkurAI-RustAgent agent OS

• Hermes-style channel parity — preserve analysis, commentary, final,

tool-call/result, approval, question, edit, artifact, system, and error events in the web timeline instead of flattening them into plain chat.

• Agent asks and confirmations — show approvals, option lists, question flows,

sliders, preferences, and edit previews as typed components that send receipts back to RustAgent. AkurAI-RustAgent OS UI.

• Durable workspace panes — expose memory, notes, passvault, cron, kanban, and

curator state as tenant-scoped sidebars and context panes.

Planned — frontend platform (vs Next / Vue / Svelte)

• Lazy routes / code splitting — per-route JS via native import() + a route

manifest.

• Image optimisation and streaming SSR.

Planned — the data engine (PocketBase-style)

• SQL — the rest of the engine — a query planner, joins, indexes, and

transactions on top of today's executor.

• Migrations for evolving collection schemas.
• Enforced performance budgets as a release gate.

Following along

Every shipped item lands with its docs in the same commit, and the Changelog records each release. This page is the high-level view; AGENTS.md in the repository is the contributor-level map.