Robotics
Manipulation, grasping, and navigation policies trained across simulated articulation, contact, and clutter — including humanoid platforms.
Synthetic Data Infrastructure for Physical AI
Train machines on worlds that don't exist yet.
Aurora turns simulated worlds into training data. Define your robot, its sensors, and its environment — Aurora Forge generates the labeled scenarios it needs to perceive, navigate, and act.
6 sensor modalities1 world definitionperfect ground truth
● RGB — Photorealistic camera output rendered from the simulated scene.
Concept visualization
Domain Randomization
One world. Millions of training scenarios.
A single world definition is a distribution, not a snapshot. Aurora sweeps lighting, materials, camera pose, object placement, and actor density across controlled ranges — so a model trained on one warehouse generalizes to the thousand warehouses it has never seen.
Scenario parametersvar_0412
- Lighting68%
- Fog12%
- Camera42%
- Objects77%
- Materials35%
- Weather20%
- Density50%
Purple marks parameters pushed away from the baseline scenario. Illustrative configuration.
Synthetic Ground Truth
Every pixel already knows what it is.
In simulation there is nothing to annotate. Aurora knows the class, identity, geometry, and pose of every object before a frame is rendered — so labels are derived from world state, not drawn by hand. No annotation queues. No labeling errors. No disagreement between annotators.
Source / RGB
Derived 01 / SEG
Derived 02 / DEPTH
Derived 03 / BOXES
Derived 04 / LIDAR
Class labelsPixel-exact semantic classes for every surface
Object identityStable instance IDs across frames and sensors
GeometryMeshes, extents, and contact points from world state
Camera pose6-DoF extrinsics for every rendered frame
Object posePosition and orientation of every asset
Sensor metadataIntrinsics, timing, and noise models
Aurora Forge
Initial productA programmable world generator for Physical AI.
Aurora Forge is being built as the programmable synthetic-data layer for robotics and autonomous systems: declare a world once, then compile it into millions of labeled sensor observations.
- 01
Define
Declare the world: environment, objects, robots, sensors, randomization rules.
- 02
Simulate
Aurora instantiates thousands of controlled scenario variations with physics.
- 03
Generate
Every variation renders sensor observations with perfect ground truth.
- 04
Train
Datasets stream out in training-ready formats for your model pipeline.
Forge job — illustrative configuration Generating
World
warehouse_07
Sensors
RGB · DEPTH · LIDAR
Scenarios
1,000,000
Frame output618,402 / 1,000,000
GPU workers18/24 allocated
- Shard
- 018 / 032
- Pass
- beauty+gt
- Queue
- nominal
- Job
- frg_92c4e1
Aurora HardCase
Platform directionTurn failures into training data.
The most valuable training examples are the ones your model gets wrong. HardCase is designed to take a single evaluation failure — a missed pedestrian, a phantom obstacle — and expand it into thousands of systematically varied scenarios that target exactly that weakness.
Failure-driven synthetic data generation.
- ModelYour perception model under test
- EvaluationRun against simulated scenario suites
- Failure discoveredLow-confidence condition isolated
- Variant generationAurora synthesizes related scenarios
- DatasetTargeted training data, auto-labeled
- RetrainModel returns stronger on the failure mode
Evaluation frame — demo case
Failure condition
Pedestrian partially occluded by racking
Confidence
42%
- occlusion
- partial · 64%
- distance
- 11.2 m
- lighting
- low · backlit
- pose
- crossing lane
Generate variants→ 10,000 related scenarios
Concept interface — example data
World Randomization Engine
Every parameter is a dial. Turn them.
This is a live, simplified model of how Aurora parameterizes a world. Production randomization operates on full physics, materials, and sensor models — but the control surface is the same idea: continuous dials over everything that varies in the physical world.
scn_4990f · 0 parameters modified
Randomization controls
68%
12%
42%
77%
35%
20%
50%
Industries
Built for machines that touch the physical world.
Wherever a machine has to perceive before it acts, its training data has to cover what reality will throw at it. Aurora targets the industries where that coverage is hardest to collect.
Warehousing
AMR fleets that handle occlusion, changing rack layouts, and human coworkers before the first real deployment.
Manufacturing
Inspection models trained on defects too rare to photograph — synthesized across materials, lighting, and line speeds.
Industrial Vision
Depth, pose, and detection stacks validated against pixel-perfect geometric ground truth instead of hand labels.
Autonomous Systems
Trajectory and scene-understanding models exposed to edge cases that are dangerous or impossible to collect on the road.
Drones
Aerial perception across altitude, terrain, weather, and camera footprint — swept systematically in simulation.
Aurora Worlds
Platform directionA growing library of worlds for machines to learn from.
Every world built on Aurora is a reusable asset: parameterized, versioned, and ready to generate data for the next team. Worlds is the simulation layer we are building toward — starting with the environments where Physical AI is deployed first.
wld_factory
Factories
- Scene type
- Indoor industrial
- Variables
- Lighting · Line speed · Materials · Actors
wld_warehouse
Warehouses
- Scene type
- Indoor logistics
- Variables
- Layout · Racking · Occlusion · Traffic
wld_construction
Construction
- Scene type
- Outdoor dynamic
- Variables
- Terrain · Weather · Machinery · Stage
wld_mining
Mining
- Scene type
- Subsurface / open pit
- Variables
- Dust · Lighting · Geometry · Vehicles
wld_energy
Energy
- Scene type
- Infrastructure
- Variables
- Weather · Corrosion · Access · Hazards
wld_cities
Cities
- Scene type
- Outdoor urban
- Variables
- Traffic · Pedestrians · Weather · Time of day
Compute
Simulation that scales like infrastructure.
Aurora is architected as GPU-accelerated distributed simulation infrastructure. A generation job is split into shards, each shard is simulated and rendered in parallel, and results merge into a single coherent dataset — the same job runs on ten workers or ten thousand.
- ScenarioA world definition expanded into concrete scenario parameters
- SimulationPhysics, materials, and sensors evaluated per scenario
- GPU workersRendering and sensor synthesis fan out across workers
- Synthetic framesObservations plus ground truth stream off the workers
- DatasetSharded, versioned, training-ready output
The scheduler is provider-agnostic by design — built to place work across multiple GPU clouds as capacity and cost dictate.
Job topology — concept diagram
Job / frg_92c4e1
SHARD 01GPU RENDER
SHARD 02GPU RENDER
SHARD 03GPU RENDER
SHARD 04GPU QUEUED
Frame output
Dataset · ds_warehouse_07
Developer Experience
The whole platform is programmable.
Aurora is being designed API-first. If your team can describe the world a robot operates in, it can generate the data that robot needs — from a script, a CI job, or a training loop.
Worlds as code
Environments, sensors, and randomization rules are declared in version-controlled definitions — reviewed, diffed, and reproduced like any other engineering artifact.
Datasets as builds
A dataset is the deterministic output of a world definition plus a seed range. Rebuild it, extend it, or bisect a regression to the exact scenario that caused it.
Failures as queries
Ask the platform for more of what breaks your model. Evaluation results become generation parameters for the next dataset.
generate.ts — concept API
1// Concept API — the SDK is in design, not yet public2const dataset = await aurora.generate({3 world: 'warehouse_07',4 sensors: ['rgb', 'depth', 'lidar'],5 scenarios: 100_000,6 randomize: ['lighting', 'materials', 'objects']7})dataset — illustrative response
1dataset.status // 'generating'2dataset.frames // streaming frame handles3dataset.annotations // ['semantic_segmentation',4 // '3d_bounding_boxes', 'camera_pose']Platform
One substrate. Five layers.
Aurora Forge is the entry point, not the end state. Each layer of the platform compounds the ones below it — worlds feed generation, generation feeds evaluation, evaluation feeds generation again.
Aurora Forge
In developmentProgrammable generation of labeled, multi-modal training data from simulated worlds.
Aurora HardCase
Platform directionEvaluation failures expanded into targeted synthetic training scenarios.
Aurora Worlds
Platform directionA reusable, parameterized library of industrial environments.
Aurora Evaluate
Platform directionStructured scenario suites for measuring perception before deployment.
Aurora Compute
Platform directionThe distributed GPU substrate every layer above runs on.
The order is deliberate: generation creates the data advantage that makes every later layer stronger.
Why simulation
The physical world is too large to collect.
So we simulate it.
Physical AI needs experience across environments, objects, weather, sensors, failures, and edge cases. Much of that experience is rare, dangerous, expensive, or impossible to label in the real world. Simulation lets machines live through it computationally — before deployment, not after.
Rare
a pallet falling exactly once a year
Dangerous
a person stepping into a robot arm envelope
Expensive
night shifts of fleet-wide data collection
Unlabelable
per-pixel depth from a real camera
Request access
Build the world your machines need.
Aurora Forge is being built with a small group of robotics and perception teams. Tell us what you are working on and we will be in touch.
- Best fit today
- Teams training or evaluating perception for robots, AMRs, drones, or industrial vision.
- What early access means
- Direct collaboration on your worlds, sensors, and dataset requirements.