UKKO
Browser-based computer-vision game engine — your body is the controller, video clips are the world.
UKKO is a browser-based game engine where the player's body is the input device. A SvelteKit frontend runs MediaPipe pose detection in the browser and sequences video clips off the detected gestures; a Go gateway owns sessions, content packs, and scores; a Python worker handles authoring-time transcoding and AI generation. There's no 3D rendering, no controllers — a game is a content pack of clips, transitions, and pose triggers. Built for a fully air-gapped event deployment (May 2026): the whole stack also ships as a single Windows kiosk executable with an installer, plus a smile-photo capture and print pipeline.
- TypeScript
- SvelteKit 2
- Svelte 5
- Tailwind v4
- shadcn-svelte
- Go 1.24
- chi
- SQLite
- WebSockets
- WebAuthn
- sqlc
- goose
- Python 3.12
- FastAPI
- MediaPipe
- RTMO
- Apache
- systemd
- Windows kiosk (NSIS installer)
- Raspberry Pi
UKKO is a browser-based game engine where the body is the controller. The player stands in front of a webcam; MediaPipe pose and hand landmarkers run entirely in the browser tab and fire gesture triggers; the SvelteKit frontend answers by sequencing video clips while a Go gateway keeps sessions, packs, and scores. No 3D rendering, no controllers, no app — a game is a content pack of clips, transitions, and pose-trigger rules.
The "games are content, not code" thesis
Most game engines ship a runtime and a level editor; UKKO flips that — the runtime is the engine plus a clip library plus a small DSL of pose-to-clip rules. New experiences don't ship new builds; they ship a new pack. The bet is that for the target use case (event installs, museum kiosks, brand activations) the bottleneck is rarely "we need a custom engine," it's "we need this whole thing to ship by Friday with different art." UKKO is the version of that loop that lets non-engineers iterate on the experience.
Architecture
- Frontend — SvelteKit 2 + Svelte 5 +
Tailwind v4 + shadcn-svelte. Renders the clip player and
runs the whole vision loop locally with
@mediapipe/tasks-vision— pose/hand landmarks, motion windows, trigger rules — so no frames ever leave the machine. Built to run as a kiosk full-screen tab. - Gateway — Go 1.24 with chi for HTTP routing, SQLite (WAL) under sqlc-generated query layer, goose for migrations. Owns sessions, content packs, scoreboards, WebAuthn admin login, and the WebSocket fan-out to the play surface; serves the vision models as static assets.
- Worker — Python 3.12 + FastAPI. Authoring side only: clip transcoding, server-side MediaPipe / RTMO for pack analysis, loop-seam detection, and the AI provider abstraction. The play loop never calls it, which is what lets it drop out of the offline build.
- Deploy — systemd services behind Apache with Let's Encrypt SSL on the public install. No Docker in production; the offline build (see below) collapses the whole stack into one executable.
- Kiosk extras — a smile-photo capture that prints winner photos on the spot (Windows GDI+ print chain with an operator-side layout editor for photo + sponsor logo placement), a mirror-box pose overlay, and a bank of keyboard-chord operator panels for tuning gesture sensitivity live at the event without a rebuild.
Offline-first by design
UKKO was built for a fully air-gapped event deployment in
May 2026. The just offline-kit
recipes cross-compile the Go gateway with the SvelteKit static
export embedded, CGO-free with a pure-Go SQLite, into a single
windows/amd64 executable — plus a Raspberry Pi
build — and wrap the Windows drop in an NSIS setup installer
that the public site serves as a version-pinned download.
Browser-side MediaPipe handles pose detection in the offline
build, so the kiosk needs no Python and no GPU. The smoke-test
recipe rehearses the full one-command bring-up on real
hardware. The architecture rationale lives in
docs/offline/feasibility-windows.md; the
constraints those binding guardrails enforce live in the
repo's CLAUDE.md.
Why "UKKO"
Ukko is the Finnish god of weather, sky, and thunder — a deity whose business is making things happen at scale by waving his hands. That's the metaphor. The engine doesn't care what the gesture is; it cares that the gesture happened, and that the world responds.
Straight from the source
The project's own README.
Rendered in place — every link, image, and code block carried over from the repo. The page below is what a contributor would see opening the project for the first time.
UKKO
Browser-based computer-vision game engine. Players' body movements trigger video clip sequences -- no 3D rendering, no controllers. Games are content, not code.
Live: ukko.gamingworld.uk
Quick Start
just setup # install deps, create .env, run migrations
just dev # start all services in dev mode
Stack
| Layer | Tech |
|---|---|
| Frontend | SvelteKit 2, Svelte 5, Tailwind v4, shadcn-svelte |
| Gateway | Go 1.24, chi, SQLite (WAL), sqlc, goose |
| Worker | Python 3.12, FastAPI, MediaPipe, RTMO |
| Deploy | systemd, Apache2, Let's Encrypt |
Structure
apps/frontend/ SvelteKit app
apps/gateway/ Go HTTP gateway
apps/worker/ Python vision + AI worker
db/migrations/ goose SQL migrations
db/queries/ sqlc query definitions
deploy/ systemd, Apache, Docker configs
scripts/ deploy, backup, restore scripts
docs/prd/ product requirements
Commands
See just --list for all available recipes.
Documentation
Full product requirements in docs/prd/.
Event / offline deployment
UKKO is being prepared for a fully air-gapped event deployment at Peak Technologies (May 2026). Start at docs/offline/README.md for the one-command workflow (just offline-kit, just offline-kit-smoke), artifact layout, and USB copy commands. Architecture rationale is in docs/offline/feasibility-windows.md; the real-hardware rehearsal checklist is in docs/offline/smoke-test.md. Binding guardrails online development must respect live in CLAUDE.md.
Build something like this
Want a tool like this for your shop?
We've shipped this kind of thing before. Twenty-minute intro call, no slides.