Benchmark

This page reports representative timing comparisons between RaiSim and another widely used multi-body physics engine (MuJoCo) on articulated-dynamics workloads, and documents the environment in enough detail to reproduce the numbers. For general tuning guidance, see Performance.

Environment

All numbers on this page were collected on a single machine with the following configuration.

Component	Detail
Machine	Apple MacBook Air (MacBookAir10,1), Apple M1 SoC, 8 CPU cores (4 performance + 4 efficiency), 8 GB unified memory.
Operating system	macOS 26.5.1 (build 25F80), arm64.
Compiler	Apple Clang 21.0.0 (Xcode toolchain), C++20, target arm64-apple-darwin.
RaiSim build	Current optimized RaiSim build, CMAKE_BUILD_TYPE=Release (-O3 -DNDEBUG) with -mcpu=apple-m1.
MuJoCo build	MuJoCo 3.4.1, compiled from source as part of the benchmark suite (same compiler and Release flags).
Threading	Single threaded. Both engines run the simulation loop on one core; no multi-threading or SIMD batching across bodies is used.
Metric	Wall-clock seconds for the timed simulation loop of each scene (scene construction is excluded). Lower is better; Speedup (R/M) is the MuJoCo time divided by the RaiSim time.
Settings	Each benchmark uses its default arguments (the per-benchmark step counts listed below). The RaiSim and MuJoCo variant of every benchmark is configured with matching scene parameters and the same integration timestep, so the two engines simulate equivalent scenes.

Reproducing measurements

The unified RaiSim/MuJoCo comparison runner belongs to the closed-source RaiSim engine repository and is not included in public raisim2Lib releases. Public users therefore cannot rebuild that exact comparison binary from this repository.

To measure the shipped binary on your own hardware, build the public timing-oriented examples in Release mode and run them one process and one thread at a time. See Build, Test, and Benchmark and Performance for commands, available targets, and comparison guidance. The table below records the maintainer-run environment and results; it is not a claim that the internal benchmark source is part of the public package.

What the benchmarks simulate

Each scene is described below with its articulation (joint types and degrees of freedom), its collision/contact content, the integration timestep, and the number of simulation steps timed. “DOF” is the number of generalized velocity coordinates the dynamics solves for. A floating base contributes 6 DOF (3 translation + 3 rotation).

Benchmark (id)	Steps	Scene details
chain10_speed	100,000	One articulated chain with a fixed base and 10 links joined by 10 spherical joints (3 DOF each) → 30 DOF. Each joint has a spring-damper. No collision geometry (the link spheres are visual only), so there is no contact — this is pure articulated forward dynamics. Timestep 0.001 s.
chain20_speed	100,000	Same as chain10_speed but 20 links and 20 spherical joints → 60 DOF. No collision, no contact. Timestep 0.001 s.
anymal_standing	1,000,000	One ANYmal quadruped: floating base + 12 revolute joints = 18 DOF, under PD position control. It stands on a flat ground plane. ANYmal’s collision geometry is primitive shapes (a trunk box plus cylinders and spheres on the legs); the four feet rest on the ground, giving about four persistent contacts. Friction coefficient 0.8, timestep 0.002 s.
anymal_falling	100,000	The same ANYmal (18 DOF), but no ground is added — the robot falls freely under gravity. There is no contact, so this isolates floating-base articulated dynamics. Timestep 0.002 s.
heightmap_anymal_speed	200,000	One ANYmal (18 DOF) on a procedurally generated fractal height-map terrain (20 m × 20 m, 100 × 100 samples, 3 fractal octaves). Contacts form between the feet and the terrain cells. Timestep 0.002 s.
primitive_speed	100,000	No articulated system. 32 rigid bodies — 16 boxes (0.4 m cubes) and 16 spheres (radius 0.15 m) — arranged in a 4 × 4 grid, each sphere stacked above a box, dropped onto a flat ground plane. Contacts are box–ground, sphere–box, and box–box primitive pairs. Timestep 0.002 s.

Results

RaiSim is faster than MuJoCo across these articulated-dynamics benchmarks. The charts below show both the absolute timings and the relative speedup.

RaiSim vs MuJoCo (single thread, Apple M1, default args)

Benchmark	RaiSim	MuJoCo	Speedup (R/M)
Chain20 speed	0.434 s	2.708 s	6.24×
Heightmap ANYmal speed	1.035 s	4.371 s	4.22×
Primitive speed	3.037 s	10.678 s	3.52×
Chain10 speed	0.214 s	0.751 s	3.50×
ANYmal standing	3.855 s	11.580 s	3.00×
ANYmal falling	0.189 s	0.464 s	2.45×

Absolute times depend on hardware, compiler, and scene configuration, so treat them as relative magnitudes rather than fixed specifications.

Why RaiSim is faster here

RaiSim wins these benchmarks because it has better methods for articulated systems. Its articulated-system dynamics and contact solver are designed specifically for jointed mechanisms, so simulating chains, legged robots, and other articulated systems is more efficient. Raisim has O(n) articulated system solver that can even handle contact properties as well, whereas other physics engines use O(n^3) solver due to inversion of mass matrix.