Version the embodiment.
Package the robot with its meshes and textures, validate it once, and pin the immutable catalog version in every run.
robot/my-arm:v1Train Robots in the Cloud.Robotics Simulation Platform
Build robot simulation and reinforcement learning workflows in Python with Simulo’s SDK and CLI. Develop on your laptop. Run and scale without managing GPU infrastructure. Watch policies learn live, and keep every model, recording, and result.
- Bring
- Your robot, your world
- Author
- Normal Python, locally
- Run
- Managed GPUs
- Observe
- Logs, then a live view
- Retain
- Models, recordings, results
01 A live simulation and learning run.
The premise
Simulation should be the foundation of your robotics platform.
Robotics development spans robot assets, environments, learning, evaluation, compute, and evidence. Simulo connects them around simulation so the same job moves from local source to managed GPU execution and durable output.
Your inputs
Bring your robot.
Define your environments.
Start from a validated catalog asset or publish your own USD or URDF package. Then describe the scene and learning task in Python. Simulo resolves the pinned assets and creates the parallel environments when the cloud job starts.
Build the environment in code.
Compose terrain, props, lighting, sensors, and randomized scene state through the same typed Python interface.
scene.add(...)Define the reinforcement learning task.
Own the observations, actions, rewards, resets, and termination rules, then scale the task across parallel environments.
num_envs=384The lifecycle
From robot and environments to a trained policy.
Your embodiment and your world
Bring your own robot. Define the world around it.
Validate and pin your USD or URDF robot package, then build scenes, sensors, terrain, observations, actions, and rewards in Python. Simulo replicates that task across parallel environments when the job runs.
$ simulo asset publish ./my-arm --kind robot \ --name my-arm --entry robot.urdf✓ validated robot/my-arm:v1 robot = simulo.Asset.from_registry("robot/my-arm:v1")scene.add(simulo.Robot(asset=robot), at="/World/Robot")scene.add(simulo.Terrain.rough(), at="/World")One CLI command to managed GPUs
Submit the app. Simulo handles the GPU run.
The CLI packages immutable source, resolves version-pinned assets, uploads the job, provisions managed GPU infrastructure, and follows its logs. Application flags come directly from the training function signature.
$ simulo run grasp/app.py \ --num-envs 384 --max-iterations 600 --viewstream Packaging source… doneResolving robot/my-arm:v1… verifiedSubmitted train_grasp_policy → job grasp-7Kd2GPU worker ready · 384 envs · PPOTerminal and browser while it runs
Follow the run without losing the training loop.
Stream logs in the terminal or open the live 3D scene in a browser over WebRTC. Every view follows one job identity from queued through completion.
$ simulo logs --follow[train] iteration 284/600 reward 294.65 # illustrative[checkpoint] latest.pt saved $ simulo viewOpening live view for job grasp-7Kd2…Reward curve, illustrative
Durable outputs after completion
Keep the result, models, and evidence.
The completed job retains its result JSON, checkpoints, trained models, recordings, and published outputs. Download what you need, continue from a checkpoint, or export the policy for its next stage.
$ simulo result{"model": "grasp_policy.pt", "iterations": 600} $ simulo models grasp-7Kd2 best.pt$ simulo outputs --all -o ./job-outputs/✓ best.pt ✓ rollout.mcap ✓ evaluation.json02 / Author
Code is the interface
Real training.
Readable Python.
Declare the retry policy, resumable checkpoints, parallel environments, trainer, and output beside the task. The website shows the shape; the full robot and reward logic stays in your codebase.
Explore the SDKruns = simulo.Volume.from_name("grasp-runs", create_if_missing=True) @app.job( gpu="L4", timeout=60 * 60, retries=2, callbacks=[simulo.callbacks.ResumableCheckpoint(every=40)],)def train_grasp_policy( num_envs: int = 384, max_iterations: int = 600,) -> dict[str, Any]: env = simulo.LearningEnv( task=PaneGraspTask(), num_envs=num_envs, device="cuda", headless=True, seed=17, ) trainer = simulo.RLTrainer( env=env, algorithm="PPO", device="cuda", seed=17, ) stats = trainer.train(max_iterations=max_iterations) checkpoint = f"{runs.path}/grasp_policy.pt" trainer.save(checkpoint) trainer.close() env.close() return {"checkpoint": checkpoint, "num_envs": num_envs, **stats}03 / Run
$ simulo run grasp/app.py \\ --num-envs 384 --max-iterations 600 --viewstream01Packagesource + assets
02GPU worker384 envs
03Job recordlogs + outputs
One command to the cloud
The CLI enters the GPU lifecycle.
The lightweight client packages your exact source and pinned robot assets. Simulo provisions managed GPU infrastructure, pulls the execution runtime on the worker, and attaches logs and outputs to one job record.
Read the submit lifecycle04 / Observe
Evidence, while it matters
Watch the robot learn.
Use simulo logs --follow to stream logs and simulo view to open the live 3D scene in a browser. When it finishes, fetch the result with simulo result and the models and recordings with simulo outputs.
Job grasp-7Kd2 · illustrative Running
OverviewLogsModelsOutputs
reward_mean294.65
iteration 0iteration 600
latest.pt rollout.mcap evaluation.json
Built for iteration
A simulation-first platform built for robot learning.
Your robot and environments.
Use a validated catalog robot or publish your own package, then define the simulation world and task in Python.
Managed GPUs when the job needs them.
Submit from a lightweight local client. The large execution runtime and parallel environments stay on the worker.
One record from source to policy.
Source, pinned assets, logs, checkpoints, recordings, evaluation, and results remain attached to the job.
Start with a real robot task