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 dev at this release, RelWithDebInfo build; Gazebo Jetty gz-sim 10.5.0 from ros-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 Gazebo gpu_lidar and imu sensors.

    • gz’s converter rejects the warehouse’s world-rooted URDF, so docs/release/comparison/make_gazebo_world.py writes 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.