Robot Native Engine

Robots are not plugins. RNE is a Rust robot-native game engine for deterministic simulation, embodied AI, synthetic sensors, and policy evaluation.

RNE combines a headless, replayable simulation core with real wgpu rendering. Worlds hold robot, sensor, actuator, agent, and episode entities; simulation needs no renderer, and ROS 2 is an optional adapter, not a core dependency.

Real simulation showcase

Hands-on joint sliders, scene editing, and RGB/depth/LiDAR views: start the Robot workbench with cargo run --release --locked -p robot_workbench.

Every frame below is rendered by wgpu from deterministic simulation or pinned camera state; gates and regeneration commands are in README showcase acceptance.

Real indoor 3DGS · mobile manipulation A real photo-derived interior (Voxel51 Dr Johnson 3DGS) bound to real cameras and landmarks by a fail-closed validation fixture. The 10-link PBR robot completes a floor-level friction grasp, 0.401 m lift, 1.559 m transport, and placement within 0.049 m; live wrist RGB-D self-masks the robot and drives the final approach without payload truth. metadata · source
OpenArm v2 · bimanual control 18-axis typed feedback, an IK-solved pick / handoff / place cycle gated on real fingertip contact, and exact Rapier replay over 1,400 steps. metadata · source	Factory inspection Official G1 link meshes, point-and-confirm gestures and deterministic replay. The robot does not walk: it stays within 6.4 cm of where it starts, and all three markers are placed within reach of that spot. metadata
Office AGV Shared-aisle yield, dock pickup, cargo transport, and desk placement without contact or early drop. metadata	PLATEAU UAV · RGB-D flight A visible multirotor flies 76.6 m over imported city geometry with 12.21 m building clearance, zero collisions, and synchronized onboard RGB-D. metadata · source

Highlights

Area	Included	Docs
City simulation	PLATEAU import, traffic, LiDAR, RGB-D, OSM HUD	docs, ex. 46–47
Vehicle dynamics	Bicycle/Ackermann, tire saturation, suspension, road excitation	docs, ex. 49–51
Quadruped locomotion	Official Go2, torque control, disturbances, steering	docs, ex. 52–65
Humanoid locomotion	Official G1 23-DoF, balance, learned stride, CEM eval	docs, ex. 39, 63, 67, 68
Manipulation	PBR/3DGS mobile manipulator, friction grasp, Dex3 hands	docs, ex. 32, 40–42, 89
Deformables	XPBD cable and cloth, deterministic headless replay	ex. 43–45
More demos	Localization, native planning/dynamics/legged/WBC/OC, Go2 jump	docs

Independent validation wanted

RNE remains below 1.0 until outside projects reproduce tasks and pass the shipped conformance kits (native bundles include the tools; no source checkout needed).

Only v0.4.0 official assets qualify; if that page lacks the native archives and SHA256SUMS yet, prepare the checklist but do not open an evidence issue (v0.1.0 does not qualify).

• External project reproduction + Failure Capsule
• Installed flagship reproduction
• Third-party plugin conformance
• External physics/simulator/hardware/accelerator conformance

See the external evidence intake guide. Opening an issue is only the start of review: it does not imply acceptance; in-repo reference implementations do not count as independent evidence.

Vehicle dynamics at the grip limit

Same controller, two plants: the dynamic car's trail turns red once the front axle saturates. No-slip follows the line; the dynamic car runs wide past tire grip. Vehicle dynamics.

Navigation, SLAM, and multi-robot

The magenta route is what plan_path returned over the corridor's own collision geometry, and the amber band is the costmap inflation that pushed it off the centre line: the dock and the desk stand in a 2.3 m corridor, so the 6.63 m plan swings 0.82 m wide where a straight line would be 5.95 m and impassable.

rne_nav/rne_slam: deterministic, ROS-free costmaps, a transform tree, A*/DWA/pure-pursuit, multi-robot avoidance, an EKF, 3D ICP, and online 2D SLAM with loop closure and AMCL (a ROS 2 adapter maps to Nav2). Details: Navigation, SLAM.

Logistics across floors

Goods-in to delivery A forklift AGV takes a case off a stand, calls the lift, rides up with the load and sets it down on the floor above. The mast is a prismatic joint with a position servo and the case is an ordinary dynamic body throughout: it moves 0.038 m on the tines across the whole carry. source

Calling and riding a lift The call button reads solved contact force from the robot's own body, the car and doors are rne_nav::Elevator state, and the car carries the robot by ordinary contact rather than by parenting it. source

Two trucks, one lift A truck on each floor and the lift as the conveyor between them. The ground-floor truck sets the case on a stand inside the car and backs out; the car goes up with only the case; the upper-floor truck forks it out and delivers it. A light-curtain check holds the doors while anything is in the doorway, and the case moves 6 mm and 1.5 mm on the two trucks' tines. Driving and turning are commanded; the wheels are not modelled. source

G1 locomotion

A full backflip in native RoboSim/Rapier: 62.5 µs step, 21 convex body colliders with self-collision, bounded joint effort and gravity only — no imposed base trajectory, no root wrench, no RL. It lands on its feet and is still standing 15 s later. Peak joint speed is 1.039x the URDF rating, under the unchanged 1.05 gate.

The GIF replays a recorded native rollout — the renderer applies the recorded poses and takes zero physics ticks, and the model and recording hashes are checked before the first frame. The controller comes from a parameter search, not a learned policy. This is a simulator result; hardware is unvalidated. Details and the full evidence trail: docs/G1_CONTACT_BACKFLIP.md.

Walking is a separate and much weaker claim. Example 68 holds the v0.3 sustained envelope upright for 3000 ticks / 50 s, turning the commanded way the whole time (+1.6 / −2.2 rad) without holding its heading target, but that walk goes backwards: the knees bend toward the way the robot faces while the body travels the other way, because the search that found its torque overlay scored distance without a direction. Measured along the facing, its 8 s windows are -0.16 m and -0.22 m.

UnitreeG1TorqueOverlay::FORWARD_STRIDE walks forwards, straight and without turning: +0.14 to +0.16 m per window, travel within a mean 0.20 rad of the facing. It holds only under the exact conditions it was trained in. A constant 1e-6 N·m of extra hip-yaw torque tips it over, so it cannot yet be steered or stopped. This is a stability-and-direction claim, not a navigation one. Details: docs/G1_LOCOMOTION.md.

Quickstart

git clone https://github.com/rsasaki0109/RoboSim.git
cd RoboSim
cargo run -p hello_world --example 00_hello_world
cargo run -p falling_cube --example 01_falling_cube

For a complete local validation, run cargo run -p xtask -- ci (the long smoke gate splits into manipulator/locomotion/assets/media partitions, e.g. cargo run -p xtask -- ci-smoke media). The headless asset CLI, replay, and determinism-check commands, and the full example index, are in examples/README.md.

Independent integrations

The native release archive includes a one-command installed product proof:

./bin/rne-flagship-proof flagship-proof --cross-backend \
  --measure-on "lab-workstation-a" --verify-installed-bundle .

It runs the same indoor TaskSpec through Rapier and bundled MuJoCo, verifies both replays plus the Failure Capsule against SHA256SUMS, and writes a SHA-256-bound report with no source checkout, renderer, or network needed. Details: flagship validation.

Third-party plugins, physics backends, adapters, and external task reproductions go through the fixed external evidence intake; submission never implies acceptance.

Architecture

The workspace is split by responsibility:

• rne_core/rne_math/rne_ecs/rne_world/rne_robot/rne_sensor/rne_ai/rne_data: schedules, ECS, spatial math, entity/robot control, sensors, learning interfaces, typed data streams.
• rne_planning/rne_dynamics/rne_legged/rne_wbc: backend-neutral joint-space planning, articulated dynamics, legged templates, whole-body control.
• rne_physics/rne_physics_rapier and rne_render/rne_render_wgpu: backend-neutral traits plus the Rapier and wgpu implementations.
• rne_asset/rne_plugin/rne_traffic: assets, plugin interfaces, backend-neutral traffic.
• adapters/ros2: ROS 2 integration; core crates remain ROS 2-free.

Determinism and testing

Simulation uses SimClock, explicit seeds, stable entity ordering, and replay digests; headless examples/tests never initialize a renderer; public APIs use explicit units (_m, _rad, _s, _hz); physics backends never leak engine-specific handles through core traits.

Standard checks:

cargo fmt --all
cargo clippy --workspace --all-targets -- -D warnings
cargo test --workspace
cargo run -p xtask -- ci-headless
cargo run --locked -p xtask -- flagship
cargo run -p xtask -- ci

Python and ROS 2 adapters

The Python adapter exposes native environments for policy experiments:

python3 -m venv .venv
.venv/bin/pip install maturin
.venv/bin/maturin develop -m crates/rne_py/Cargo.toml
.venv/bin/python examples/04_python_policy/run.py

ROS 2 is optional, isolated under adapters/ros2; see the bridge README for setup.

Documentation

• Architecture · Roadmap · OSS parity · Plugin SDK · Browser viewer
• Conformance/readiness: physics · hardware · simulator · OpenArm cross-sim · compat corpus · support · 1.0 readiness · flagship validation
• Indoor autonomy: multi-floor navigation
• Physics: height field terrain · collision bake · arm position control
• Locomotion: G1/workbench/splat bg · Go2 · frontier plan · sensors
• Case studies: Tsukuba/full/3DGS bg · SSL 2v2/adapter
• More demos · Examples · Changelog

License

Licensed under either the Apache License 2.0 or the MIT license, at your option.