Skip to content

Status and roadmap

This page lists what the current code does, what parts of the design are not in this release, and the limitations you should plan around. It is written for operators deciding whether the runtime fits their workload, and for developers who want to know what to expect.

Release state

The current version is 0.1.0. There is no tagged release yet: the changelog tracks the work by date. The runtime is a single node.

What works in this release

Area What you get Read more
Deno executor TypeScript and JavaScript in a fresh V8 isolate per task, frozen clock, CPU/memory/wall limits; opt-in warm isolate reuse; streamed request and response bodies; WebAssembly inside JS with memory counted against the task Execution and isolation, Deno guide
WASM executor WASI Preview 2 components exporting wasi:http/incoming-handler, a fresh wasmtime instance per task, opt-in instance reuse, warm pool of pre-created instances, streamed responses, full-std Rust components WASM guide
Platform APIs Deno: std:kv, std:sql, std:sqlite (bun:sqlite), std:blob, std:queue, std:services (typed RPC), std:sdk (operator SDKs run by the runtime). WASM: std:host/{log,kv,sql,blob,queue,call,sdk,…} (RPC both ways) Guest API, WIT
Triggers HTTP (/s/{slug}/…, custom hosts, {slug}.{base_domain}), interval and cron schedules, durable queue with retries and a dead-letter queue, in-process service calls with environments and allowed callers Triggers, Service calls and queues
Storage Per-service KV (with atomic kv.incr counters), SQL (SQLite, async std:sql and synchronous std:sqlite) and blob storage on local disk; environment variables; AES-256-GCM sealed secrets; SQL export per service Storage
Builds and deploys Lazy (first request) or eager builds; npm: and jsr: resolved at build time through esm.sh with an rt.lock per version; immutable versions, instant rollback, auto-rollback when a lazy build fails Services, versions and builds
Scheduling Go-style scheduler over all cores; requests over capacity wait in a queue instead of getting 429; adaptive per-service concurrency between min_instances and max_instances; warm pools that follow demand; profiles max_density, balanced, min_latency Scheduler and autoscaling
Caching Three tiers (memory, disk, source) with cost-aware eviction, integrity-checked disk cache, preload of hot services Caching
Tenancy and security Plans with quotas and limit maxima, projects and environments, scoped tenant API keys (self-service with keys:write), per-service access, ingress and egress rules (the resolved client IP is passed to handlers as ctx.client.ip), SSRF guard, audit events, custom hosts verified by DNS TXT record or operator approval, master key rotation Tenants, plans and keys, Security model
Operations One container and one volume, Prometheus metrics, health and readiness probes, live logs over SSE, per-service stats, drain, rt.toml with profiles and environment overrides, OpenAPI 3.1 with a Scalar UI, the 21ci CLI, an MCP server for AI assistants Production deployment, Observability
Samples Runnable Deno and WASM examples and five sample apps (Telegram bot, event sign-ups, live queue, currency rates, edge gateway) Tutorials

New in this release

Feature What it adds Read more
Projects and environments Every tenant has projects (a default one to start); a project lists its environments and each service lives in one project and one of its environments Projects and environments
Self-service tenant tokens A tenant key with the keys:write scope creates, lists and revokes keys of its own tenant (/v1/keys, 21ci token), never with more scopes, projects, environments or lifetime than itself Get access
MCP server A Model Context Protocol endpoint (POST /mcp) on the control listener, authenticated with a tenant key, so AI assistants such as Claude Code, Cursor and Claude Desktop can manage services AI assistants (MCP)
Instance bounds Per-service scaling.min_instances (kept warm, no scale to zero) and scaling.max_instances, bounded by the plan's max_instances; a trend-aware autoscaler Scheduler and autoscaling
Synchronous SQLite std:sqlite (also importable as bun:sqlite): the service's SQLite database with bun's synchronous API, next to the async std:sql Sub-services
WebSockets and durable objects std:sockets (sockets held by the node, one task per event, tags, attachments, auto-response, sockets that survive deploys), std:durable (one object per name with storage and an alarm), an outbound WebSocket client; the same in WASM (std:host/sockets, durable, ws-client, socket-handler) WebSockets and durable objects

Not in this release

These parts of the design are deferred or replaced. Items marked planned are expected in a later release; the others are explained in the last column.

Item State in this release What to do instead
Supervisor/executor process split planned One process; --role=all is the only role. The master key and decrypted secrets share the process with tenant code Treat the node as one trust domain; run separate nodes for tenants that must be strictly separated
V8 sandbox (custom V8 build) planned Prebuilt V8 without the sandbox; GET /v1/node/status reports v8_sandbox: false; security.require_v8_sandbox must be false Do not mix mutually hostile tenants with sensitive operator data on one node
seccomp filter and Landlock Not planned for now. security.seccomp = true applies PR_SET_DUMPABLE=0, NO_NEW_PRIVS and RLIMIT_CORE=0 on Linux only Use container hardening: non-root user, cap_drop: ALL, no-new-privileges (the compose file sets these)
S3 backends for artifacts and blobs planned Local disk only; [s3] and storage.blob_backend are accepted but unused Put the data volume on storage you back up
OTLP trace export planned [otel] is accepted; nothing is exported Prometheus metrics, service logs, server-timing and traceparent headers
libSQL SQLite through rusqlite, same file format Nothing; the std:sql API is the same
WASM pre-initialization at build time planned Components run their start-up code on every fresh instance Turn on wasm.reuse_instances for components with heavy start-up (for example language runtimes)
Streamed bodies for WASM blob and call APIs planned std:host/blob and std:host/call bodies are buffered Keep those bodies small; HTTP responses already stream
Per-service V8 snapshots planned Not built: top-level code runs on every fresh isolate Turn on deno.reuse_isolates to run top-level code once per isolate
Weighted traffic split and canaries planned One live version per service Test on a separate staging service, then make the new version live; rolling back is one call
Multi-node, clustering, high availability Not in v1 (see non-goals) Restart policy, health checks and backups on one node

Known limitations

These are properties of the current code that can surprise you. Most have a workaround.

Deno throughput with the default configuration. Every request creates a fresh V8 isolate. That fixed CPU cost per request, not your handler, bounds how many requests per second a core can serve. Warm reuse (deno.reuse_isolates, on by default in min_latency) removes that cost. See Performance characteristics and Performance tuning.

npm coverage. npm: packages are built by esm.sh for an ES2022 target. node: imports in your own code are rejected at deploy, and Node built-ins exist only as far as esm.sh polyfills them, so packages that need node:net, node:fs, child_process and similar do not work. How many of the common API SDKs (openai, stripe, axios, pg, …) work has not been measured yet; a Node compatibility layer is an open decision. Test your dependencies before you commit to them.

Storage-heavy services share one thread pool. Storage calls (SQL, KV, blob files) run on a shared pool. Under contention one tenant holds at most floor(blocking_share × threads) of its threads (plan key blocking_share, default 0.25); when threads are idle, a busy tenant may borrow them, always leaving one free. For nodes with few, storage-heavy tenants, raise blocking_share in the plan or blocking.threads. See Scheduler and autoscaling and Configuration.

Frozen clock. Date.now() and performance.now() do not advance during synchronous code, so code that times its own CPU work measures 0 ms. This is a security measure; security.clock = "coarse" is the escape hatch for nodes that need it.

Single-process blast radius. All tenants share one process and one memory pool. A crash or an engine vulnerability affects every tenant on the node. Executor sharding for tenant groups is a paid capability (see About).

Control and metrics listeners have no access control of their own. Keep them on loopback or a VPN, and put TLS and a reverse proxy in front of the public listener only.

Backups need a stopped node or SQLite's backup command. A hot file copy of the databases is not consistent. Drain (POST /v1/node/drain) is one-way: restart the node to accept traffic again.

WebSockets live on one node. The node holds every socket; a node restart drops them (clients reconnect, durable storage and alarms stay). No WebSockets over HTTP/2 and no permessage-deflate. Outbound sockets close when the task that opened them ends. See WebSockets and durable objects.

Open questions

Decisions that are still open, with the behavior that applies until they are answered:

Question Current behavior
A Node built-ins subset (node:buffer, node:events, …) Only what esm.sh polyfills
Priority classes in run queues (latency-critical vs batch) None; choose a profile per service
Periodic process recycling to reshuffle memory against slow side-channel attacks Off
Disallowing eval and new Function Allowed, because many libraries compile validators at runtime
Built-in backups to S3 Operator's responsibility; per-service export exists

Non-goals for v1

These are out of scope for the first version by design, not missing work.

Non-goal Note
Hosted SaaS, multi-region, multi-node clustering, high availability One node; the data layout keeps a later cluster possible
Web console A paid management feature. The REST API, OpenAPI and the 21ci CLI are the interfaces
Full Node.js compatibility, native addons npm through esm.sh builds only
Email triggers Not a trigger kind
Module state that survives across Deno requests by default A fresh isolate per task is the default; reuse is an opt-in cache, not a guarantee
Built-in TLS or ACME Terminate TLS in your reverse proxy
Billing Usage counters exist for quotas only
Process-per-tenant sharding, KMS, SSO/RBAC, durable audit log Paid editions

See also

  • Changelog: what changed and when.
  • FAQ: short answers about isolation, cold starts, scaling and operations.
  • Security model: what each isolation layer does today.
  • Isolation compared: what this runtime gives up and gains against containers, microVMs and VPSes.