Bytecode Logic Engine

Kitwork.

Logic Execution Infrastructure

Built on Go, the engine compiles a familiar Javascript-like blueprint into bytecode and executes it on a stack-based virtual machine, allowing logic to run beyond interpretation or abstraction, in its own native form.

Try Playground Documents

app.kitwork.js

                import { router, log, database,
                    go } from 'kitwork';

                const db = database.connection();

                router.get("/users/:id?").handle((req, res) => {

                    // 1. Database query via ORM
                    mapping

                    const users = db.table("user").limit(5).list();

                    // 2. Spin up parallel Goroutine background
                    worker

                    go(() => {

                        log.Print("Isolated background
                    sync");

                    });

                    return res.json({ data: users });

                });

Performance Benchmarks

Verified load test metrics executing concurrently on a single local engine node.

12,700+

Requests / Sec

HTTP Load Throughput

14.1M

Ops / Sec

Raw Bytecode Exec Speed

70ns

Logic Latency

VM Execution Precision

1.16ms

HTTP Median

Latency under Heavy Load

Engine Stack

Key Capabilities

Everything you need to build next-generation sovereign microservices and high-frequency backend interfaces.

Zero-Copy Routing

High-velocity trie-based router matching endpoints natively in Go, bypassing Javascript overhead entirely for path resolution.

Zero-Allocation ORM

Direct SQL builder executing database queries in nanoseconds—nearly 20x faster than traditional heavyweight ORMs.

Concurrency

Spawn non-blocking background threads utilizing Go's lightweight scheduler via the standard Javascript `go()` directive.

Thread-Safe Cache

Features custom file locks (`sync.RWMutex`) to guarantee static cache stability and prevent content truncation under heavy load.

Interactive Node

Live Developer Playground

Run actual code on this node and observe responses, latency, and system execution metrics.

Routing & Cache

Select an endpoint to trigger. Notice the latency difference on cache hits.

Endpoint

Terminal Output

Idle

// Press Run to execute logic...

app.kitwork.js

import { router } from 'kitwork';

// Cached response (expires in 1 hour)
router.get("/api/testcache").cache("1h").handle((req, res) => {
    return res.text("testcache");
});

// PNJ Gold Price API proxy with 5 seconds cache
router.get("/api/gold").cache("5s").handle((req, res) => {
    const fetch = http.get("https://edge-api.pnj.io/...");
    return res.json(fetch.json());
});

Get into the flow in
under 60 seconds.

No massive node_modules. No complex build steps. Just clone and run.

# 1. Clone the starter project
git clone https://github.com/kitwork/starter
cd starter

# 2. Start the project with Go
go run .

Huỳnh Nhân Quốc

Founder · Kitwork

Sponsor

Most systems are built around servers.
I build runtimes where logic can exist on its own.

I believe logic should be portable, deterministic, and free from the weight of infrastructure. Not trapped inside frameworks, containers, or endless layers of abstraction, but compiled into something capable of moving and executing in its own form.

Kitwork is my attempt to give backend logic its own runtime, its own identity, and its own sovereignty.