Plain Three.js and TypeScript that Claude and Codex already know, with playtests that prove every change. One codebase runs in the browser and ships native to desktop and Android.
VULTURE 013 · live Three.js
On desktop and Android, the game renders in a native window. There is no WebView.
Scenes, meshes, materials and cameras are plain Three.js objects.
The game loop, input, physics, audio and asset loading come wired together.
One gameplay codebase builds for the browser, Windows, macOS, Linux and Android.
Built with ThreeNative
Every frame below is a capture from a game built on the engine in TypeScript and Three.js. No renders, no mockups.
Plain Three.js
ctx.scene is a real THREE.Scene and ctx.renderer is a real WebGPURenderer. There is no editor state and no scene format to learn, so Claude and Codex write code they have seen a million times.
Verified
Playtest scenarios press keys, wait ticks and assert on game state, cameras, HUD, console errors, screenshots and draw calls. A feature is done when the game proves it, not when the diff looks right.
Native
The same game runs in the browser on WebGPU and ships as a native app for Windows, macOS, Linux and Android. On native there is no WebView: the frame goes straight to the GPU.
The agent loop
Every project ships with agent instructions and four MCP servers. The agent searches what exists, writes a small patch, then proves it in the running game.
Architecture
Your game is ordinary TypeScript on top of a small set of packages. The engine owns the plumbing; the look and the gameplay stay in your source.
@threenative/core
defineGame, the fixed-step loop, scenes, input, state and the build entry for web and native.
@threenative/physics
Rapier physics: WebAssembly in the browser, a native binding on device.
@threenative/playtest
Scripted gameplay scenarios with semantic, visual and performance assertions.
@threenative/ui
React bindings for HUDs, menus and debug overlays over the game surface.
threenative-engine-mcp
Lets an agent search every public engine API before it writes code.
@threenative/runtime-native
The native host: V8, wgpu-native and Dawn, with no WebView.
import { type ICtx, Scene, defineGame } from "@threenative/core";import { BoxGeometry, Mesh, MeshStandardMaterial } from "three";class Play extends Scene { override enter(ctx: ICtx) { const material = new MeshStandardMaterial(); const cube = ctx.add(new Mesh(new BoxGeometry(), material)); return (_frame: ICtx, dt: number) => { cube.rotation.y += dt; }; }}export default defineGame({ scenes: { play: Play }, start: "play" });defineGame runs the loop. Each scene adds Three.js objects in enter() and returns a function that runs every frame.
Read the docsPerformance
On native, three.js records each frame's GPU commands into one packed buffer that crosses into C++ once. Every number below links to the run that produced it.
Generic plumbing in a vanilla game
42%
About 170 of roughly 400 lines in the abyss game were identical in every game.
Source
4,096 cubes, native desktop
2.28 ms vs 4.17 ms
ThreeNative shipped defaults against Godot, 1.8× faster. RTX 2080, 1280×720, median of 3 runs.
Source
512 skinned rigs
1026 → 4 draws
Frame time p50 47.05 → 24.45 ms against stock Three.js, faster in 6 of 6 paired runs.
Source
One command scaffolds a project with the engine, agent instructions and MCP servers already wired.