Skip to main content

​
What is Simulation?

Simulation on Cyberwave runs your robots, sensors, and workflows against a physics-backed digital twin instead of the real world. The same environment, the same SDK, the same models, just with cw.affect("simulation") swapped in for cw.affect("live"). It’s how you iterate on control code, validate ML policies, and stress-test missions without wearing out hardware.
Simulation and live modes share the same API surface. Code you write against a simulated twin deploys unchanged to the physical robot once you flip the affect mode.

​
What You Can Simulate

Any Digital Twin

Every twin in your environment (arms, rovers, quadrupeds, cameras) has a physics-backed simulated counterpart out of the box.

Custom URDF Imports

Upload your own URDF and 3D model to simulate hardware that isn’t in the catalog yet.

Virtual Sensors

Cameras, depth sensors, and IMUs render synthetic data from the simulated scene, using the same wire format as live sensors.

Whole Environments

Warehouses, labs, outdoor sites: build the scene once in the Environment Editor and reuse across simulation and live.

​
How You Build It

​
1. Set up the scene

Use the Environment Editor to drop twins, static objects, and sensors into a 3D space. Every environment supports an Edit Mode for design and a Simulate Mode for physics playback, with no separate sim project needed.

​
2. Drive the simulation

ModeUse it forReference
Dashboard Simulate ModeInteractive debugging, demosEnvironment Editor
cw.affect("simulation")Scripted runs, unit tests, CIPython SDK
Model evaluationBenchmarking a trained policyML Models
Workflow triggerScheduled sim sweeps, regression runsWorkflows
from cyberwave import Cyberwave

cw = Cyberwave()
cw.affect("simulation")

arm = cw.twin("so101-main")

arm.joints.set("shoulder_pan", 10, degrees=True)
arm.joints.set("shoulder_lift", -30, degrees=True)
arm.joints.set("elbow_flex", 60, degrees=True)

state = arm.joints.get_all()
print(state)

​
3. Use virtual sensors

Every sensor attached to a twin has a simulated counterpart that renders from the 3D scene. Pull a synthetic camera frame, run it through a perception model, and close the loop, exactly like you would in live mode. 
from cyberwave import Cyberwave

cw = Cyberwave()
cw.affect("simulation")

arm = cw.twin("so101-main")
frame = arm.capture_frame("numpy", sensor_id="wrist_cam")

model = cw.model("vlm/qwen-vl")
answer = model.ask(frame, prompt="Is the red block in the gripper's reach?")
print(answer)
Use virtual sensors to generate synthetic training data, verify camera placement before mounting a real one, or sanity-check a perception pipeline on controlled scenes.

​
4. Evaluate fine-tuned models in simulation

Before you deploy a fine-tuned VLA or VLM model to hardware, run it against the simulated twin to score it against a held-out set of tasks. This is the fastest way to compare checkpoints and catch regressions. 
from cyberwave import Cyberwave

cw = Cyberwave()
cw.affect("simulation")

arm = cw.twin("so101-main")
policy = cw.model("vla/pick-place-v3")

successes = 0
for episode in range(50):
    arm.reset()
    result = policy.run(arm, prompt="pick up the red block", max_steps=200)
    if result.success:
        successes += 1

print(f"Success rate: {successes / 50:.2%}")
Typical evaluation loops on Cyberwave look like:
  • Regression suite: replay known-good task prompts against every new checkpoint and compare success rates.
  • Distribution shift: randomise object positions, lighting, and camera angles in the Environment Editor to measure robustness.
  • Sim-to-real gap: run the same policy in sim and live back-to-back to quantify the delta before broad deployment.

​
5. Automate with workflows

Wire simulation runs into Workflows so every new model checkpoint, every config change, or every scheduled sweep produces a fresh evaluation report. Workflows can run sim in the cloud on demand, with no local GPU required.

​
Simulation Modes

Cyberwave offers two simulation modes on the platform today, each tuned for a different phase of development. Both run against the same digital twins in the same environment, so you can move between them without rebuilding scenes.

​
Playground

The Playground is an in-browser simulation that runs inside the Simulate tab of the Environment Editor. It applies lightweight frontend physics with gravity and basic rigid collisions. URDF twins use their <collision> geometry as collision sources when available, with a fallback collider generated automatically when collision metadata is missing. Use Playground for fast visual iteration: verifying twin placement, sanity-checking motion paths, demoing behaviours, or teaching yourself the API. No export step, no extra tooling, just open the environment and hit Simulate.

​
MuJoCo

MuJoCo is the full-fidelity physics option. From any environment in the Environment Editor you can export the scene to MuJoCo with one click, either as a standalone XML or a ZIP that bundles the XML with all referenced assets. Cyberwave composes the scene from every twin’s universal schema, honours per-twin overrides (color, fixed-base behaviour, exported mass in kilograms), and flags environments whose asset inertial data is incomplete with an Export warning. Use MuJoCo when you need contact-rich dynamics, rigorous evaluation of trained policies, reinforcement-learning rollouts, or reproducible sim runs outside the browser.

​
Where to Go Next

Environment Editor

Build the scene your simulation runs in.

Digital Twins

Understand the twin layer that powers both sim and live.

Train a VLA Model

Tutorial: collect data, fine-tune, and evaluate in simulation before deploying.