The Browser is the Engine.
Stop exporting black-box WebGL binaries from desktop applications. Aeion Motion Studio is a native, professional-grade 3D creative suite running entirely within the OS. Featuring over 60+ Visual Scripting nodes, WebAssembly (Wasm) powered physics, and procedural audio synthesis, it transforms a standard 3D viewer into a AAA spatial computing platform.
Generative 3D & Edge Physics
Node-Based Visual Scripting
An "ActionScript" successor for the WebGL era. Build complex interactions, loops, and gameplay logic using a powerful visual node graph featuring 60+ nodes. Trigger animations, swap materials, and mutate states without writing a single line of code.
Wasm Edge Physics (Rapier)
True determinism at 60fps. Motion Studio natively integrates the Rust-based Rapier physics engine compiled to WebAssembly. Apply Rigid Body, Soft Body, and Kinematic properties instantly. Objects bounce, collide, and fracture with absolute physical accuracy natively in the browser.
Procedural Audio Synthesis
Don't rely on bloated `.mp3` files. The engine leverages the browser's Web Audio API to mathematically synthesize retro sound effects (lasers, explosions) and spatial audio cues procedurally in real-time, reducing initial payload sizes to nearly zero.
Generative AI Integration
Connect directly to the Neural Bus. Use AI nodes to prompt for 3D meshes on the fly, or pipe TTS audio through the lip-sync pipeline to procedurally animate digital human visemes instantly within the scene.
Shader Graph Architect
Create stunning procedural materials. Visually map noise functions, fresnel glows, and parallax occlusion to your geometries. The system compiles the graph down to hyper-optimized WebGL2/WebGPU shader strings natively.
Flawless DOM Synergy
Unlike a compiled Unity game that traps your content in a `<canvas>`, Motion Studio scenes can seamlessly interact with the surrounding HTML/React application. Trigger React state changes from a 3D click, or drive 3D particle bursts from a 2D HTML button.
What ships in Motion Studio
AI 3D Generation
Generate a ready-to-use glTF/GLB model straight from a text prompt (GA). Turn a narration track into lip-synced facial animation on a standard viseme rig (GA today via a deterministic amplitude-driven generator, with a higher-fidelity phoneme-accurate model rolling out). Turn a text description into skeletal animation using a real motion-capture action library — walk, run, wave, jump, nod, bow, turn, and more (GA today via a deterministic action-vocabulary mapper, with a learned free-form text-to-motion model rolling out behind the same interface). Compile a scene's physics into a deterministic simulation (source generation is GA; a compiled edge-runtime binary is rolling out).
Async Render Queue
Long-running renders run on a tracked job queue and surface back to the timeline without blocking the editor.
Asset Optimization
Real polygon reduction — uploaded glb/gltf assets are genuinely decimated, cutting triangle and vertex counts (and file size) to make AAA scenes web-deliverable. Advanced texture compression is rolling out next; nothing is faked in the meantime — assets that can't yet be safely compressed further are simply left as-is rather than corrupted.
Live Scene Bindings
A declarative, type-safe binding layer connects your 3D scenes to Aeion collections — when a collection row changes, the bound scene property updates automatically, and every write back is validated server-side before it lands. Inventory hits zero in Commerce, and the product configurator fades the model out, with no glue code written to make that happen.
Versioned Scenes with Drafts
Every scene ships with draft/publish versioning and a stable embed token out of the box — iterate on a v2 in a private draft while the current version stays live, then swap atomically on publish.
The Neural Bus is the difference between a 3D editor and a 3D operating system.
Every other web 3D tool gives you primitives — a cube, a sphere, a material — and asks you to model the rest in a desktop app. Motion Studio sits on top of the Neural Bus, the same pipeline Aeion uses for video, audio, and text generation. That means when a designer types "low-poly mountain village at dusk, snowy" into a node, the request fans out to whichever generation provider has best context, returns a compressed glb, and drops it onto the timeline ready to use. The same Neural Bus path powers lip-sync generation — TTS audio in, per-frame viseme weight curves out, animated digital-human face. The art pipeline that used to take a Maya artist and a rigger now takes a sentence and a few seconds of processing time.
Wasm physics: deterministic, edge-ready, embarrassingly fast.
When a scene uses physics, Motion Studio packages the rigid bodies, joints, and collision meshes into a Rapier scene config and compiles it — deterministically — through the same AST engine that already assembles Aeion's other deployable Wasm binaries. Source generation is GA today; the purpose-built edge-runtime Wasm binary, tuned for the target environment (browser main thread, web worker, or edge worker), is rolling out next. That binary targets under 200KB and 5ms-per-step latency, and is bit-for-bit deterministic across machines: the same input produces the same output frame on a MacBook in Tokyo, a Pixel in Berlin, and a server in Virginia. That determinism is what makes multiplayer authoritative-server physics possible without a 50MB Unity export.
Native Multi-User Collaboration
CRDT Multiplayer Editing
Motion Studio is built on the same Yjs CRDT real-time substrate as the rest of the OS. Multiple designers, developers, and animators can edit the same scene, wire the same node graph, and sculpt the same terrain simultaneously with sub-50ms latency.
Live Play Mode
Because there is no "build" step, transitioning from Edit Mode to Play Mode is instantaneous. The Wasm physics engine boots immediately, allowing rapid iterative testing of spatial behaviors and collision logic.
Versioned Scenes with Drafts
Scenes ship with versions + drafts enabled out of the box. Ship a hero scene to production while a designer iterates on v2 in a draft, then atomically swap on publish.
Embed Token Sharing
Each scene gets a stable embed token. Drop a scene into an external site or partner portal without granting tenant access.
Architect & technical-buyer questions
Unity WebGL is a compiled black box — your 3D content is trapped inside a `<canvas>`, the initial download is 20-40MB, search engines can't index it, and there's no clean React interop. Motion Studio is built natively in React Three Fiber. Scenes are versioned database rows, not zipped artifact bundles. A 3D click can trigger a Zustand store update; a button click can drive a 3D particle burst. The whole engine is HMR-friendly during development.
Rapier compiled to Wasm runs ~10,000 active rigid bodies at 60fps on a 2022 MacBook Air. For most product configurators, marketing scenes, and gamified UI, you'll never hit a ceiling. For full multiplayer-game workloads, we recommend pinning physics to a Web Worker — Motion Studio supports both main-thread and worker targets natively.
The Neural Bus routes generation requests to the highest-quality provider currently available — typically Luma Genie, Trellis, or Meshy. The choice is provider-pluggable and tenant-configurable; any tenant can plug in their own self-hosted Hunyuan3D or proprietary model.
Yes. Drop a `.glb`, `.gltf`, `.fbx`, or `.usdz` into the scene library and the built-in asset optimizer reduces polygon count automatically (texture compression is rolling out). Maya/Blender/Cinema4D round-trip is supported.
The Yjs CRDT substrate is conflict-free by construction — there is no merge conflict because every operation is commutative. Two designers can edit the same node graph simultaneously; the result is deterministic regardless of network ordering. Average operation latency is sub-50ms inside the same region.
Yes, on any plan — BYOM (Bring Your Own Models) is included, not gated. Luma, Trellis, or any model exposing a compatible REST inference API can be plugged in. Air-gapped deployments use a self-hosted Trellis container; all generation traffic stays inside your VPC.
Visual Scripting nodes are typed, pre-vetted primitives — there is no `eval` or arbitrary-JS escape hatch. Custom nodes can be authored but go through the same package-publication flow as a module: declarative manifest, signed bundle, tenant-scoped install. The 60+ ship-in-the-box nodes are written and security-reviewed by the platform team.
Each binding declares a typed channel — collection + field path on one side, scene-graph property selector on the other. When the collection row changes, the binding pushes through the real-time layer; when the scene mutates a bound property, it writes back through a validated API. This is how product configurators stay reactive to inventory updates without bespoke glue code.