AI game development platform

Vibe-code 3D games that survive the

Describe your game. Your agent builds it in plain Three.js and TypeScript, proves each change in a playtest, and ships it native to desktop and Android.

  • 6 MCP servers (115 tools)
  • Web, desktop and Android
  • WebGPU + WebGL2
  • MIT licensed
An explorer on a mossy cliff watches a broken stone ring glow lime over floating islands and waterfalls

Play what people ship

Staff picks from the store, free to play in your browser.

Verified AI Game Development

Six MCP servers. 115 tools. Wired out of the box.

An AI agent is only as good as the environment in which it can act and prove its work. Every scaffolded project writes ready-to-run MCP configs for Claude Code, Codex, Cursor, Gemini CLI, VS Code, opencode and Zed — giving your agent 622 indexed APIs, Unreal and Unity pack importers, collaborative live terrain, GLB animation checks, 8-pass sculpt gates and real WebGPU profiling.

Browse all 6 MCP server schemas
Auto-wired forClaude CodeCodexCursorGemini CLIVS CodeopencodeZed
6 MCP servers, wired for verified AI game development: Assets (import, optimize, rig), Terrain (generate and edit worlds), Sculpt (8-pass visual quality gates), Engine (search shipped capabilities), Animation (inspect and verify motion) and DevTools (playtest and profile), around a floating island world.
6
MCP servers wired by create-threenative
115
structured tools across assets, terrain, animation, sculpt, engine and DevTools
622
typed engine capabilities indexed offline

threenative-assets

threenative-asset-mcp

57 tools

Find, convert, optimize, rig and synthesize game assets

Unified search across 10+ libraries plus offline Unreal (.uasset/.umap) and Unity (.unitypackage/UPM) to GLB conversion, visual-gated mesh optimization, auto-rigging, animation retargeting, game audio and procedural creatures.

  • asset_search
  • asset_import_unreal
  • asset_import_unity
  • mesh_optimize
  • asset_auto_rig
  • asset_retarget_animations
  • audio_generate_sound
  • creature_compile
  • Converts owned Unreal 4/5 and Unity packs to GLB with an honest import report
  • mesh_optimize shrinks heavy GLBs behind a rendered before/after gate
  • Searches Fab, Poly Haven, ambientCG, Smithsonian 3D, Polyfork, Sketchfab, Kenney and itch.io

threenative-engine

threenative-engine-mcp

6 tools

Offline capability search + classic 3D game mechanic references

Reads the installed engine's own generated manifest of 622 public symbols so agents reuse shipped systems instead of reinventing them, paired with pinned 3D classic-game mechanic cards and gameplay frame contact sheets.

  • engine_search_capabilities
  • engine_capability_detail
  • engine_search_references
  • engine_reference_detail
  • engine_watch_reference
  • engine_save_reference
  • Matches requests by mechanic or exact symbol name with import path, signature and example
  • Points straight to the right starter kit when a prompt matches a shipped genre
  • Surfaces verified mechanic timings and curves from classic 3D reference games

threenative-terrain

@threenative/terrain

3 tools

Seeded Strata terrain recipes and live collaborative editing

Generate, patch and author whole biome worlds from validated JSON recipes, bake LOD heightfields and scatter placements, and edit live alongside a human in the browser over revision-checked SSE.

  • terrain_generate
  • terrain_biome_new
  • terrain_patch
  • Five starter biomes ready to copy and customize: forest, coastal, alpine, desert, tundra
  • Supports Arbor procedural tree species directly inside terrain scatter rules
  • Atomic revision checks (409 on stale writes) so agent and human never clobber each other

threenative-animation

threenative-animation-mcp

5 tools

Build-time GLB animation editing, prop sockets and foot-skate checks

Inspect skeletons, attach weapons or props with per-clip keyed offsets, edit clips and verify planted-foot skate, ground penetration, loop seams and bone stretch — backed by a deterministic .anim.json op log and live Pose Lab view.

  • animation_inspect
  • animation_attach
  • animation_modify
  • animation_verify
  • animation_open_view
  • Every edit is a deterministic JSON op beside the GLB — clean git diffs and undo stack
  • animation_verify flags planted-foot skate, ground clipping and loop seams by bone and frame
  • Live Pose Lab calibrator page (--view) writes the exact same ops an agent writes

threenative-sculpt

threenative-sculpt-mcp

12 tools

Fail-closed 8-pass visual sculpting and rigging quality gates

Turns reference imagery into clean user-owned procedural Three.js source across eight locked passes (blockout through optimization) with ObjectSculptSpec validation, regional pixel and semantic visual comparison, and rig/skinning gates.

  • sculpt_plan
  • sculpt_spec_gate
  • sculpt_compare
  • sculpt_pass_gate
  • sculpt_rig_gate
  • sculpt_skin_condition
  • sculpt_grimoire
  • Eight locked passes ensure silhouette, proportions, materials and lighting converge
  • Uncertainty never advances a gate — combines deterministic comparison with semantic review
  • Includes rig parity, skinning condition and clip measurement checks for custom characters

threenative-devtools

chrome-devtools-mcp

32 tools

Live WebGPU profiling, GPU traces, heap and frame inspection

Launches an isolated WebGPU-enabled Chrome profile on demand so an agent can capture live screenshots, trace slow frames, audit draw costs, inspect network requests and verify zero console errors.

  • performance_start_trace
  • performance_analyze_insight
  • take_screenshot
  • list_console_messages
  • take_heapsnapshot
  • evaluate_script
  • Configured with real hardware WebGPU and Vulkan flags — never profiles SwiftShader
  • Starts lazily on first tool call so projects pay zero overhead until needed
  • Pairs with playtest traces to isolate frame spikes, memory growth and shader stalls

From a prompt to a verified build

Every scaffolded project ships with agent instructions and 6 wired MCP servers. The agent discovers engine capabilities, fetches or bakes assets, edits code or terrain, and proves the result in a running playtest.

threenative-asset-mcp · 57 tools

Unreal, Unity and 10+ asset libraries — ready for Three.js

Fab, Unreal Marketplace (.uasset/.umap) and Unity Asset Store (.unitypackage) packs were locked inside proprietary editors. ThreeNative Asset MCP searches 10+ 3D, texture and audio libraries, converts owned Unreal and Unity packs into self-contained GLBs, optimizes heavy meshes behind a visual gate, and auto-rigs or retargets characters — with no Unreal or Unity install.

  • Imports Unreal (UE 4.0–5.5) and Unity packs into self-contained GLBs plus an honest import-report.json
  • mesh_optimize simplifies heavy static GLBs behind a rendered before/after comparison gate
  • Auto-rigs meshes, retargets animations, inspects & generates game audio, and compiles procedural creatures
$ npx -y threenative-asset-mcp
A first-person view into a cave lit by a warm lantern, with a wet floor.
Soul Cave, a Fab Unreal environment, imported to GLB and rendered in Three.js.
57
MCP tools for search, import, optimization, rigging and audio
47 / 47
meshes converted from Fab Office Pack Vol.1
146
animation clips kept from the Animal Variety Pack
UE4–5 + Unity
packs converted to GLB without opening either editor

What converts

Unreal static & skeletal meshesGLB with LODs, skins and animation clips
Unity .unitypackage & UPM tarballsGLB per model and per prefab with bound materials
Materials & PBR texturesEmbedded glTF PBR maps
UE levels (.umap) & foliageScene GLB with KHR lights & EXT_mesh_gpu_instancing
Landscape heightfieldsIndexed Three.js terrain mesh
Heavy static GLBs (mesh_optimize)Decimated GLB verified by rendered before/after gate
Groom hair, MetaHuman DNA & audioStrand file, DNA, WAV/TTF/JSON beside the GLB

Nanite-only data without a fallback mesh, Blueprint bytecode, custom Unity shaders and encrypted Pak files are reported honestly in import-report.json, never faked. Fab support is experimental and Unity imports are verified on real packs.

One search, many libraries

  • Fab / Unreal
  • Unity Asset Store
  • Poly Haven
  • ambientCG
  • Smithsonian 3D
  • Polyfork
  • Sketchfab
  • Kenney
  • itch.io / Quaternius / KayKit
  • Procedural Environment
  • Game Audio (Sonniss · Freesound · ElevenLabs)

It never signs in, purchases or claims assets for you. You need the license for every paid asset; audio_generate_sound uses your own ElevenLabs key.

Procedural Asset Library

Browse, seed and bake 200+ procedural 3D assets

Run pnpm asset-library to open an interactive Storybook viewer for realistic nature, geological cliffs, 75 modular city blocks, stylized biomes and modular dungeons. Orbit any asset, tweak seeds, LODs or themes, inspect triangle stats and copy the exact deterministic bake call into your game.

$ pnpm asset-library
28
realistic tree species with CC0 bark & leaf scans
75
socketed Apex City Kit road, building & vehicle modules
53
Stylized Biome Kit assets, mountains & animated scenes
49
modular Dungeon Kit pieces in 3 switchable themes
Stylized53 pieces

Alpine forest, snow peaks and desert canyon — zero texture files

Complete procedural Three.js worlds and individual pieces with custom stylized shaders for animated water, falling snow and wind-swept foliage. Switch seeds or variants in the viewer and copy the exact generator call from the Docs tab.

  • Three complete scene presets: Alpine Forest, Snow Peaks and Desert Canyon
  • Custom mountain ridges, stylized pines, desert arches, waterfalls, palms and clouds
  • Advance stylizedUniforms.uTime.value each frame for animated water, snow and foliage
src/world/biome.ts
import {  createStylizedAsset,  stylizedUniforms,} from "@threenative/procedural-environment/stylized";const { group } = createStylizedAsset(  "mountain-snow",  { seed: 8, variant: 1 },);scene.add(group);stylizedUniforms.uTime.value += dt;
Read the procedural environment guide
ThreeNative Asset Library viewer displaying the Stylized Biome Kit Snow Peaks scene with sidebar catalog and seed controls.
Asset Library · Stylized Biome Kit Snow Peaks scene
Asset Library Docs tab showing a procedural snow mountain ridge with triangle count and copyable TypeScript code.
Docs tab · live preview with exact copyable generator call

Strata Terrain Engine + Live Editor

Strata: generate the terrain, then sculpt it with your agent

Strata is the ThreeNative terrain engine (@threenative/terrain). One seeded JSON recipe produces heightfields, splat maps, real-world elevation tiles, biome scatter, LOD chunks and a single baked world GLB. You sculpt in the live browser editor while your agent edits the same document over MCP.

A Strata terrain wireframe mesh turns into a rendered alpine slope with grass, boulders, pines and a snowy peak.
Strata terrain alpine forest vista with snow-capped mountains, atmospheric fog, dense conifer slopes and sunlit meadow grass.
Alpine biome · Strata heightfield, haze, grass and Arbor conifers
A character standing inside a dense sunlit forest of procedural trees, ferns and undergrowth on rolling terrain.
Forest biome · scanned Arbor foliage and ground cover
A coastal shoreline with reflective water, sandy beach, reeds, boulders and distant forested hills.
Coastal biome · shoreline water, reeds and cliffs
Wind-rippled red desert dunes with mesas, desert scrub and crisp sun shadows.
Desert biome · rippled dunes, sandstone mesas and scrub
Highland tundra slopes with snow-capped alpine peaks, glacial valleys, boulders and tree line.
Tundra biome · alpine peaks, boulder scatter and valleys

Collaborative revision-checked editing

Both the browser GUI and agent MCP patch one document file over SSE. Invalid saves keep the last good world; stale writes fail cleanly with 409.

Environment, surfaces & asset mapping

Tune sun azimuth, sky fill, haze, sea color and exposure live, register asset-MCP GLBs or textures and bind channels like bark.albedo and stone.normal.

Stable placement overrides & stamps

Every scattered tree or boulder keeps a deterministic seed key so hero props stay put when masks change, plus footprint editing for stamps and heightmaps.

5 copy-out starter biomes + Arbor trees

Start from Forest, Coastal, Alpine, Desert or Tundra worlds, reference arbor:<species> directly in biome rules, and export one static world GLB with colliders.

scripts/bake-world.ts
import {  Terrain, Mask, bakeMesh,} from "@threenative/terrain";import { toGeometry } from "@threenative/terrain/three";const terrain = new Terrain({  size: 512, resolution: 257, seed: 73,})  .noise({ id: "ridges", amplitude: 42 })  .flatten({    id: "outpost", height: 12,    mask: Mask.circle([20, 30], 18),  });const geo = toGeometry(bakeMesh(terrain.evaluate()));

Keep the source — zero hostage projects

Generated games are easy to start and hard to finish when your project is trapped in a proprietary format. In ThreeNative, ctx.scene is a real THREE.Scene and ctx.renderer is a real WebGPURenderer — every agent change is a reviewable TypeScript diff in your own Git repo.

Browse all 622 engine APIs
  • Open the same repo in Claude Code, Codex, Cursor, VS Code or any coding agent
  • Drop down to raw Three.js and TSL node shaders whenever you want — zero lock-in
  • 622 offline-indexed capabilities and classic 3D mechanic references keep agents accurate

Looks like a fresh Unreal 5.8.3 project

New scenes start from the default look and frame budget of a fresh Unreal 5.8.3 project, not flat Three.js defaults. 380 Unreal visual and performance subsystems are tracked and ported systematically from what Unreal's source does, while the look itself stays in your game's src/render/.

  • Unreal's filmic tone curve, histogram auto exposure and physical sky & sun
  • Surface-cache global illumination, traced reflections, virtual shadows and quality tiers
  • Direct support for MetaHuman OpenRigLogic heads and raw UE4/UE5 .uasset static meshes
Browse the core API
Ribbed vaults and hanging chandeliers seen from the floor.
Vesper Hall: real-time GI under Unreal's tone curve.

One codebase, every screen

The same TypeScript game runs in the browser on WebGPU (with automatic WebGL2 fallback) and ships as a native C++ app for Windows, macOS, Linux and Android. On native there is no WebView: V8 replays packed WebGPU commands straight into wgpu-native and Dawn.

  • Instant Vite dev loop in the browser, signed native release builds when you ship
  • Godot-shaped Rapier physics, unified input, touch, gamepad and React 19 HUDs everywhere
  • Measured at 60 fps on a real Pixel 8 and native desktop — not only emulators
Ship native
A first-person street with a native HUD, captured on an Android phone.
Bayview as a native Android app on a Pixel 8.
An aircraft over the sea with cockpit gauges and radar, in the native desktop host.
Midway in the native desktop host. No browser, no WebView.

Modular engine, real Three.js underneath

Every subsystem is an opt-in package around a thin core. Use only what your game needs — from Rapier physics and React HUDs to Strata terrain, procedural worlds, MetaHuman facial rigs and raw Unreal loaders.

That is the whole game

defineGame wires the fixed-step loop, Rapier physics, input, React HUD and playtest hooks while every scene stays plain Three.js.

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" });

Verified creation — the agent plays what it built

Most AI game builders stop at a fragile first prototype where the next edit breaks collisions or deletes the HUD. A ThreeNative scenario presses keys, waits ticks and asserts on state, screenshots and frame budgets — so every change ships with proof, not hope.

playtests/movement.playtest.json
{  "name": "play",  "target": "web",  "schemaVersion": 1,  "warmupFrames": 60,  "steps": [    { "kind": "input", "press": "ArrowRight",      "holdTicks": 60, "release": true },    { "kind": "wait", "waitTicks": 600, "release": true }  ],  "assert": {    "diagnostics": {      "noConsoleErrors": true, "runtimeReady": true    },    "components": [      { "entity": "hud", "component": "glyphs", "changed": true }    ]  }}
$ npx @threenative/playtest playtests/movement.playtest.json --url http://127.0.0.1:5173
A first-person test range with score 0 and ammo 30 of 90.
Before the scenario: score 0, ammo 30/90.
The same range after the scripted steps, with score 150 and ammo 29 of 90.
After: score 150, ammo 29/90. The playtest asserts both.
  • Game state
  • Transforms
  • Cameras
  • HUD
  • Console errors
  • Screenshots
  • Triangles
  • Draw calls
  • Deterministic scenarios in plain JSON
  • A run with no assertion, or a missing entity, fails closed
  • The same check runs in CI and in the agent's loop
Write a playtest

Measured, with the source linked

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.

Compare with Three.js and Unreal
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 msThreeNative shipped defaults against Godot, 1.8× faster. RTX 2080, 1280×720, median of 3 runs.Source
Native C++ engine, desktop
2.35× to 3.2× fasterFrame p50 against the previous host at three scene sizes. RTX 2080, same size and triangles. Web main thread: 1.41× faster.Source
512 skinned rigs
1026 → 4 drawsFrame time p50 47.05 → 24.45 ms against stock Three.js, faster in 6 of 6 paired runs.Source
How the native frame path works
An aircraft over the sea in the native desktop host.
Midway, native desktop: 57.6 to 58.3 fps at a 60 Hz cap, frame p50 14.8 ms.
A sailing ship near a palm island.
Caravel's playtest fails if p95 passes 33 ms or draw calls pass 140.
The fox platformer on a wooden bridge between grassy cliffs, on an Android phone.
Pixel 8, native Android: 60 fps across 253 windows.

Start from a playable kit in one command

Scaffold a blank starter or jump straight into 14 genre kits — each one wired with Rapier physics, React HUDs, playtest scenarios, agent instructions and all 6 MCP servers.

Starter

Polished default project with React HUD, Rapier physics and ready-to-edit scene.

$ pnpm create threenative my-game
  1. Scaffold a project

    Pick a template. Engine packages, agent instructions and all 6 MCP servers come wired.

    pnpm create threenative my-gameLearn how
  2. Run dev & Asset Library

    Iterate live on WebGPU in the browser, sculpt terrain or browse procedural kits.

    cd my-game && pnpm install && pnpm devLearn how
  3. Ask your agent

    Describe an outcome. The agent queries MCPs, edits TypeScript and proves it in playtest.

    Learn how