Build Your Cloud Runtime Infrastructure.
An open-source Cloud Runtime Platform for building and operating your own cloud runtime infrastructure. Unify compute, data, edge, and authentication into a single runtime, then deploy production-ready services anywhere on infrastructure you own, without vendor lock-in.
Real products running on today
One binary.
The entire stack.
JS subset → bytecode → Go VM. Every piece is purpose-built — no Node, no containers, no esbuild.
A familiar JS subset compiles to bytecode and runs on a stack-based VM written in Go — not V8. Every tenant runs its own isolated VM; static files & .view() pages bypass the VM entirely — served straight from disk.
Parameterized query builder blocks SQL injection. update/delete require a WHERE clause — no accidental full-table wipes. Each identity gets its own isolated DB connection.
No build step — native imports, no esbuild. Edit → hot-reload compiles to bytecode → prewarms → serving. 9.8ms cold boot.
Source → lexer → parser → AST → bytecode → a stack VM written in Go. Bytecode is cached per tenant and prewarmed at boot.
Measured, not marketing: 33,287 req/s, zero failures across 499,510 requests, 27ns per VM instruction.
Runs on your own server. Data, assets (fonts, icons, logos) and certificates stay yours — no third-party CDN, no vendor lock-in, no per-request cloud bill.
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.
More CPU and RAM in one machine — until you hit the hardware ceiling, and the single point of failure that comes with it.
Stateless replicas behind a load balancer, an orchestrator, a service mesh, and external state. Capacity grows — so does the machinery you operate.
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.
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.
Serverless compute
Sandboxed execution of APIs, scheduled tasks and workers. Starts in 9.8ms, bounded by design so no workload can run forever.
Transactional data
A zero-allocation transactional layer over PostgreSQL, with built-in pooling and ACID by default.
Edge gateway
Built-in gateway with zero-copy caching and automatic TLS. Paths resolve before any code runs.
Authentication
JWT identity and access control built into the runtime. Guards run before your handler, on the fast path.
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.
Measured, not promised.
Every number is reproducible on a single node with
go test -bench and k6 — June 2026, on an 8-core
laptop.
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
whileloops, no infinite recursion; every execution is metered and terminates. - No build step — save a file, the runtime recompiles and hot-swaps in under 10ms.
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
Worker
Worker
Worker
node lostcluster healthy — 3 workers active
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.
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.
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/kitworkRun the benchmarks
Every number on this page ships
with a command.
Reproduce them yourself with go test -bench
and k6.
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 changelogInfrastructure you can
actually understand.
Open-source engine, reproducible numbers, a public roadmap. Your first deploy is one command away.
