4.0.1 live Agent-era 3D. 18 lines vs. 120 lines of raw Three.js.

Stop assembling renderer plumbing.
Ship verified 3D in 18 lines.

Raw Three.js makes you hand-wire 14 packages, untyped string URLs, manual Draco/KTX2 WASM workers, PMREM generators, and recursive dispose() loops just to boot a scene. Aura3D 4.0.1 (@aura3d/engine@4.0.1) packages the entire browser 3D application stack into one zero-dependency TypeScript engine—compile-time typed GLB/glTF assets from an 800,000+ model catalog, WebGPU compute + WebGL2 rendering, physical PBR + HDR post-processing, deterministic Rapier physics, and aura3d migrate three codemods—proven across studio-grade playable 3D browser games (Aura Slam 3D, Apex Overdrive, Thermal Drift, and Grid Dispatch).

$ npx create-aura3d@4.0.1 my-scene --template product-viewer
Aura3D 4.0.1 vs. Three.js Play 3D Games Give agents context
18 lines vs ~120 in raw Three.js
800K+ assets compile-time typed GLBs
v4.0.1 zero external deps
4 Flagships studio 3D games
Aura Slam 3D · Live Stadium Playable 3D Game
2-bone IK · 6 courts · Smash Lab · World Tour Play Fullscreen ↗
Built on
Built with Aura3D 4.0.1

Don’t take our word for it.
Play the games.

These are live public Aura3D 4.0.1 games—not video loops or composited mockups. Rally across 6 world stadiums in Aura Slam 3D, fly over sunset gridlock in Apex Overdrive, race armed Ramjet drones in Thermal Drift, or drive a autonomous Lidar cruiser and supercar fleet across San Francisco in Grid Dispatch.

Open the 4.0.1 Game Gallery
01 · Aura Slam 3D

Championship 3D court tennis.

Articulated 2-bone IK tennis athletes, 6 stadiums (New York, London, Paris, Dubai, Beach, Moon), Smash Lab target practice, and a 32-player World Tour.

Play Aura Slam 3D
02 · Apex Overdrive

Fly over gridlock in 3D.

11 typed vehicle GLBs, Cold-gas thrusters, barrel rolls, carrier launch ramps, and sky-lane dogfights.

Play Apex Overdrive
03 · Thermal Drift

Armed Ramjet drone racing.

7 playable combat drones, twin laser cannons, thermal overdrive vs. water cooling zones, shockwaves, and 3 circuits.

Play Thermal Drift
04 · Grid Dispatch

Drive San Francisco in a robotaxi or supercar.

Switch between Apex Driver L5 self-driving fares and manual supercars across San Francisco with live vector minimap and floating peer tags.

Play Grid Dispatch
Built to ship

Your 3D application stack, already assembled.

Start above renderer plumbing with typed assets, agent-ready scene composition, maintained scaffolds, Rapier physics, Recast navigation, interaction systems, diagnostics, and deployment checks in one TypeScript workflow.

Aura3D 4.0.1 vs. Raw Three.js
Why Teams Choose Aura3D 4.0.1 Over Raw Three.js

Stop assembling 14 fragile npm packages.
Boot a verified 3D scene in 18 lines of TypeScript.

Three.js is a legendary low-level rendering kernel—not a complete application engine. The moment you step beyond a spinning cube, raw Three.js forces your team to hand-wire WebGLRenderer, PerspectiveCamera, OrbitControls, GLTFLoader, DRACOLoader, KTX2Loader, RGBELoader, EffectComposer, PMREMGenerator, Rapier3D, Recast, manual resize observers, and recursive dispose() loops just to keep a single route from leaking GPU memory. Aura3D 4.0.1 (@aura3d/engine@4.0.1) ships the entire browser 3D application stack in one zero-dependency, MIT-licensed TypeScript SDK.

Capability
Aura3D 4.0.1 (@aura3d/engine@4.0.1 + @aura3d/cli@4.0.1)
Raw Three.js Stack (three@0.185.x + ecosystem)
Advantage
Scene Boot & Lifecycle
18 lines with createAuraApp(): deterministic clock, resize observer, context-loss recovery, and app.dispose()
~120 lines of manual WebGLRenderer, PerspectiveCamera, ResizeObserver, requestAnimationFrame, and recursive dispose()
83% less code
Asset Pipeline & Type Safety
Compile-time typed src/aura-assets.ts generated from aura.assets.json with SHA-256 digests, SPDX checks, and clip/morph metadata
Untyped string URLs (loader.load('/foo.glb')), silent 404s, manual DRACOLoader / KTX2Loader WASM worker path wiring
Compile-time safe
Materials & Lighting
Built-in physical PBR: clearcoat, sheen, transmission, volume attenuation, dispersion, iridescence, anisotropy, procedural sky + IBL, AgX / ACES tone mapping
Manual PMREMGenerator, manual shader chunks, separate RGBELoader setup, ad-hoc tone mapping configuration
Zero setup
Post-Processing
Integrated HDR post stack (bloom, ssao, ssr, dof, motionBlur, chromaticAberration, vignette, colorGrading, taa, fxaa)
External three/examples/jsm/postprocessing or third-party composer with manual render-target ping-pong management
Declarative post()
WebGPU & Compute
First-class WebGPU compute shaders (compute.createComputePipeline), GPU frustum + Hi-Z occlusion culling, and GPU particle systems alongside WebGL2
Experimental node-material split across separate build entry points; manual storage-buffer management
Unified runtime
Physics & Character Control
Built-in deterministic fixed-step physics, CCD, joints, swept kinematic character controller, and raycast vehicle dynamics
Bring-your-own @dimforge/rapier3d-compat, manual WASM init, custom fixed-step accumulator, custom raycast vehicle math
1 simulation owner
Navigation & Crowd AI
Built-in navmesh generation, A* corridor pathfinding, and multi-agent crowd steering with local avoidance
Bring-your-own recast-navigation + WASM glue + custom steering loops
Built-in AI crowds
Advanced Rendering (Splats, Portals, VFX)
Native splats.createGaussianSplat(), recursive stencil/FBO portals.createPortalWorld(), GPU compute particles, decals, trails, and water waves
Fragmented third-party Gaussian Splat viewers, manual stencil-buffer portal passes, custom instanced particle shaders
First-party APIs
Three.js Migration Path
Automated AST codemod (aura3d migrate three) plus migrateThreeToA3D compatibility layer and 5 dedicated migration starter templates
Rewrite from scratch or maintain legacy imperative THREE.* code indefinitely
Automated codemod
Pre-Deploy Verification
Built-in aura3d check-deploy & aura3d evidence: headless Chromium route health, zero-console-error enforcement, and aura-evidence.json
Manual browser eyeballs; no standard GPU or asset gate in CI
CI-certified
Raw Three.js (three@0.185.1 + 6 addons) ~120 lines · manual lifecycle
// 7+ imports, untyped string URLs, manual WASM decoders,
// manual PMREM/HDRI setup, manual EffectComposer, manual resize & dispose
import * as THREE from 'three';
import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';
import { KTX2Loader } from 'three/examples/jsm/loaders/KTX2Loader.js';
import { RGBELoader } from 'three/examples/jsm/loaders/RGBELoader.js';
import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer.js';
import { RenderPass } from 'three/examples/jsm/postprocessing/RenderPass.js';
import { UnrealBloomPass } from 'three/examples/jsm/postprocessing/UnrealBloomPass.js';

const container = document.getElementById('app')!;
const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera(45, container.clientWidth / container.clientHeight, 0.1, 100);
camera.position.set(2.8, 1.9, 3.6);

const renderer = new THREE.WebGLRenderer({ antialias: true, powerPreference: 'high-performance' });
renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
renderer.setSize(container.clientWidth, container.clientHeight);
renderer.toneMapping = THREE.ACESFilmicToneMapping;
renderer.toneMappingExposure = 1.1;
renderer.shadowMap.enabled = true;
container.appendChild(renderer.domElement);

const controls = new OrbitControls(camera, renderer.domElement);
controls.target.set(0, 0.85, 0);
controls.enableDamping = true;

const pmrem = new THREE.PMREMGenerator(renderer);
new RGBELoader().load('/assets/studio.hdr', (hdr) => {
  scene.environment = pmrem.fromEquirectangular(hdr).texture;
  hdr.dispose();
  pmrem.dispose();
});

const draco = new DRACOLoader().setDecoderPath('/wasm/draco/');
const ktx2 = new KTX2Loader().setTranscoderPath('/wasm/basis/').detectSupport(renderer);
const loader = new GLTFLoader().setDRACOLoader(draco).setKTX2Loader(ktx2);
// + 65 more lines for lights, shadows, AnimationMixer, EffectComposer,
// ResizeObserver, requestAnimationFrame loop, and recursive dispose()...
Aura3D 4.0.1 (@aura3d/engine@4.0.1) 18 lines · typed & verified
import { createAuraApp, environment, light, model, orbitCamera, post } from '@aura3d/engine';
import { assets } from './aura-assets';

const app = await createAuraApp({
  target: '#app',
  scene: [
    environment.studio({ intensity: 1.15, sky: 'procedural-dusk' }),
    orbitCamera({ position: [2.8, 1.9, 3.6], target: [0, 0.85, 0], damping: 0.08 }),
    light.directional({ position: [4, 7, 5], intensity: 3.2, color: '#fff4e6', castShadow: true }),
    model(assets.damagedHelmet, {
      position: [0, 0.85, 0],
      castShadow: true,
      receiveShadow: true,
      clip: 'Idle',
    }),
    post({ toneMapping: 'agx', exposure: 1.1, bloom: { intensity: 0.35, threshold: 0.85 }, ssao: true }),
  ],
});
New in 4.0.0 · agent era, live

The engine three.js would be if it had been designed for models to drive it.

three.js (locked against the r185 comparison baseline, three@0.185.1) hands your agent a renderer and wishes it luck: no agent API, no asset pipeline, no correctness proof. Aura3D 4.0.1 turns a game prompt into a playable, machine-verified browser game — and proves it. Aura3D 4.0.1 is live across all 24 active public packages on npm (with all < 4.0.0 versions and the 5 retired pre-4.0 compatibility packages consolidated into @aura3d/engine@4.0.1 and deprecated in full), featuring the unified @aura3d/engine@4.0.1 single-entrypoint SDK, create-aura3d@4.0.1 agent-first CLI workflow, the complete effects.* post-processing, atmospheric, volumetric, weather, GPU particle, ribbon, and game.feel suite, deterministic Rapier physics & game kits (game.platformer, game.racing, game.fallingBlocks, game.fighting), and 19 playable 3D games and interactive showcases powered by 38+ custom Meshy 3D PBR hero vehicles, characters, and architectural props across 50 live apps and focused examples.

consolidated 4.0.0 SDK + game kits ● @aura3d/engine@4.0.1
surface 1 root entrypoint (@aura3d/engine@4.0.1) · 24 active npm packages
game kits game.platformer, game.racing, game.fallingBlocks, game.fighting, game.feel
deprecation all < 4.0.0 versions & 5 legacy compat packages deprecated on npm
effects.* post, atmosphere & VFX ● 28+ built-in builders
post-process bloom, neonBloom, cinematicBloom, SSAO, contactShadows, SSR, DoF, motionBlur, colorGrade, vignette, filmGrain, chromaticAberration, FXAA, outline
atmosphere fog, depthFog, volumetricFog, fogVolume, lightCone, auroraRibbon, rain, snow, atmosphere.setSky
particles & feel particles, meshParticles, flipbook, trail, beam, ResidentGPUParticleRenderer, looks.preset
typed PBR & Meshy 3D pipeline ● hash-pinned
catalog 800,000+ real GLB/glTF + 38+ custom Meshy 3D PBR hero assets
consumption @aura3d/cli@4.0.1 import-meshy & typegen; invented paths fail closed
simulation Rapier deterministic physics + Recast crowd navigation
19 playable 3D games + 50 routes ● fail-closed
showcases 19 upgraded 3D games & 31 interactive showcases/labs (50 live routes)
per route 1920×1080 L4 GPU posters, route-health probes, gameplay receipts
three.js delta correctness is the developer's problem, every time
2.0.4 · history — CLI asset pipeline

Generate upstream. Admit locally. Keep it typed.

Aura3D 2.0.4 shipped across all 29 coordinated packages at 2.0.4, with 50 apps, games, and focused examples. It connects the pinned official Meshy CLI to Aura3D’s typed asset workflow without moving provider generation into the browser or engine. Plan and download with Meshy; import selected local GLBs as candidate assets with hashes, sanitized provenance, supplied rights evidence, generated TypeScript keys, and fail-closed admission diagnostics.

official Meshy CLI ● upstream owner
provider operations auth, planning, tasks, resume, download
pin @meshy-ai/cli@0.2.0
paid workflow dry run + explicit maximum
runtime boundary not a browser or engine dependency
Aura3D CLI admission ● candidate only
local pipeline validate, hash, manifest, type generation
default quality candidate
profiles prop, environment, vehicle, humanoid
rights supplied and recorded, never inferred
bounded pilot ● prototype
asset typed relic candidate
mechanic keyboard collect, score, reset
framing desktop + 390px mobile reviewed
collision route-local threshold; asset collision unproven
Animation Studio

Describe a scene. Watch it perform.

Type a prompt — get a rendered animated short. The same prompt, every time. Scene intelligence isn't code you write; it's a generated EpisodeDocument played by one generic renderer with zero scene-specific constants. And the director isn't a model we bundle — it's your own coding agent, driving a validated Scene-Tool CLI. No bundled LLM. No API key.

The cast is parsed straight from your words and bound to graded humanoid rigs. Sets are keyword-routed — an office becomes an office, a forest a meadow — never a moon-garden default. A shared retargeted motion library drives everyone, with velocity-gated locomotion so planted feet stay planted and captions timed to the length of the line. A ten-gate quality suite stands guard: it rejects stiff bodies, lip-only motion, and fabricated proof. Every gate measures a real signal — nothing hard-codes a pass.

The web studio is a three-pane NLE — a Director Console, live previews, and real validated commands, not a mockup. Renders are silent by design; AuraVoice owns the voice. A clean, stylized look you can watch in minutes — and when you want photoreal characters, drop in your own rigged GLB and it renders them too. Describe the next shot, and the scene changes. It just renders.

prompt → EpisodeDocument generic player, zero scene code agent is the director no bundled LLM / API key retargeted motion library velocity-gated locomotion speech-duration captions 10-gate quality suite deterministic renders silent · AuraVoice owns voice web NLE studio
Animation Studio web NLE with a Director Console and a prompt-generated office scene rendered in stylized toon shading
Live studio · prompt-generated office scene
01 — SDK

A complete 3D vocabulary, designed for generation.

Aura3D gives AI coding assistants the nouns and verbs of browser 3D: scenes, models, lights, cameras, materials, effects, interactions, UI, and deployment-ready assets behind a compact TypeScript API. The result is fast to generate and simple to refine.

agent-scene.ts typed-assets.ts deploy-check.ts
TypeScript
// Typed GLB + 4.0.0 effects.* pipeline: register once, then compose the scene.
import {
  createAuraApp, scene, model, camera,
  lights, effects, looks
} from "@aura3d/engine";
import { assets } from "./aura-assets";

createAuraApp("#app", {
  ...looks.appOptions("studio-product"),
  diagnostics: { overlay: true },
  scene: scene({ background: "#05070a" })
    .add(model(assets.boombox, { scale: 1.2 }))
    .add(lights.studio({ intensity: 1.2 }))
    .camera(camera.orbit({ distance: 4 }))
    .add(effects.bloom({ intensity: 0.28 }))
    .add(effects.ambientOcclusion({ intensity: 0.35, radius: 0.45 }))
    .add(effects.contactShadows({ opacity: 0.45, blur: 1.6 }))
    .add(effects.vignette({ intensity: 0.22 }))
});
// Typed assets & 4.0.0 effects.* keep models and post-processing deterministic.
Typed GLB workflow typed assets
asset manifest · studio lighting studio ready
02 — Prompt-to-3D

Describe the world.
Receive the scene.

Aura3D gives prompts structure: cinematic particles, physical playgrounds, data galaxies, material labs, city blocks, mini-games, humanoids, and product viewers. The assistant starts with a maintained scene system, then edits the TypeScript you own.

prompt · code · asset · deploy Start building →
prompt-plan.ts scene-kit.ts scene-kit.ts
TypeScript
// Prompt + asset path: bring the GLB, then stage it.
import {
  createAuraApp, sceneKits
} from "@aura3d/engine";
import { assets } from "./aura-assets";

const kit = sceneKits.productViewer({
  asset: assets.conceptCar,
  lighting: "cinematic",
  controls: "orbit",
});

createAuraApp("#app", kit.toAppOptions());
prompt-staged GLB scene product cinema
typed asset · lighting · controls owned TypeScript
Prompt · Physics playground
"Create falling cubes, ramps, bins, gravity cues, contact patches, reset controls, and a cinematic camera."
primitivesphysics
Prompt · Particle fountain
"Build an interactive particle fountain with an emission slider, colored droplet lifetimes, collision splash, pedestal, basin, and dark stage."
particlescontrols
Prompt · Data galaxy
"Generate a 3D analytics scene with bars, particles, labels, selected values, camera motion, and presentation-ready composition."
data vizgenerated
Prompt · City block
"Generate buildings, roads, windows, crosswalks, traffic lights, street props, night lighting, and a visible day/night state."
cityprocedural
Prompt · Material lab
"Show chrome, glass, rubber, emissive, and clearcoat as distinct primitives with lighting, reflections, and labels."
materialsprimitives
GLB · Concept car cinema
"When the concept car GLB is supplied, stage it with cinematic lighting, orbit controls, material polish, and a showroom camera."
typed assetproduct cinema
05 — Start here

One command.
A real app begins.

Start with a template, add a real asset, and let the assistant shape the scene. The agent writes code. You bring the assets. Aura3D is not a hidden runtime generator; it keeps the browser 3D foundation visible so your team can focus on the moment users see.

product-viewer
A starter for a user-provided GLB with camera, lighting, orbit controls, typed assets, and production build output.
startertemplate
cinematic-scene
A starter for camera motion, lights, bloom and fog atmosphere, and polished landing-page scenes.
startertemplate
mini-game
A starter for simple interaction, primitives, follow-camera behavior, scoring, controls, and deployable browser output.
startertemplate
agent setup
Give AI coding assistants the Aura3D API rules, asset workflow, and scene-kit patterns before they edit the app.
Agent rulesrules
copyable Aura3D commands ● supported path
what Aura3D preserves ● clear model
AI assistant your choice
asset ownership user-owned
scene authoring source code
runtime browser-native
06 — Surface

A practical 3D SDK surface.
Packaged for AI speed.

Aura3D 4.0.1 consolidates materials, environments, effects, looks, game kits, physics, navigation, animation, audio, and scene kits into the single @aura3d/engine@4.0.1 root entrypoint—backed by 24 active public packages on npm, with all < 4.0.0 versions and the 5 legacy compatibility packages deprecated in full.

@aura3d/engine@4.0.1 24 packages at 4.0.0 · < 4.0.0 deprecated on npm
4.0.0 public release ● 24/24 published on npm
primary SDK @aura3d/engine@4.0.1 + create-aura3d@4.0.1 + @aura3d/cli@4.0.1
effects & looks 28+ effects.* post/atmosphere/particle builders + 8 looks.preset recipes
renderer proof WebGPU compute + WebGL2 route evidence + bounded diagnostics
4.0.0 consolidation & deprecation ● single root entrypoint
consolidated into root materials, environments, effects, looks, game, sceneKits, physics
deprecated on npm all < 4.0.0 versions + @aura3d/lean, three-compat, materials, environments, editor
three.js migration aura3d migrate three (@aura3d/cli@4.0.1 codemod)
@aura3d/engine
Unified 4.0.0 SDK: createAuraApp, scene, model, material, lights, camera, environments, effects.*, looks.*, game.*, physics, navigation, animation, audio, sceneKits.
primary SDK4.0.0
@aura3d/cli
800,000+ asset search/resolve/add, import-meshy, assets validate & typegen, migrate three codemod, check-deploy, and create-aura3d scaffolding.
clicreate-aura3d
@aura3d/rendering
WebGL2 + WebGPU devices, forward pass, PBR, transmission, clearcoat, sheen, shadows, postprocess (bloom, SSAO, SSR, DoF, FXAA), ResidentGPUParticleRenderer.
corebackends
@aura3d/scene
Scene graph hierarchy, transforms, cameras, lights, renderables, frustum culling, and deterministic serialization.
core
@aura3d/assets
glTF / GLB, Draco, Meshopt, bounded KTX2 / Basis, RGBE HDR / PMREM IBL, and @aura3d/asset-index catalog resolution.
gltfpipeline
@aura3d/animation
Clips, tracks, mixers, layers, skinning, morphs, two-bone IK, root motion, retargeting worker, and motion-quality reports.
rig
@aura3d/physics-rapier
Native Rapier WASM adapter + @aura3d/physics rigid bodies, colliders, raycasts, character controllers, vehicles, and scene sync.
Rapiersingle owner
@aura3d/navigation-recast
Native Recast / Detour WASM navmesh generation, pathfinding queries, and multi-agent local avoidance crowd simulation.
Recastnavmesh
@aura3d/controls
Orbit, trackball, fly, first-person, drag, transform, map, pointer-lock, and camera framing helpers.
camera
@aura3d/input
Keyboard, pointer, gamepad, gestures, virtual joystick, ray picking, WebXR sessions, and AR hit-test.
xrinput
@aura3d/audio
Spatial WebAudio, mixer buses, procedural synth cues, scene bridge, adaptive stems, reverb, and filters.
spatial
@aura3d/react
Declarative <AuraCanvas> React component wrapper and lifecycle bridge for @aura3d/engine@4.0.1 apps.
react
@aura3d/product-studio
Product-viewer studio layouts, material variants, exploded views, studio lighting rigs, and @aura3d/workflows helpers.
viewer
@aura3d/math
Vectors, matrices, quaternions, rays, bounds, planes, frustums, and deterministic PRNG utilities.
primitives
@aura3d/ecs
Entity / component / system, archetypes, queries, command buffer, scheduler, plus @aura3d/core & @aura3d/scripting.
runtime
@aura3d/debug
Draw-call tracker, GPU profiler, render-state inspector, development overlays, plus @aura3d/editor-runtime & @aura3d/apps.
inspect
All 24 active packages published at 4.0.0 on npm · Legacy pre-4.0 packages (@aura3d/lean, three-compat, materials, environments, editor) & all < 4.0.0 versions deprecated. Explore the 4.0.0 API →
07 — Production polish

Make it beautiful.
Then make it shippable.

A 3D landing page has to feel effortless: fast first load, correct assets, clear controls, and no broken routes. Aura3D keeps those production details close to the code.

verification workflow ● scoped path
API surface typed imports
asset CLI hash + manifest + refs
templates build output
examples live app routes
deployment static asset check
site production copy
Scaffold templates
Assets typed refs
Deploy static check
browser support ● clear
{ "positioning": "AI-native browser 3D", "sceneKits": "particles, physics, data, materials, games", "assets": "typed GLB when supplied", "templates": [ "mini-game", "product-viewer", "cinematic-scene", "mini-game" ], "commands": [ "create-aura3d", "sceneKits.physicsPlayground", "assets add", "check-deploy", "init --agent all" ], "launch": "examples, assets, build output" }
08 — Runtime

Built for the browser.

Aura3D starts with its browser runtime. Named lower-level examples can opt into WebGPU only when adapter, backend, dispatch/render, fallback, telemetry, and pixel evidence support the exact route.

● Default browser path

WebGL2

The practical default for agent-written browser 3D: canvas setup, resize, render loop, camera, lights, interactions, and cleanup handled by the app API.

route
loads cleanly
asset
paths resolve
diag
clear errors
● Browser capability

WebGPU

WebGPU examples depend on browser and hardware support. The lower-level path carries a 96-joint skinning palette and has emulation/package proof; real-device WGSL execution and root-default WebGPU remain evidence-bound. Unsupported routes must report or use their documented fallback.

opt-in
backend
96-joint
bounded palette proof
path
documented
09 — Deployment

Bring the model.
Aura3D builds the stage.

The CLI fingerprints the file, writes the manifest, and generates typed asset references. From there, the assistant can compose a polished product scene without brittle paths.

Add a real asset
# The file already exists on disk.
npx @aura3d/cli@4.0.1 assets add \
  <path-to-source-model> \
  --name robot \
  --public-path /aura-assets/

# Generated files:
./aura.assets.json
./src/aura-assets.ts
Reference typed refs
import { assets } from "./aura-assets";

scene()
  .add(model(assets.robot))
  .add(lights.studio());

// Stable path: model(assets.robot)
Step 1
Add asset
Hash, copy, inspect, and type-generate.
Step 2
Build app
Agent writes code against real refs.
Step 3
Verify route
Open the exact page users will visit.
Step 4
Check deploy
Confirm assets ship with the static site.
Ready when you are

Give your product
a 3D interface.

Describe the scene. Generate primitives, particles, physics, data, controls, and product viewers. Bring real GLB assets when you have them. Aura3D turns browser 3D into a product surface your team can design, edit, verify, and ship when the gates pass.