We stopped renting the cloud — and built our own runtime.
Kitwork began as one developer's refusal to keep building on someone else's land. This is how a lesson learned the hard way became a runtime you fully control.
Where it started
A house built on rented land
Years ago a small price-comparison site — written from scratch in Go — climbed into Vietnam's top 100 e-commerce sites. It ran on a single 1-core server, and for a while it worked. Then, almost overnight, a search-engine change de-indexed it and the traffic vanished. The lesson landed hard and never left.
The modern cloud only deepens that dependency. A typical platform stacks Redis for cache, Kafka for events, Consul for discovery, Kubernetes to orchestrate it all — each brilliant alone, exhausting together, and demanding an operations team just to keep the lights on. Worse, the moment your code is compiled and deployed, your logic freezes inside a binary, reachable only through rigid pipelines.
If you build your house on someone else's land, you can lose it overnight.
A different question
Spend less by deciding less
Most engines chase one thing: how fast a line of code runs. Kitwork started somewhere else — what actually costs a cloud system at scale? Rarely a slow instruction. It's the repeated runtime initialisation, the uncontrolled allocation, the context switches, the garbage collection — the endless small state changes.
We call the answer Energy Computing: model a system as E = W × T × S — work, time, and state transitions — and win by making fewer decisions, not faster ones. And the other half: if code is compiled ahead of time into bytecode, it stops being frozen and starts being portable.
Bytecode is not about being low-level. It is about being done thinking.
What we built
One runtime instead of a stack
Kitwork compiles a deliberately small, JavaScript-familiar language into bytecode and runs it on a custom stack-based virtual machine written in Go — no V8, no containers, no node_modules. Compute, data, edge and authentication live together in one process you own. Deploy a folder, get a live service.
In a cluster, every node runs that same runtime and simply takes a role — Gateway, Coordinator, or Worker. When one falls, another assumes its duties. The system degrades, but it does not die.
Measured, not marketed — every figure is reproducible against the engine.
A strong system is not one that never fails — it is one that keeps working when failure comes.
Honest by design
Built in the open, claimed honestly
There are no borrowed logos on this site and no invented metrics. The products we point to are the ones we actually build and run on Kitwork ourselves — KitData, Bytecode, and the very site you're reading. The engine is open source under AGPL, and Kitwork is in public beta: download it, read every line, and own what you deploy.
The hands behind it
One pair of hands, no shortcuts
Kitwork is built by Huỳnh Nhân Quốc — a self-taught engineer from Tam Kỳ, with no degree, no investors, and no team. For years he delivered packages by day to keep the servers paid, and wrote code by night. The engine that runs this cloud was built the same way: from string to []byte upward, understanding every layer before depending on it.
Sovereign cloud, one folder at a time
The goal was never to add one more framework to the pile. It's a runtime you can hold in your hands — that boots in single-digit milliseconds, survives the loss of a node, and answers to no one but you.
“Go outside while it is still light.”
