3JSE — The WebGPU-native Game Engine

The pitch

What is 3JSE?

An open-source game engine and editor for the platform that will run the next billion games: the web.

Inspector — what 3JSE isread-only

Godot proved open source can be world-class. Unreal proved what the bar is — a real editor, expressive visual scripting, a deep gameplay library, and a pipeline from blank project to shipped game. 3JSE rebuilds that bar for the modern stack: WebGPU, TypeScript, and AI-assisted development.

Three.js already won the "does the web have a real renderer" argument. What the web has never had is everything a renderer needs around it to become a platform: an editor you can see your scene in, gameplay logic you don't hand-wire, an asset pipeline that isn't a shell script, and a way for a non-programmer — or an AI agent — to safely change how the game plays. That gap, not rendering quality, is what 3JSE closes.

"If Unreal Engine were invented today — for WebGPU, TypeScript, and AI-assisted development — what would it look like?" — docs/VISION.md, the founding question

And it is built around Three.js, never on top of a fork of it. Three.js stays a normal, upgradable dependency — if a project outgrows 3JSE's abstractions, it can drop to raw Three.js at any layer without losing anything.

Inspector — why it wins6 properties

⚡

Instant everywhere

Editor boots in a browser tab. Games ship as a URL, PWA, desktop app, mobile wrapper, or XR — no multi-gigabyte installer, no export farm.

🧬

One language: TypeScript

No scripting-vs-engine split, no C++/Blueprints boundary. The components you write are the same ones the editor, the graph, and the AI use.

🤖

AI-native at the root

An Agent API exposes the editor's own command surface. Agents observe, plan, act, and verify by actually running the game — changes stay legible to humans.

📄

Projects are software projects

Scenes, prefabs, and graphs are readable, deterministic, git-diffable text files — never a proprietary binary blob only the editor can open.

🧩

Plugins are first-class

The engine itself is a curated set of official plugins on a small core. Third-party physics, terrain, or gameplay packages install exactly like official ones.

🔓

Upgradeable forever

Three.js is a pinned dependency, not a vendored fork. Your engine upgrades like any other npm package — for the lifetime of your game.

The two flagship products

Atlas for understanding. The Harness for building.

Two systems that exist today, not on a roadmap: the Atlas semantic layer turns a game into something you can see, navigate, and tune — and the AI Harness turns a coding agent into the editor itself.

🧭

3JSE Atlas

Code is for agents. Graphs are for understanding. FeelSpec is for intent and tuning. The viewport is a witness.

Atlas is generated from the real project — declared semantic metadata plus static and runtime evidence — and is never the source of program logic. It shows meaning, not implementation: Player → Movement → Jump → Camera, not Event → Branch → Cast → Tick.

Working today: the Atlas Semantic Core (@3jse/atlas, headless, 31 tests) — system contracts, typed graph compiler, FeelSpec resolution, deterministic layered layout, live knob editing wired straight to real component fields, agent task-context export with blast radius, and health as a pure function of harness evidence.

The full Atlas plan → · Implementation status →

🤖

The AI Harness

3JSE is not an editor. The coding agent is the editor. Visual tools are added only when repeated work proves they are necessary.

An agent-native Three.js/WebGPU development system: the reuse ladder (working code → curated providers → licensed assets → custom code, last), a tiered provider registry, capability routing, deterministic quality gates, and evidence-first completion.

Working today (v0.2): one Director + 24 skills, 14 curated providers, and guard rails — a destructive-git guard, a clean-code ratchet, a git-ignored WIP bench — with hard gameplay, visual, and performance gates on every claim.

Read HARNESS.md → · GitHub →

The big idea

One game. Four frontends.

Every engine forces you to pick a way of working — and silently maintains four parallel, drifting versions of your game. 3JSE rests on a single decision: one canonical, typed, serializable representation of what your game does — the 3JSE Gameplay IR.

🎨

Editor

Drag, place, inspect, sculpt. A desktop-class dockable GUI — for artists and level designers.

humans edit visually

💻

TypeScript

The same components, systems, and APIs the editor itself uses. No separate scripting language to learn.

programmers write code

🕸️

3JSE Graph

Full visual scripting for gameplay — not a toy, not materials-only. Compiles to the same IR as hand-written TypeScript; the Atlas plan adds the semantic layer on top.

designers connect graphs

🤖

AI agents

Structured primitives through the Agent API — never simulated mouse clicks. Plan, act, run the game, verify, hand back.

agents operate the engine

Four ways of working. Zero parallel versions. The IR is the architectural spine — everything else hangs from it. Read the IR design →

The honest comparison

vs. the giants

We don't pretend the web out-renders Nanite. We win where the web wins decisively — and we say so.

Content Browser — engine_compare.tsv3 rows

	3JSE	Godot	Unreal Engine
Language	TypeScript — one language, everywhere	GDScript / C#	C++ + Blueprints
Editor boot	Instant — it's a web app	Seconds	Minutes
Project format	Readable, git-diffable text	Text scenes	Binary .uassets
Distribution	A URL — PWA, desktop, mobile, XR	Exported binaries	Multi-GB installers
AI-native	First-class Agent API	Emerging	Emerging
Visual scripting	3JSE Graph — compiles to the same IR as code	VisualScript (deprecated)	Blueprints (excellent)
Rendering	WebGPU via Three.js — and honest about it	Vulkan / GLES3	Nanite / Lumen — the ceiling
License	GPL-3.0, free software	MIT	Source-available, royalties

Unreal's strengths — the editor, the scripting, the systems — are not tied to C++ or a desktop process model. They're tied to having all layers agree on one representation of a game. That's the part 3JSE rebuilds for the web.

Under the hood

Ten layers. One IR.

Two of them ship in your game. The rest are tooling — and every layer reads and writes the same Gameplay IR.

The ten layers of 3JSE: Three.js, Runtime, Editor, Asset Pipeline, Gameplay Framework, 3JSE Graph, AI Layer, Plugin System, Build+Deploy, Projects+Templates — fig. 1 — the ten layers. Cyan ships inside your game; violet never does.

01

Three.js is a dependency, never a fork. No subsystem reaches into internals; every project can drop to raw Three.js at any layer.

02

One IR, many frontends. TypeScript, 3JSE Graph, and AI agents compile to the same IR. No second, opaque execution engine.

03

Everything the editor can do, code can do. The editor is a GUI for the runtime's command API — not a separate authority.

04

Plugins are first-class. Official subsystems are just curated plugins on a small core; third-party packages install the same way.

05

Projects are software projects. Readable, deterministic files under version control — never a proprietary binary.

06

Built to be extended by AI. Every feature lands in a small, predictable set of places — a constraint, not a nicety.

The editor

A desktop-class editor. In a tab.

Play, pause, inspect, modify, resume — live, in-process, no rebuild. Browser for quick edits and shared project links; Tauri desktop app for serious work. Games built with it never depend on the editor at runtime.

Viewport live

Live WebGPU render, gizmos, camera navigation, stats overlay.

Hierarchy

Entity tree with prefab instances visually distinguished.

Inspector

Schema-generated component editors, multi-edit diffing.

Content Browser

Assets — meshes, textures, audio, prefabs, graphs — tagged, searchable, thumbnailed.

3JSE Graph

Full-tab node canvas for gameplay logic.

Material / Shader Graph

Node editor compiling to Three.js TSL.

Code Editor

Embedded Monaco-class TypeScript with LSP.

Animation Tools

Timeline, state machines, blend trees, skeleton view.

Physics Editor

Collider gizmos, constraint authoring — Rapier under the hood.

UI / HUD Editor

Retained-mode layout canvas.

Profiler

Frame timing by system, draw call, GPU pass.

Console

Logs, warnings, errors — clickable to source, TS line or graph node.

Debugger

Breakpoints, step, watch — across TypeScript and graphs.

AI Panel soon

The Agent API surface: observe → plan → act → verify.

The plan

Roadmap

Dependency-ordered, not calendar-ordered — each phase proves what the next one depends on.

Console — roadmap.log8 phases

P0Technical experiments

De-risk the bets: IR round-trip, ECS-over-Object3D performance, editor shell.

P1Editor MVP

Build a scene visually with zero hand-written code.

P2Gameplay Engine

Components, prefabs, physics, input, saves, animation — a real game.

P33JSE Graph

Visual scripting that compiles to the same IR as TypeScript — the Atlas plan supersedes the node-wiring canvas, keeping the compiler deliverables.

P4AI-native authoring

The Agent API loop — an engine an AI can operate.

P5Professional tools

Terrain, cinematics, VFX graphs, navigation.

P6Ecosystem

Templates, package sharing, multiplayer.

P7Unreal-class workflow

The full studio-grade suite — on the web platform.

Status: 3JSE is in active, early development (phases 0–2). The architecture is designed and documented; the foundations are being poured. Expect breaking changes — this is the moment to watch, shape, and build with it.

The design manual

Every decision. Every bet. Written down.

The complete 32-document design manual — written to be read by humans and by the AI agents that will help build the engine.

VISION.md🔭

Read the full manual

32 documents, fully cross-linked, on one page. Physics, rendering, networking, the object model, Verse compatibility, the vendor registry, the harness, the Atlas plan — everything.

📖 Open the design manual

The WebGPU-native Game Engine

What is 3JSE?

Instant everywhere

One language: TypeScript

AI-native at the root

Projects are software projects

Plugins are first-class

Upgradeable forever

Atlas for understanding. The Harness for building.

3JSE Atlas

The AI Harness

One game. Four frontends.

Editor

TypeScript

3JSE Graph

AI agents

vs. the giants

Ten layers. One IR.

A desktop-class editor. In a tab.

Roadmap

P0Technical experiments

P1Editor MVP

P2Gameplay Engine

P33JSE Graph

P4AI-native authoring

P5Professional tools

P6Ecosystem

P7Unreal-class workflow

Every decision. Every bet. Written down.

The Vision

The Architecture

The Gameplay IR

The Editor

The AI Agent API

The AI Harness

The Atlas Plan

Atlas — Implementation Status

The Roadmap

Read the full manual