A game engine that lives in the browser

Horizon is a no-code-first engine for building and shipping 3D games without leaving the tab. Real-time collaboration, a compiling visual scripting system, an automatic asset pipeline and one-step publishing — here is what is actually under the hood.

The whole engine runs in your browser

The 3D viewport is the real engine — a Bevy renderer compiled to WebAssembly, drawing through WebGPU. It is not a preview or a cut-down web version: what you manipulate in the tab is what ships.

  • No installer, no licence key, no platform lock
  • Opens on any machine you sign in from
  • Same renderer in the editor, the in-editor play mode and the published game

Several people, one scene, no merge conflicts

The scene is a CRDT built on Loro. Two editors that received the same updates hold byte-identical state, so there is no locking, no "who saves last wins", and no merge step to get wrong.

  • Edits sync live over a WebSocket to an authoritative room service
  • Concurrent changes to the same object resolve deterministically
  • Work offline and reconnect — pending updates replay cleanly

Undo that goes back further than your session

Because every change is an operation on the document, the whole history is queryable. Step backwards through it, branch from any point, or pin a version as the one players get.

  • Time travel across the full edit history, not a fixed undo buffer
  • Snapshots compacted and stored server-side
  • Publishing pins a content hash, so a live game never shifts under players

Visual scripting that compiles to real code

Wire game logic from a node graph — 67 nodes across 12 categories covering triggers, control flow, transforms, input, maths and error handling. The graph is not interpreted at runtime: the server compiles it to WebAssembly.

  • Conditions, loops, try/catch, groups and post-its
  • Compiled server-side, so the browser never ships a toy interpreter
  • Same performance envelope as hand-written scripts

Drop to code whenever the nodes run out

An integrated editor sits beside the graph for the logic that is easier to type than to wire. Scripts compile to WebAssembly modules, versioned and served like any other asset.

  • Full in-browser code editor with the engine's API documented inline
  • Mix no-code graphs and written scripts in one project
  • Reference documentation generated from the engine itself

Drag in a model, get an optimized asset

Drop a GLB and the conversion pipeline takes over: geometry becomes the engine's compact binary mesh format, textures are re-encoded to WebP, and the result is registered in your project catalog.

  • Automatic conversion to the .horizonmesh binary format
  • Textures transcoded to WebP and resized
  • Upload dedup — importing the same asset twice costs nothing

Previews rendered by the engine, not guessed

Every mesh and prefab gets a thumbnail rendered headlessly through the same Bevy pipeline the editor uses, so the grid shows the asset as it will actually look in a scene.

  • Generated on import, cached by content hash
  • Consistent lighting across the whole library
  • Falls back to software rendering where no GPU is available

Content-addressed and signed end to end

Assets are identified by a hash of their content rather than a filename, and the services sign what they serve. A client can verify that the mesh it loaded is the one the pipeline produced.

  • Blake3 content ids — identical bytes are stored once
  • Ed25519 signatures on served blobs
  • Immutable by construction: a hash never points at different bytes

An assistant that reads your actual graph

The no-code editor's assistant receives the script graph you are working on, not just a chat prompt, and answers with a structured graph you can apply directly.

  • Streams its reasoning as it works
  • Returns an applicable script, not a block of prose
  • Model credentials stay server-side — the browser never holds a key

One account, one gateway, sane security defaults

Every frontend talks to a single gateway that owns authentication, CORS and rate limiting. The login token lives in an httpOnly cookie, so a cross-site scripting bug cannot walk off with a session.

  • Session token unreachable from JavaScript
  • Tighter rate limits on credential endpoints
  • Email verification and Google sign-in out of the box

From editor to playable in one step

Publishing pins the current version and lists the game in the launcher. Players open a link and are in — no download, no store approval, no build pipeline to babysit.

  • Games stream into the browser
  • Set a price in coins, or publish it free
  • Purchases handled through Stripe, permanently tied to the buyer's account

Built as services, not a monolith

Meshes, textures, scripts, rooms, catalog, thumbnails and compilation are separate services behind the gateway. Each scales on its own, and a slow import never blocks someone else's editing session.

  • Rust services for the asset and scene hot paths
  • Blob storage separated from metadata
  • Same stack locally and in production

The fastest way to judge it is to open it

The editor loads in a browser tab with nothing to install. Start a scene, wire a node graph, and publish it to the launcher when it is worth playing.