v0.2.0 compared with Gazebo Jetty: the sample AMR¶
Roadmap item 0.2-H10 asks for “comparison notes against Gazebo Jetty for the AMR demo (factual, with method)”. These are measurements of one scenario on one machine, not a general verdict.
Method¶
Machine: Intel Core i9-13900H laptop (20 hardware threads), 30 GB RAM, Intel Iris Xe (Mesa 26.0.8), Ubuntu 26.04, ROS 2 Lyrical. Measured 2026-10-25.
Versions: Lagrange
devat this release, RelWithDebInfo build; Gazebo Jetty gz-sim 10.5.0 fromros-lyrical-gz-*, with gz-physics 9’s DART plugin (its log names the engine it loads).Scenario: the sample AMR (
assets/robots/amr_diffdrive/amr_diffdrive.urdf) in the sample warehouse (assets/worlds/warehouse_small/warehouse_small.urdf), physics step 1 ms, standard gravity, the robot standing still (no drive command in either), 60 s of simulated time, headless, as fast as possible.Gazebo world:
The robot comes from
gz sdf -p amr_diffdrive.urdf. Its 2D lidar (720 beams), 3D lidar (16 × 900) and IMU become Gazebogpu_lidarandimusensors.gz’s converter rejects the warehouse’s world-rooted URDF, so
docs/release/comparison/make_gazebo_world.pywrites its boxes as one static model, with the same 1 ms step.Run with
gz sim -s -r [--headless-rendering] --iterations 60000.Gazebo renders a sensor only for a subscriber, so the sensor runs had a subscriber on each lidar topic. It received 601 scans from each lidar (10 Hz over 60 s).
Lagrange:
lagrange determinism ... --no-demo --seconds 60. That runs the simulation twice and hashes the state every 100 ms; the time per run below is half the wall time, so it slightly over-counts Lagrange’s cost.Physics only:
--domain sensors=off(ground-truth substitute).With sensors: the CPU lidar (Tier 0, Embree, all cores) and the IMU.
Start-up: the wall time of a run of one step (Gazebo
--iterations 1; Lagrange--seconds 0.1). It is subtracted to get the stepping time. Each figure is the median of 2 or 3 runs.
Results¶
Gazebo Jetty |
Lagrange v0.2 |
|
|---|---|---|
Start-up to first step |
2.4 s (2.6 s with rendering) |
0.015 s per run |
Physics only, 60 s simulated: wall time |
5.8 s |
0.57 s per run |
Physics only: stepping time, real-time factor |
3.4 s, about 18× |
0.56 s, about 107× |
Physics and sensors, 60 s simulated: wall time |
6.9 s |
1.22 s per run |
Physics and sensors: stepping time, real-time factor |
4.3 s, about 14× |
1.2 s, about 49× |
Peak memory (whole process) |
139 MB / 265 MB (with rendering) |
58 MB / 66 MB (two runs in one process) |
Two runs bit-identical |
not measured |
yes: 601 state hashes over 60 s |
The demo itself (Lagrange, driving, through the Python bindings): 60 s simulated in 1.54 s with the lidar on the GPU (Tier 1), a real-time factor of 39 (criterion 9 asks for at least 1).
What the numbers do and do not say¶
Different engines. Gazebo stepped DART; Lagrange steps MuJoCo 3.12. Most of the physics difference is the engine, not the framework around it. Gazebo with MuJoCo would be the like-for-like comparison, and is not in Jetty.
Different lidars. Gazebo renders its lidars on the GPU through OGRE 2 (one depth render per scan). Lagrange’s CPU lidar casts exact rays against the collision shapes, Embree-culled, on all 20 threads. Gazebo’s lidars see visual geometry; Lagrange’s see collision geometry. In this world the two are the same boxes.
Gazebo does more per step that is not measured here: its transport (gz-transport), scene broadcasting, and the generality of its entity-component system. Lagrange’s run had no viewer and no ROS bridge.
Only this scenario. One small robot, seven boxes, a still robot. Large worlds, many robots, cameras and contacts in clutter are not covered.
Reproduce: the commands above, in this order: the Gazebo world with
make_gazebo_world.py, then the two simulators. Expect run-to-run variation of a few percent.