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.
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.
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
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
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
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
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
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
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.
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
→GLB per model and per prefab with bound materials
Materials & PBR textures
→Embedded glTF PBR maps
UE levels (.umap) & foliage
→Scene GLB with KHR lights & EXT_mesh_gpu_instancing
Landscape heightfields
→Indexed Three.js terrain mesh
Heavy static GLBs (mesh_optimize)
→Decimated GLB verified by rendered before/after gate
Groom hair, MetaHuman DNA & audio
→Strand 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
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
Asset Library · Stylized Biome Kit Snow Peaks sceneDocs 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.
Alpine biome · Strata heightfield, haze, grass and Arbor conifersForest biome · scanned Arbor foliage and ground coverCoastal biome · shoreline water, reeds and cliffsDesert biome · rippled dunes, sandstone mesas and scrubTundra 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.
flowchart LR
human["You in the<br/>Terrain Editor GUI"] <-->|"JSON + SSE<br/>live sync"| server["terrainEditor()<br/>Vite server"]
agent["Agent via<br/>threenative-terrain MCP"] <-->|"atomic commit<br/>409 on stale rev"| server
server <--> doc["terrain.json<br/>recipe · sky · assets · overrides"]
doc --> bake["bakeWorldPackage()<br/>LOD chunks + colliders + GLB"]
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.
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
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
Bayview as a native Android app on a Pixel 8.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.
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.
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.
Midway, native desktop: 57.6 to 58.3 fps at a 60 Hz cap, frame p50 14.8 ms.Caravel's playtest fails if p95 passes 33 ms or draw calls pass 140.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
1Scaffold a project
Pick a template. Engine packages, agent instructions and all 6 MCP servers come wired.