Skip to content
TypeScript 3D engine, version 4.7.8

A lit 3D product in 10 lines of TypeScript.

Aura3D is the TypeScript engine for agent-written browser 3D that ships the whole stack: lighting looks, typed and licensed assets, Rapier physics, Recast navigation, a game kit and deploy checks. The three.js version of the same scene is 38 lines before orbit controls.

npx create-aura3d@4.7.8 my-scene --template product-viewer

No renderer setup, loader wiring or dispose loops.

Aura Slam 3D tennis court with a player mid-serve
Aura Slam 3D Live WebGL2 game
Open fullscreen
Poster first. The live game starts only when you press Play.
main.ts 10 lines
import { camera, createAuraApp, interactions, looks, model, scene } from "@aura3d/engine";
import { assets } from "./aura-assets";

createAuraApp("#app", {
  scene: scene()
    .add(looks.preset("product-studio"))
    .add(model(assets.product, { name: "product", targetHeight: 1.6, castShadow: true }))
    .add(interactions.orbit({ target: "product" }))
    .camera(camera.frameAsset(assets.product, { targetHeight: 1.6 })),
  ...looks.appOptions("product-studio")
});

Line counts include imports and skip blank and comment lines. The three.js version is in tools/bench-vs-threejs/tagline/ in the Aura3D repo.

  • 24npm packages
  • sha256hash, source and licence recorded per asset
  • 25playable games
  • MITdeclared in every package

The same product shot. A quarter of the code.

Both scenes load the same GLB with HDR studio lighting, a shadow-casting key light, tone mapping and a framed camera. Aura3D adds orbit controls in the same 10 lines.

Show the three.js version
three.js main.ts 38 lines
import * as THREE from "three";
import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";
import { HDRLoader } from "three/addons/loaders/HDRLoader.js";

const renderer = new THREE.WebGLRenderer({ antialias: true });
renderer.setPixelRatio(Math.min(devicePixelRatio, 2));
renderer.setSize(innerWidth, innerHeight);
renderer.toneMapping = THREE.NeutralToneMapping;
renderer.shadowMap.enabled = true;
document.querySelector("#app")!.appendChild(renderer.domElement);

const scene = new THREE.Scene();
scene.background = new THREE.Color("#2b2f36");
const camera = new THREE.PerspectiveCamera(35, innerWidth / innerHeight, 0.1, 100);
const pmrem = new THREE.PMREMGenerator(renderer);
new HDRLoader().load("/hdri/studio_small_08_1k.hdr", (hdr) => {
  scene.environment = pmrem.fromEquirectangular(hdr).texture;
  scene.environmentIntensity = 1.1;
  hdr.dispose();
});

const key = new THREE.DirectionalLight("#ffffff", 2.4);
key.position.set(6.52, 18.39, 13.98);
key.castShadow = true;
key.shadow.mapSize.set(2048, 2048);
scene.add(key);

new GLTFLoader().load("/aura-assets/product-fixture.glb", (gltf) => {
  gltf.scene.traverse((o) => { if ((o as THREE.Mesh).isMesh) o.castShadow = o.receiveShadow = true; });
  scene.add(gltf.scene);
  const box = new THREE.Box3().setFromObject(gltf.scene);
  const center = box.getCenter(new THREE.Vector3());
  const dist = box.getSize(new THREE.Vector3()).length() / (2 * Math.tan((camera.fov * Math.PI) / 360));
  camera.position.copy(center).add(new THREE.Vector3(0.5, 0.35, 1).normalize().multiplyScalar(dist));
  camera.lookAt(center);
});

addEventListener("resize", () => {
  camera.aspect = innerWidth / innerHeight;
  camera.updateProjectionMatrix();
  renderer.setSize(innerWidth, innerHeight);
});
renderer.setAnimationLoop(() => renderer.render(scene, camera));
Aura3D main.ts 10 lines
import { camera, createAuraApp, interactions, looks, model, scene } from "@aura3d/engine";
import { assets } from "./aura-assets";

createAuraApp("#app", {
  scene: scene()
    .add(looks.preset("product-studio"))
    .add(model(assets.product, { name: "product", targetHeight: 1.6, castShadow: true }))
    .add(interactions.orbit({ target: "product" }))
    .camera(camera.frameAsset(assets.product, { targetHeight: 1.6 })),
  ...looks.appOptions("product-studio")
});

Also in our benchmark: a PBR viewer with HDR lighting, shadow, bloom and orbit controls in 24 lines instead of 49, with 1 import instead of 8. In the Aura3D benchmark (five small scenes, one author, counted in lines of scene code), four of them need up to 51% less scene code.

Measured on the published package (benchmark run of 2026-10-28): a one-cube scene reaches its first frame in about 420 ms and draws in 1 call, and a PBR viewer scene with a shadow and bloom draws in 25. The five benchmark scenes log no console warnings or errors. Software WebGL2 on a remote runner, one run, not GPU numbers.

See the benchmark

Everything three.js leaves to you, built in.

three.js gives you a renderer. Aura3D gives you the renderer, the lighting, the asset pipeline, the game kit and the deploy checks, typed end to end and built for AI coding agents.

Why Aura3D over three.js
What Aura3D includes and what three.js leaves to you, by need: lighting, post effects, model loading, asset licensing, production safety, game shell, replay, high refresh rates, blank-screen recovery and AI coding agents.
Need With Aura3D With three.js
Studio lighting and shadows One looks.preset() call: HDRI, key light, shadows, grade. PMREM, lights, shadow flags and tone mapping by hand.
Bloom, AO, custom post pass effects.bloom(), effects.shaderPass(). EffectComposer plus 3 to 4 addon passes.
Loading a model model(assets.robot): typed key, compile-time check. GLTFLoader and a string path.
Asset licensing Source, licence, author and sha256 recorded per model. Not tracked.
Production safety Unverified models don't draw. Any URL loads.
Game shell HUD, touch, juice, session, audio cue bank. Not included.
Replay and QA Fixed-step loop, seeded RNG, QA hooks. Write your own.
120 and 144 Hz displays Render interpolation built in. Write your own.
Blank-screen recovery Safety net with black-frame self-heal. Not included.
AI coding agents llms.txt, 14 skills, recipes in every new project. No official agent docs.

25 games built on Aura3D. Play four right here.

Every one is a real Aura3D route, not a video. Nothing loads until you press Play.

Aura Slam 3D New York hard court with a player serving
Aura Slam 3D 3D tennis
Open fullscreen
3D tennis2-bone IK

Aura Slam 3D

Tennis with six stadiums and two-bone IK athletes.

Technical proof Quick Match and Smash Lab are playable; tournament and online modes are not in this version.

Apex Overdrive interceptor flying over a sunset freeway
Apex Overdrive Sky-lane racer
Open fullscreen
Sky-lane racerWebGL2

Apex Overdrive

Thread an interceptor through sunset gridlock.

Technical proof 10 typed vehicle GLBs and sky-lane racing with thrusters.

Thermal Drift ramjet drone racing through a rain-soaked neon city
Thermal Drift Combat racer
Open fullscreen
Combat racerThermal overdrive

Thermal Drift

Race armed ramjet drones through a rain-soaked megacity.

Technical proof 7 selectable drones with laser cannons and homing missiles on three circuits.

Grid Dispatch robotaxi on California Street in a 3D San Francisco
Grid Dispatch City sandbox
Open fullscreen
City sandboxLive minimap

Grid Dispatch

Drive a city grid as a robotaxi or a sports car.

Technical proof A live vector minimap and floating name tags on the AI rival cars across the city grid.

Also playable: Iron Crown, Pip's Big Leap, Aura Hoops 3D, Aura Diamond 3D, Aura FC 3D, Aura Links 3D, Bunker Zero, Slingshot Siege, Glint Courier, Cross Hop, Craterline GP, Chroma Roll, Serpentine Sky Run, Gridlock Courier, Ion Circuit, Shadowstep Gauntlet, Lamplight Line, Saltwind Highway, The Bellkeeper's Walk, Duneglide, and Cumulus Dash.

See all 25 games

Every model typed, hashed and licensed.

Add a GLB or pull a CC0 model by name. The CLI records its source, licence, author and sha256, then generates a typed key, so a missing asset is a compile error instead of a blank screen. In production, a model without a valid hash doesn't draw.

Damaged PBR helmet rendered with studio lighting and contact shadows
Damaged helmet Typed GLB with PBR
Open fullscreen

One CLI from search to shipped asset.

  • Search open sources: aura3d assets search "robot"
  • Generate with Meshy when nothing fits.
  • Optimize, inspect and thumbnail from the same CLI.
Read the asset workflow Open the cinematic concept car scene
Add an asset CLI
# Hash, copy, inspect, and type a local GLB.
npx @aura3d/cli@4.7.8 assets add \
  ./model.glb \
  --name robot \
  --public-path /aura-assets/

# Writes:
./aura.assets.json
./src/aura-assets.ts
Typed refs TypeScript
import { createAuraApp, looks, model, scene } from "@aura3d/engine";
import { assets } from "./aura-assets";

createAuraApp("#app", {
  scene: scene().add(looks.preset("product-studio")).add(model(assets.robot)),
  ...looks.appOptions("product-studio")
});

Built for games, written by agents.

Game kit

HUD, touch controls, juice and session flow. An audio cue bank and step sequencer. A fixed-step loop, seeded replay and QA hooks. Smooth motion on 120 and 144 Hz displays.

Agent-ready

Every new project ships llms.txt, 14 Aura3D skills and compiled recipes for Claude, Cursor and Codex. Typed APIs and loud errors keep agent-written code on the rails.

Animation Studio

Describe a scene, get a deterministic animated short. Your coding agent directs it through a validated CLI; no bundled model or API key.

Start from a working project.

20 templates, from product viewers and cinematic scenes to mini-games, racing, fighting and character control. Each one is a normal Vite app you own, with tests.

npx create-aura3d@4.7.8 my-scene --template product-viewer

Six prompts to start from

Paste one into your coding agent.

Build a product viewer for a supplied GLB with studio lighting and orbit controls.

Product viewer

Create a dusk scene with volumetric fog, bloom, and a slow camera push.

Cinematic scene

Make a falling-blocks game with scoring, pause, and keyboard and touch controls.

Mini-game

Add a physics playground with ramps, crates, contact shadows, and a reset button.

Physics lab

Generate a night city block with lit windows, traffic lights, and a day/night toggle.

City block

Write agent rules that use typed Aura3D assets and public SDK imports only.

Agent setup

Check every asset before you ship.

aura3d check-deploy fails the build when a hashed asset is missing, a stray file sneaks into dist, or a model fails validation. Add --browser to load every route in headless Chromium and fail on failed requests and console errors, or --release for licence and quality gates.

Pre-deploy checklist

  • Typed imports resolve against the public API.
  • Every shipped asset carries a hash and a typed reference.
  • Unreferenced files in dist fail the check.
  • check-deploy --browser flags failed requests when a route boots.
  • check-deploy --browser reports console errors on the routes you ship.
  • --release adds licence and quality gates.
  • Every template ships route-health and screenshot tests.

Browser support

BrowserWebGL2WebGPUNotes
ChromeVerifiedOpt-inPrimary development target
EdgeChromiumOpt-inFollows the Chrome channel
SafariExpectedLimitedTest the version you support
FirefoxExpectedLimitedTest the version you support

Chrome is the verified target behind the route evidence. WebGL2 is the default elsewhere; test Safari and Firefox on the versions you support. WebGPU stays opt-in and route-scoped. See the route evidence.

  1. 01Add assetHash, inspect, and generate the typed reference.
  2. 02ComposeBuild the scene from real asset keys, not string paths.
  3. 03VerifyOpen the exact route users will visit.
  4. 04Check deployConfirm every shipped asset matches the manifest and the static build.
npx @aura3d/cli@4.7.8 check-deploy --dist dist

Build the product, not the engine.

The agent writes code. You bring the assets. Aura3D is not a hidden runtime generator: scaffold a template, add a typed asset and ship a route you can check.

npx create-aura3d@4.7.8 my-scene --template product-viewer

MIT (declared in package.json)