Start

ThreeNative compared

How ThreeNative differs from Three.js alone, Godot, Unity and Unreal, and when a Three.js and TypeScript team picks each one.

How ThreeNative compares with plain Three.js, traditional visual engines (Godot, Unity, Unreal Engine) and hosted AI game makers across source ownership, MCP tooling, world creation and shipping targets.

CapabilityThreeNativeThree.jsGodotUnityUnreal EngineAI Makers
Architecture & ownership
Programming modelPlain TypeScript + real THREE.Scene & WebGPURendererPlain JS / TS, low-level 3D API onlyGDScript or C# inside Godot nodesC# MonoBehaviours & DOTSC++ & Blueprint visual graphsPrompt wrapper; code hidden or paywalled
Scene format & git diffs100% readable TS/JSON source diffs — no opaque editor state100% source code.tscn text scenes + editor-owned resourcesYAML scenes / prefabs with GUID churnBinary .uasset & .umap filesHosted cloud state; code export gated on Pro/Max
Source ownership & licenseMIT end to end, including native C++ runtimeMITMITProprietary + seat / runtime feesSource available + 5% royalty over thresholdProprietary runtime; credit burn & host lock-in
AI agent toolchain
Built-in MCP servers6 wired servers (115 tools) for Claude, Codex, Cursor & moreNoneCommunity / fork pluginsBeta assistant & external MCPsExternal / community editor MCPsProprietary chat only (no external MCP)
Offline API discovery622 engine APIs + classic 3D mechanic cardsRelies on LLM training weightsClass docs via searchAPI docs via searchLarge surface, version drift commonClosed prompt internals
Automated verificationFail-closed JSON playtests, screenshots & perf budgetsRoll your own test harnessUnit tests; headless QA customPlayMode tests require editor setupGauntlet / Functional tests, heavy setupOpaque QA claims without replayable proof
Build-time animation & sculpt gatesFoot-skate checks, Pose Lab, 8-pass sculpt & rig parity gatesNoneManual editor inspectionManual editor inspectionManual editor inspectionSingle-shot generation; prone to regressions
Worlds, assets & content
Procedural asset library200+ trees, cliffs, 75 city modules, biomes & 49 dungeon piecesBring your own modelsBring your own modelsAsset Store / third-partyQuixel / Fab integrationsLimited low-poly props or generated meshes
Live terrain editorCollaborative Strata GUI + agent MCP over SSE (409 rev-safe)Write your own heightfield codeAddons required (Terrain3D)Built-in editor terrain toolsLandscape tools & World PartitionNo collaborative seeded terrain pipeline
External pack importUnreal (.uasset/.umap) & Unity (.unitypackage) → GLB + reportglTF / FBX loaders onlyglTF / FBX / Blend; no .uassetUnity packs native; no UnrealUnreal packs native; no UnityCustom upload or platform catalog only
Rendering & targets
Default lookUnreal 5.8.3 tone curve, sky, GI & shadows in src/render/Blank black canvas; manual lights & toneForward+ / SDFGI / Volumetric fogURP / HDRP presetsLumen & Nanite flagship defaultsVaries wildly per prompt
Physics & HUDGodot-shaped Rapier physics + React 19 / Tailwind HUDWire physics & DOM manuallyGodot Physics / Jolt + Control UIPhysX / Havok + UI ToolkitChaos Physics + UMG / CommonUIBasic JS physics & generated HTML overlays
Web targetFirst-class WebGPU + automatic WebGL2 fallbackFirst-class WebGPU & WebGL2WASM export (~20–40 MB, thread caveats)Heavy WebGL / WebGPU WASM buildsWeb export deprecated / unsupportedHosted browser preview
Native desktop & mobileC++ V8 + wgpu-native (Desktop & Android; iOS experimental)Requires Electron / WebView wrapperDesktop, Android & iOSDesktop, Android, iOS & consolesDesktop, Android, iOS & consolesCloud export or thin WebView wrappers
Visual scene editorCode-first by design (+ live Studio & Terrain Editor)None (third-party editors)Full node/scene editor & inspectorFull mature scene & prefab editorFull AAA world & Sequencer editorChat prompt + basic viewport preview

At a glance

ThreeNative is a game framework on top of Three.js. You write TypeScript in your own editor and keep Three.js materials, cameras, meshes and loaders. ThreeNative adds the game loop, input, physics, asset builds, UI bindings, playtests and a native runtime.

ThreeNative Three.js Godot Unity Unreal Engine
What it is Game framework on Three.js 3D rendering library Open-source engine and editor Engine and editor Engine and editor
You write TypeScript in your editor JavaScript or TypeScript GDScript or C# in the editor, C/C++ via GDExtension C# in the editor Blueprints and C++ in the editor
Rendering Three.js, with the render setup as project source Three.js Godot renderer Unity renderer Unreal renderer
Game systems Loop, input, Rapier physics, UI hooks, playtests Bring your own Built in Built in Built in
Desktop and mobile Native runtime for Windows, macOS, Linux, Android Needs a separate native host Engine export Build profiles and platform modules Engine packaging

Pick ThreeNative when

  • Your game already runs on Three.js, or your team knows it well.
  • You want game code in plain TypeScript files, reviewed and versioned like any other code, with npm packages available.
  • You want one src/game.ts for the browser, desktop and Android. See Native runtime for platform support.
  • You want to edit lighting, materials and post effects as source files in the project.
  • You want a React HUD and automated playtests against the running game.

Pick something else when

  • Three.js alone: you are building a 3D scene or visualisation, not a game, and ship only to the web.
  • Godot: you want an integrated scene editor with its own scripting. ThreeNative physics borrows Godot names such as CharacterBody3D and RigidBody3D, but has no editor.
  • Unity: your team works in C# and relies on the Unity editor and its platform tooling.
  • Unreal Engine: you want its world-building and content tools, Blueprints and C++.
  • Any of the three engines: you need to ship on iOS. ThreeNative does not support it yet.

Vendor documentation

Measured numbers and a side-by-side table are on the compare page.

Edit this page on GitHub ↗