🖥️ Simulators: MuJoCo, Isaac Sim, PyBullet
Train robots without breaking anything: high-fidelity physics simulation for VLA. MuJoCo at 2.7M steps/s, Isaac Sim with ray tracing at 94k FPS, and PyBullet for rapid prototyping — each has its own niche.
Detailed content
⚡ MuJoCo: 2.7M steps/s, the academic standard
The fastest physics simulator for training RL and VLA policies on CPU.
Main Concept
MuJoCo (Multi-Joint dynamics with Contact) is a physics engine optimized for simulating contact between rigid bodies and joints. Acquired by Google DeepMind in 2021 and released as open-source (Apache 2), it processes 2.7 million steps per second on CPU — making it feasible to train VLA policies with millions of episodes in hours.
✓ When to use MuJoCo
- ✓ Reproduce academic papers (dm_control, Gymnasium)
- ✓ Train RL at massive scale on CPU
- ✓ Simulate manipulation with soft, precise contact
- ✓ Use MJX for parallel GPU execution (JAX backend)
✗ When NOT to use MuJoCo
- ✗ Need for photorealistic rendering for visual sim-to-real
- ✗ Simulate native LiDAR/depth camera sensors
- ✗ Integrate directly with ROS2 without a bridge
- ✗ Simulate fluids or deformable materials
🎮 NVIDIA Isaac Sim: 94k FPS, ray tracing
Photorealistic simulation for high-fidelity sim-to-real transfer — the GR00T N1 environment.
The number that matters: 94,000 FPS
Isaac Sim runs the 94,000 frames per second with ray tracing on an NVIDIA A100 GPU. This means 1 hour of GPU time equals ~26 hours of real-time simulation, making it possible to use domain randomization with photorealistic textures at scale. NVIDIA’s GR00T N1 was trained entirely in this environment.
Isaac Sim is NVIDIA’s robotics simulation platform, built on Omniverse and PhysX 5. It offers real-time photorealistic rendering and can simulate thousands of robots in parallel using GPUs.
Platform evolution
Isaac Gym (discontinued)
NVIDIA's first massively parallel GPU RL environment. Precursor to Isaac Sim, without photorealistic rendering.
Isaac Sim + Omniverse
Integration with USD (Universal Scene Description) and real-time RTX ray tracing. PhysX 5 with GPU-accelerated simulation.
Isaac Lab + GR00T N1
Unified RL/IL framework on Isaac Sim. Training environment for NVIDIA's GR00T N1 model — a humanoid foundation model.
🐍 PyBullet: lightweight and open-source
A functional simulator on any laptop — the fastest way to run your first policy.
Quick start with PyBullet
import pybullet as p
import pybullet_data
# 1. Conectar ao simulador
p.connect(p.GUI) # ou p.DIRECT para headless
p.setAdditionalSearchPath(pybullet_data.getDataPath())
# 2. Configurar física
p.setGravity(0, 0, -9.81)
plane = p.loadURDF("plane.urdf")
# 3. Carregar robô
robot = p.loadURDF("kuka/kuka.urdf", basePosition=[0, 0, 0])
# 4. Loop de simulação
for _ in range(1000):
p.stepSimulation()
joint_state = p.getJointState(robot, 0)
p.disconnect()PyBullet is the Python wrapper for the Bullet Physics Engine. With a simple pip install pybullet, you have 3D simulation with a URDF loader, collision detection, and constraints—ideal for prototyping policies before moving to heavier simulators.
Tip: headless for training
Use p.connect(p.DIRECT) instead of p.GUI to train without a display — up to 10× faster because it does not render frames. Reserve GUI for visual debugging.
🔗 Gazebo + ROS2: native integration
The simulator with native ROS2 support—simulation and real-robot code are almost identical.
Gazebo (now "Gz") is the simulator integrated into the ROS2 ecosystem. Unlike MuJoCo (focused on RL), Gazebo simulates real sensors — depth cameras, LiDAR, IMU — and communicates with ROS2 natively via topics through the ros_gz_bridge.
✓ Advantages of Gazebo
- ✓ Identical ROS2 code in simulation and on the real robot
- ✓ Built-in virtual sensors (camera, LiDAR, IMU)
- ✓ Gazebo Fuel: repository of ready-made 3D models
- ✓ Native integration with Nav2 and MoveIt2
✗ Limitations
- ✗ Slower than MuJoCo for large-scale RL
- ✗ Non-photorealistic rendering (vs Isaac Sim)
- ✗ More involved configurations (SDF + plugins)
- ✗ Classic Gazebo vs Gz (incompatibilities)
🎲 Domain Randomization: variability for transfer
The technique that enabled the first successful sim-to-real transfer at scale.
Core Concept
Domain randomization randomly varies simulator parameters — textures, lighting, masses, friction, colors — during training. The policy learns to be robust to variations instead of memorizing the sim's perfect environment. It was the technique that enabled OpenAI to teach a robot to solve a Rubik's Cube in 2019.
Types of randomization
Visual Randomization
Vary object textures, background color, light position and intensity, and camera type. The policy shouldn't depend on specific colors to recognize an object.
Physics Randomization
Vary object mass, friction coefficient, joint damping, and actuator latency. Simulates real-world imprecision, where physical parameters are never exact.
ADR — Automatic Domain Randomization
Automatic curriculum: starts with small variations and progressively increases them as the policy improves. Implemented by OpenAI for the Dactyl project (robotic hand).
Tip: start simple, scale later
Don’t randomize everything at once — the policy may not converge. Start with minimal visual randomization (background color), verify that the policy still learns, then add physics. Use ADR to automate this curriculum.
🔄 Sim-to-sim: validation before the real world
Test in 2 different simulators before risking expensive hardware — a low-cost, powerful validation step.
Sim-to-sim is the practice of transferring a policy trained in one simulator (e.g., MuJoCo) to another simulator with different physics (e.g., Isaac Sim) as an intermediate step. If the policy fails in another simulator, it will fail on a real robot — but you found out without breaking anything.
Robot format conversion
# URDF → MJCF (MuJoCo)
python -m mujoco.mjcf.convert robot.urdf robot.xml
# URDF → USD (Isaac Sim / Omniverse)
from omni.isaac.urdf import _urdf
urdf_interface = _urdf.acquire_urdf_interface()
urdf_interface.parse_urdf(urdf_path, dest_path)
# Benchmark cross-simulator com SIMPLER
python eval_simpler.py \
--policy checkpoint.pt \
--env SimplerEnv-MuJoCo \
--n_eval_episodes 50
# Mesmo benchmark em Isaac Sim
python eval_simpler.py \
--policy checkpoint.pt \
--env SimplerEnv-IsaacSim \
--n_eval_episodes 50✓ Signs of a robust policy
- ✓ Similar success rates in MuJoCo and Isaac Sim
- ✓ Consistent behavior with different textures
- ✓ Tolerance intervals overlap across sims
- ✓ Failures are randomly distributed, not systematic
✗ Signs of overfitting to the sim
- ✗ 90% success in MuJoCo, 20% in Isaac Sim
- ✗ Policy stops at the same frame every time in the 2nd sim
- ✗ Consistent failures when changing the object’s texture
- ✗ Different behavior with the same URDF/MJCF
Minimum validation protocol
Always use N ≥ 50 episodes per environment to calculate confidence intervals (95%). With N < 20, variance is so high that you may confuse luck with robustness. Record videos of failed episodes — they reveal patterns that metrics do not capture.
✅ Module Summary
Next module
2.4 — ROS2: Middleware for Real-World Robotics