Cloud Runtime · Open Source

Run Your Own Cloud Infrastructure.

An open-source runtime that bundles compute, data, edge and auth into one process you fully control. Deploy a folder, get a live service — on your own hardware, with no vendor lock-in.

Start building Explore the platform
Engine is open source ▸9.8 ms cold start ▸no node_modules

Real products running on Kitwork today

KitData Bytecode Kitwork.vn
Scaling model

Scale cloud infrastructure, one node at a time.

No bigger box. No orchestration estate. To scale Kitwork you add a node — the same engine, the same single binary. It joins the mesh, takes its share of the work, and the platform is simply larger. Capacity grows one machine at a time.

Scale up
A bigger box

More CPU and RAM in one machine — until you hit the hardware ceiling, and the single point of failure that comes with it.

Scale out
An estate to operate

Stateless replicas behind a load balancer, an orchestrator, a service mesh, and external state. Capacity grows — so does the machinery you operate.

Scale by node
The Kitwork way

Identical, self-contained engines that mesh over QUIC. The database is the only shared memory, so any node runs any tenant. Add a node to grow; lose one, and nothing precious goes with it.

Built to scale by node — the multi-node mesh is rolling out in phases.

Platform

Separate products.
One platform.

Compute, data, edge and clustering — each a real product, with no glue code between them. Use one, or all of them together.

Compute

Serverless compute

Sandboxed execution of APIs, scheduled tasks and workers. Starts in 9.8ms, bounded by design so no workload can run forever.

app.kitwork.jsGET /api/users
import { router, database } from 'kitwork';
const db = database.connect();
router.get("/api/users").handle((req, res) => {
    return db.table("users").list(12);
  });
200 OK9.8ms
200 OK10.2ms
200 OK8.9ms
200 OK11.1ms
Data

Transactional data

A zero-allocation transactional layer over PostgreSQL, with built-in pooling and ACID by default.

table: userACID
idINT
nameVARCHAR
emailVARCHAR
verifiedBOOL
SELECT *~230ns compile
Edge

Edge gateway

Built-in gateway with zero-copy caching and automatic TLS. Paths resolve before any code runs.

Client request
Gateway · routerresolve
In-memory cacheHIT
Static filesHIT
Auth

Authentication

JWT identity and access control built into the runtime. Guards run before your handler, on the fast path.

guard
JWT HTTP Only
Cookie: token=ey…; HttpOnly
verify signature✓
scope · user✓
Cluster In development

Self-healing cluster

The next layer we're building: every node runs the same runtime, adopting roles — Gateway, Coordinator, Worker — on the fly to survive outages.

Node 01
Gateway
Node 02
Coordinator
Node 03
Worker
cluster
Database
Benchmarks

Measured, not promised.

Every number is reproducible on a single node with go test -bench and k6 — June 2026, on an 8-core laptop.

0
Requests / sec
0 of 499,510 failed
0.5M
Instructions / sec
VM core throughput
0ns
Per instruction
Stack-based precision
0ms
Cold boot
Full tenant, bundle to live
Developer experience

Familiar by design.

Write standard JavaScript. What's supported behaves exactly like JS; what's removed fails at compile time with a clear message. No new language to learn, no footguns on shared infrastructure.

  • Real JavaScript semantics — operators, Date, Math, full String & Array methods, Unicode-correct.
  • Bounded on purpose — no while loops, no infinite recursion; every execution is metered and terminates.
  • No build step — save a file, the runtime recompiles and hot-swaps in under 10ms.
orders.js
// standard JS — runs as bytecode
import { router, database } from 'kitwork';
const db = database.connect();
router.get("/orders/tax").handle((req, res) => {
  return db.table("orders").list(24)
Where we're going

Degrade,
never collapse.

The runtime is production-ready today. The self-healing cluster is what we're building next: every node runs the same runtime and takes whatever role the cluster needs. Lose a node, and its peers carry on — capacity may shrink, the service does not stop.

Runtime & virtualization

Bytecode VM, energy metering, nanosecond latency — shipped

Single-node cloud

Multi-tenant hosting, auto TLS, folder-push deploys — shipped

Self-healing cluster

Multi-node state sync, automatic failover — in progress

Sovereign edge network

Localized clusters for data residency — planned

Cluster simulation
Edge Gateway
Coordinator

Worker

Worker

Worker

cluster healthy — 3 workers active

Architecture

Everything in one process.

A request flows through edge, compute and data without ever leaving the runtime. The only thing outside it is your database.

RUNTIME PROCESSClientHTTPS requestEdgerouter · TLS · cacheComputebytecode VM · sandboxedDataACID · zero-allocAuthentication guardPostgreSQLyour store

No network between layers

Edge, compute and data share one process — calls between them are function calls, not RPC over a network. Fewer hops, fewer failures.

Bounded by the runtime

Every request is energy-metered and cannot run forever. That's what makes it safe to host untrusted tenants side by side.

Postgres is the only dependency

State lives in the database, never in node memory — so any node is replaceable and the runtime stays disposable.

Built in the open

Don't take our word for it.

We're early, and we'd rather earn trust than claim it. Everything we say is something you can read, run, or track yourself.

Read the source

The entire engine — compiler, VM, runtime — is public under AGPL-3.0. Audit it, fork it, run it on your own hardware for free.

github.com/kitwork

Run the benchmarks

Every number on this page ships with a command. Reproduce them yourself with go test -bench and k6.

See the methodology

Track the roadmap

What's shipped is marked shipped; what's coming is marked in progress. No vapor, no fake status — just an honest changelog.

Read the changelog

Infrastructure you can
actually understand.

Open-source engine, reproducible numbers, a public roadmap. Your first deploy is one command away.

Start building View the engine