The canonical forward-looking product strategy is PRODUCT_STRATEGY_2026_2029.md. It defines the north star, sequencing, release gates, 1.0 readiness criteria, and immediate 12-week plan. The sections below retain detailed milestone history and implementation evidence; when a forward priority or version label conflicts, the product strategy takes precedence.
The next product arc closes the common workflow gap with open simulators such as Choreonoid, Gazebo Sim, and AWSIM: one asset description should be runnable headlessly, controllable through typed I/O, recordable, replayable, and inspectable without a commercial engine. The baseline and scope are tracked in OSS_PARITY.md.
RNE's differentiation is not a longer importer list. The target workflow is: define one robot task once, run it against interchangeable backend-neutral physics implementations, scale the same task into headless evaluation or RL, and turn every failure into portable evidence that another machine can verify.
The labels below are feature tracks and do not require an early public version or Git tag. Each track advances only when its machine-readable exit evidence is available.
| Track | Outcome | Main exit evidence |
|---|---|---|
| 0.2 Trust and benchmark | Backend-neutral determinism contracts, audited capability inventory, timing-free benchmark aggregation, and portable Failure Capsules | xtask capability-report, xtask benchmark, xtask failure-capsule verify, workspace/headless CI |
| 0.3 Interchangeable dynamics | Promote the optional MuJoCo spike into conformance-covered rigid bodies, articulations, actuation, canonical contact evidence, and control-engineering plant/controller validation while retaining Rapier and analytic backends | The same fixtures run through each advertised backend; exact same-runtime and registered cross-backend tolerance contracts pass; OpenArm step/ramp/chirp, plant-model, PID/state-space, and robustness reports retain the first divergent measurement, realization, or plant response in a verified Failure Capsule |
| 0.4 Scalable learning | Ordered vector environments, deterministic reset streams, batched observations/actions, and accelerator adapters outside core | Single-environment replay matches its lane in a batch; throughput reports name hardware, batch size, and scenario |
| 0.5 Perception and data | Timestamped joint/actuator feedback, IMU, RGB-D/LiDAR datasets, renderer-specific capture adapters, calibration manifests, estimator evidence, and offline evaluation | Sensor timing/calibration/noise/failure contracts and dataset hashes reproduce headlessly; stationary and prescribed-motion IMU fixtures retain nominal and minimized estimator-failure evidence without making rendering a core requirement |
| 0.7 Flagship robot-native scenario | One manipulation-plus-mobility scenario that combines traffic/world semantics, perception, policy evaluation, replay, and browser inspection | A clean checkout reproduces success and a deliberately injected failure from one capsule on Windows and Linux |
The concrete sensor and control-engineering sequence, report contents, and definition of done are tracked in the External product proof plan. The current mobile-robot-to-Physical-AI implementation sequence, researched plant/sensor model choices, and cross-backend benchmark gates are tracked in Mobility Physical AI Foundation.
The promotion gates are measurement integrity, estimation validity, plant integrity, identification validity, closed-loop performance, and portability. This keeps sensor work focused on calibrated controller-visible observations and dynamics work focused on identifiable plants, stability, saturation, and robustness—not on adding catalog breadth or accepting terminal-pose-only demos.
Contest scoring starts with the Tsukuba Challenge 2026 confirmation run, not a city-scale photoreal clone. See TSUKUBA_CONFIRMATION_RUN.md: the first exit is the official stop/cone/e-stop geometry, headless.
The shortened full-run analog scores three signalized crossings with the same official stop-line box on a ~10 m sidewalk segment. See TSUKUBA_FULL_RUN.md.
The next contest analog is RoboCup SSL Division B 2v2 field geometry, not a grSim protocol clone. See SSL_SMALL_PITCH.md.
The UDP adapter for ports 10300-10302 lives in adapters/ssl (SSL_ADAPTER.md); example 87 couples decoded commands into the small-pitch plant.
The Grove-G1 analog is a 0.5 m park then Dex3 pick/place workcell, not a Nav2 or MoveIt port. See G1_WORKBENCH_MISSION.md.
Optional Tsukuba viewer backgrounds can use committed 3DGS splats without changing confirmation-run scoring. See TSUKUBA_3DGS_BACKGROUND.md.
Optional Tsukuba viewer backgrounds can also composite a PLATEAU LOD1 fixture without changing confirmation-run scoring. See TSUKUBA_PLATEAU_BACKDROP.md.
The v0.5 track is now in progress. Dataset bundle v1 streams records with payload/shard/manifest hashes, preserves capture/availability latency, calibration, noise seeds, assets, domain-randomization decisions, and explicit drop gaps. Offline depth-pair evaluation is renderer-free and recomputes committed metrics from the bundle. RGB8/depth/LiDAR plus dataset-native IMU/transform/action/outcome/annotation codecs are bound and headless fixtures freeze their complete shard digests. The WGPU-backed Unitree G1 head camera now streams a TaskSpec-bound twelve-frame RGB/depth bundle with explicit calibration, latency, noise, and renderer identity; both platform evidence jobs require and upload it instead of accepting the CPU fallback. Completed clean-run platform provenance remains required before treating that matrix as external evidence.
The reference capture now records a successful seeded diff-drive run with action, outcome, transform, IMU, LiDAR, RGB, sensor depth, and ideal scene depth streams. Its v2 470-record manifest/shard summary and its 17-frame offline depth report are frozen and regenerated by the local headless gate plus the Windows/Linux evidence matrix. The known 5 mm depth bias remains below the 10 mm gate across 52,224 compared pixels. The workflow definition enforces cross-platform equality; a completed clean CI run is still required before treating that equality as external platform evidence. A renderer-specific capture remains separate evidence rather than a headless requirement, so CPU-only simulation and offline evaluation stay renderer-free.
The v0.6 foundation has started without pulling hardware concerns into core.
rne_hardware_gateway binds the same TaskSpec to playback, shadow, HIL, and
live authority modes, accepts injected monotonic host ticks, bounds every
queue, and fails closed on deadline, stale data, disconnect, actuator limit,
clock regression, queue overrun, and emergency stop. A golden over-limit
session freezes schema-v1 events and final state. A byte-bounded versioned
process protocol and deterministic child-process mock now freeze an injected
disconnect with both device watchdog and gateway stops. The remaining process
fault matrix now passes six child-process cases: deadline, disconnect,
reconnect, stale command, limit, and emergency stop. A TaskSpec-bound shadow
comparator records ordered tolerances, separate host/SimClock timestamps, first
divergence, and a revalidated golden verdict. Failure Capsule create/verify preserves these
typed artifacts beside the corresponding simulation replay and rejects missing
TaskSpec or tampered aggregates. LeKiwi + SO-101 is now the selected reference:
the brand-specific adapter pins LeRobot v0.6.0, freezes a base-only TaskSpec and
unit mapping, holds the observed arm pose, and passes strict child-process
bridge, shadow-authority, and independent-watchdog tests. A profile-bound host
runner now turns the actual Open/poll/actuate/zero-stop/Close exchange into one
validated artifact, distinguishes mock from physical device identity, and
refuses a clean completion with authority, pending output, or a safety latch.
A versioned base-only physical-evidence manifest and staged verifier now prevent
mock, mixed-device, incomplete safety, unverified dataset, or checklist-only
output from satisfying the reference-device exit. A real LeKiwi shadow, HIL
safety matrix, and low-speed live run remain open. That reference-device exit
is necessary but not sufficient for the flagship physical gate: the 30 Hz
base-velocity TaskSpec is not the release flagship TaskSpec/controller. An
explicit content-addressed rate/observation/action projection, elevated
parent-controller shadow, and bounded live success/failure are also required.
The first v0.7 flagship slice is also integrated. cargo run --locked -p xtask -- flagship coordinates imported mobile-lift assets, RGB-D inspection,
signal-controlled traffic, navigation, and friction pick/place in one fixed-step
runner. It emits a passing seven-contract report, minimizes a seeded
perception blackout from three active dimensions to one, verifies the replay
and Failure Capsule, and writes a self-contained browser inspector. Windows and
Linux run the same command in CI. The runtime-gated xtask flagship --cross-backend path now executes the identical TaskSpec and policy on Rapier
and native MuJoCo 3.9, requires exact task/contract outcomes, compares nine
named unit-bearing tolerances instead of cross-solver hashes, and uploads the
verified comparison report from the dedicated Windows/Linux MuJoCo job.
Cross-backend report schema v2 additionally executes the same minimized
perception blackout on both engines, requires the same first contract violation
at zero-step and zero-nanosecond delta, verifies both replays, and retains both
failure reports in the shared Capsule.
The v0.8 ecosystem track starts with signed release provenance. Tag and manual
release rehearsals now attest each native archive and ABI3 wheel through GitHub
OIDC/Sigstore using SLSA v1 provenance. The tag publish job verifies every
subject before release creation, and xtask release-check enforces the
machine-readable release/artifact-attestation.toml trust policy. Platform
jobs retain the exact signed bundles, and the 1.0 readiness audit replays their
cryptographic verification against the exact repository, workflow identity,
tag, source and signer commit, predicate, issuer, runner class, and archive
digest before accepting a strict schema-v1 receipt. Each platform now also
signs a separate archive-install report whose digest chain fixes the archive,
extracted release report, SHA256SUMS member graph, and twelve-check rehearsal;
readiness manifest v4 freshly verifies both signed subjects and audits
third-party accelerator adapters without weakening the external-system gate.
The installed accelerator conformance CLI also generates a dependency-free
protocol-v1 authoring scaffold. Release rehearsal creates it from the packaged
binary and runs its bounded Python fixture through the same process kit. This
proves the clean-install authoring route only; the fixture cannot count as the
independent accelerator, backend, or hardware evidence required for 1.0.
Its canonical schema-v1 self-manifest freezes every generated file identity;
future incompatible scaffold changes must retain v1 and add a new schema.
The installed release CLI now also exposes rne-asset plugin check, a
standalone controller-plugin conformance runner with a versioned,
content-addressed report and deterministic reset replay. Release rehearsal runs
the kit against the bundled reference shared library on both tier-1 platforms.
The host-independent rne_plugin_sdk now owns the C-ABI definitions, while the
offline scaffold vendors the exact SDK module. Installed rehearsal generates,
builds with warnings denied, loads, and conforms a fresh controller plugin.
The installed bundle now also ships rne-hardware-conformance and a fixed-
binding process mock. The content-addressed schema-v1 report executes nine
TaskSpec, protocol, authority, and fail-closed cases against any external
adapter executable; the same catalog passes the Rust mock and Python LeKiwi
bridge, and both tier-1 release rehearsals rerun it from installed artifacts.
The publishable rne_physics_conformance authoring crate now gives external
Rust backends a distinct content-addressed schema-v1 report. Its immutable
nine-check catalog accepts arbitrary backend identities, fixes unit-bearing
tolerances in the kit, rejects capability overclaims, and binds Failure Capsule
evidence to the exact implementation subject. The existing built-in comparison
runner is retained as rne_physics_conformance_suite; independent third-party
certification remains a v0.9 exit gate.
Readiness manifest v2 now requires that future independent certification retain
the exact tested subjects rather than only a passing JSON report. It binds
controller libraries and manifests, physics implementation/source bundles, and
simulator adapter bytes plus TaskSpec, runtime manifest, and world/model/config
files, or hardware adapter bytes plus TaskSpec and normalized launch contract back to the
report's content identity and external source revision.
The expanded v0.9 compatibility slice adds an installed, content-addressed
corpus for thirty-six historical/current fixtures spanning TaskSpec identities,
checkpoint, generic/behavior/scenario replay, dataset, renderer capture, all
ten frontend protocol-v1 message families, controller C ABI,
plugin-conformance report, controller-scaffold contract, historical migration,
Failure Capsule, TaskSpec-bound hardware session, and physics artifacts.
rne-compatibility runs every current typed reader, proves
fail-closed handling of a deterministic future schema and unknown field, and
verifies byte-exact frontend/dataset payload round trips with malformed-input
rejection. Release rehearsal requires the same corpus after extraction on both
tier-1 platforms. The 1.0 readiness audit also replays the source corpus,
rechecks every historical Git revision/tree/blob, and requires the retained
report to equal that fresh execution rather than trusting its pass flags. The
language-boundary slice ships a C/C++ header, freezes the
64-bit ABI layout and ten required symbols, and verifies 24 Python exports and
their exact call shapes from source CI and the installed ABI3 wheel. This
advances the freeze but does not replace external-use or six-month stability
gates. The final conditions are tracked by release/one-zero-readiness.toml
and audited with cargo run --locked -p xtask -- release-readiness --as-of YYYY-MM-DD. Its nine-check schema-v1 report currently remains ineligible;
ONE_ZERO_READINESS.md defines the evidence pack and
promotion mode. xtask readiness-pack init safely creates that pack on an
external disk from the honest baseline, while readiness-pack stage stores
individual files and emits their canonical SHA-256 TOML references without
claiming third-party independence or promotion eligibility. The fixed
external-intake registry and required issue forms expose the three real
third-party evidence routes while keeping human independence review and the
typed readiness audit authoritative.
The history matrix also binds the introducing TaskSpec v1, dataset bundle v1, and Failure Capsule v1 revisions. The installed dataset case reconstructs its original binary shard and reruns stream/gap/digest/offline-evaluation checks; TaskSpec and Failure Capsule require exact typed round trips. Future public schema transitions still require a migration or explicit required-rerun case.
Frontend protocol v1 history is bound separately to its introducing commit and
the first committed full ClientHello golden. The source/current golden blob
must remain identical, while installed validation repeats exact wire round
trips, negotiation, and malformed-input rejection.
The historical matrix retains the original schema-v1 case and restores actual 7-tick, sensor-bearing schema-v1 and schema-v2 artifacts as v3. It binds each source revision/tree and source/current digest, preserves the v2 depth frame, and compares complete normalized state within the registered tolerance. The Rust surface now has a fixed 31-crate baseline registry. CI verifies the recorded commit/tree, exact package paths, and pinned semver-checks version before applying patch-level compatibility rules; moving PR bases cannot erase an accepted API from history.
The 0.2 foundation deliberately keeps performance timings separate from stable
correctness evidence. DeterminismContract describes exact, tolerance, or
outcome-level promises; benchmark reports embed those promises and hash only
stable content. Failure Capsules reference existing generic or behavior replay
artifacts instead of inventing a second action schema. The MuJoCo adapter stays
publish = false and default-off until its advertised capabilities join the
shared conformance catalog.
Roadmap version labels below describe feature tracks, not published crate versions. Several v0.15/v0.16-track capabilities landed before the v0.14 release was cut. M0 consolidates that work into one auditable v0.14 release candidate; version numbering is rebased from the code actually shipped after that point.
| Milestone | Target | Outcome | Exit gate |
|---|---|---|---|
| M0 | Aug 2026 | Parity consolidation and v0.14.0-rc.1: split reviewable history, replay-input integrity, transactional external-simulator mirroring, bounded/versioned runner transport, pinned reproducible CI, current docs and changelog |
fmt, workspace Clippy, workspace tests, explicit headless tests, parity catalog, and 10-seed Behavior CI all pass from a locked dependency graph; release candidate is reproducible from a clean checkout |
| M1 | Sep-Oct 2026 | Behavior CI failure replay: versioned behavior contracts, deterministic seed manifests, minimized failing-run artifacts, JSON/JUnit diagnostics, and local reproduction command | Every behavior failure reports contract, seed, first violating step, state digest, and replay artifact; a committed failure fixture fails then reproduces identically headlessly |
| M2 | Nov-Dec 2026 | Stable robot-native control surface: versioned observation/action schemas, controller lifecycle and capability negotiation, multi-robot scheduling, and C-ABI compatibility suite (plan) | A controller built against the oldest supported ABI loads in the newest runtime; no adapter type leaks into core crates; multi-robot results are spawn-order independent |
| M3 | Jan-Feb 2027 | Production sensor/frontend transport: framed binary protocol, explicit negotiation, bounded queues/backpressure, RGB-D/LiDAR payloads, and reconnect semantics (plan) | Slow/disconnected clients cannot stall simulation or grow memory without bound; protocol compatibility and headless sensor references pass on Windows and Linux |
| M4 | Mar-Apr 2027 | Physics conformance: backend-neutral test vectors, units/tolerance registry, snapshots, contact/joint validation, and analytic-vs-Rapier reports (plan) | Every advertised backend capability has a conformance test; deterministic tests use stable hashes where valid and documented tolerances otherwise |
| M5 | May-Jun 2027 | Scenario and traffic scale: multi-entity OpenSCENARIO execution, mixed native/external ownership metrics, recoverable TraCI sessions, and urban scale budgets (plan) | Reference scenario runs 100 actors at >=60 Hz headlessly on the CI benchmark class with deterministic externally visible ordering and zero unexplained violations |
| M6 | Jul 2027 | 0.1 release hardening: public API freeze, migration and compatibility policy, supply-chain/license audit, fuzzed import/protocol boundaries, release artifacts and examples (plan) | No P0/P1 defects, all public APIs documented, two clean release rehearsals pass the full matrix, and v0.1.0 installs and runs every flagship workflow |
Cross-cutting rules for every milestone:
- Core crates remain ROS2- and backend-type-free; adapters conform to RNE types.
- Simulation decisions use
SimClock, explicit units, seeded randomness, and deterministic externally visible ordering. - Every feature has a headless test or runnable example plus a short docs update; every failure must be locally reproducible from a recorded seed or artifact.
- Performance claims name the fixture, machine class, actor/sensor count, and percentile; correctness gates are never waived to meet throughput targets.
M5 evidence is produced by cargo run -p xtask -- scenario-scale. The
committed OpenSCENARIO reference contains 100 actors and runs 600 fixed steps;
its golden runtime hash is 7503294308621126381 and its canonical
actor/action result digest is 6732886903736628512. The report measures three
release repetitions on the named runner class and fails below 60 headless
steps/s or on any classified/unexplained violation.
M6 acceptance is encoded in release/exit-matrix.toml and evaluated by
cargo run --locked -p xtask -- release-exit. The contract freezes 14 CI jobs
plus clean Linux and Windows artifact rehearsals, maps them to the exact
workflow runner and command, requires locked graph-building invocations, and
names CI / workspace and Release rehearsal / release_candidate as the two aggregate RC checks. Each aggregate
writes a schema-v1 report containing the source commit, Cargo.lock SHA-256,
per-job verdicts, clean-checkout state, and zero-open-P0/P1 decision. The
preceding M6-D clean-checkout rehearsal (GitHub Actions run 31569498834)
passed both native jobs before this final aggregate was introduced; M6-E's
local final matrix passed all gates, including 22/22 OSS parity checks and a
slowest 3,246.41 steps/s across three 100-actor samples. The clean PR aggregate
verdicts then passed in CI run 31577873319 and release run 31577873221;
both uploaded reports record release_eligible=true. M6 is complete, and the
tested release tree merged through PR #162 as a4e230f.
| Phase | Area | Deliverable | Status |
|---|---|---|---|
| A | Fixed-step runtime | rne-asset simulate with explicit rate, typed wheel/joint command, physics hash, and exact replay check |
Done |
| B | Run manifest | Versioned .rne.run.toml for scene, clock, seed, controller, and determinism output |
Done |
| C | Replay artifact | Versioned .rne-replay recording tagged wheel/joint actions, joint state, sensor stream summaries, per-step contact statistics, fall/failure annotations, physics hashes, final report, CLI verification, and browser interval inspection |
Done |
| D | Standard adapters | Full typed sensor payload export and manifest-level sensor subscriptions | Done |
| E | Standard adapters | OpenSCENARIO/traffic adapter | Done (rne_openscenario importer parses a minimal OpenSCENARIO 1.0 subset → versioned scenario document, its executor drives the document over the traffic runtime, and run manifests reference it via [scenario]) |
Build a deterministic, renderer-independent urban traffic domain, then import PLATEAU road semantics into it and drive Robot Entities through signalized routes. The first stage is deliberately split into five reviewable PRs:
| Phase | Area | Deliverable | Status |
|---|---|---|---|
| A | Architecture | rne_traffic ownership, dependency boundary, deterministic ECS foundation |
Done |
| B | Asset | .rne.traffic.json schema v1 with stable IDs, provenance, lanes, junctions, connections, signals, and byte-identical golden output |
Done |
| C | PLATEAU | Import road class/function, LOD2 TrafficArea/AuxiliaryTrafficArea, and LOD3.1 lane semantics |
Done |
| D | Topology | Deterministic tile stitching, junction classification, turn curves, grade separation, and conflict relationships | Done |
| E | Runtime / Demo | Headless routing, signals, turns, 100-vehicle official-Sanjo replay; migrate example 46 and publish GIF/README media | Done |
Stage-one acceptance requires byte-identical assets for identical input, stable world hashes for identical seeds and actions, zero signal violations and collisions in the reference replay, explicit authoritative/derived/synthetic provenance, and at least 60 Hz headless execution for 100 vehicles in one tile. See architecture/010_traffic_domain.md.
User feedback after v0.13: "the manipulator holding an object doesn't look real". The contact-triggered weld grasps at whatever raw contact pose it catches (off-center dangling, a 2 cm seat-lift pop on the fixed base, the mobile carry dragging the object ~10 cm in front of the gripper), and the fingers ignore the object once welded. Two-stage plan: first make the weld look like a grasp, then replace it with physical friction-based grasping.
| Phase | Area | Deliverable | Status |
|---|---|---|---|
| A | Manipulation | Weld visual realism: two-finger contact gating (no single-finger graze capture), smooth weld-anchor retarget to a canonical in-gripper pose (centered between finger pads, folds in the 2 cm seat lift — no teleports), fingers pinch to the object surface | Done (PR #35, fixes #39/#40/#41; README hero rebuilt on real physics PR #42; mm_mobile uncommanded-arm hold damping PR #43) |
| B | Physics | Friction-based grasp core: force-limited finger position motors + friction-cone holding, weld removed for graspable objects. Risk: reintroduces contact-history sensitivity — the v0.13 settle fixes (stable equilibria, kinematic base) are the prerequisite that makes this attemptable. Validate cross-platform from day one (temp linux workflow loop) | Core done (feat/friction-grasp-core): opt-in GraspMode::Friction on MobileManipulatorSim (weld stays the default, hero digest bit-for-bit unchanged), ContactEvent::impulse from Rapier's solver, per-obstacle friction in scene TOML, hold/release/low-friction-slip tests on mm_minimal |
| C | Tasks | Migrate pick/place E2Es, policies, and RL benches to friction grasp; keep weld as a fallback mode for scripted regression tests | In progress: bounded continued-close pinch target complete; fixed-base example 33 and its policy E2E run in friction mode; Python RL clutter/place rollouts select friction after reset; mobile example 34 validates friction grasp acquisition while full mobile friction placement remains |
| D | Release | CHANGELOG / ROADMAP / hero regen, ship v0.14.0 | In progress (M0 parity consolidation and RC hardening) |
The remaining mobile friction-place gap is deferred to a post-v0.14 mobile-manipulation track: mm_mobile has
no vertical lift, while its v0.13 policy drags a welded cube across the table.
A physical-grasp replacement needs a lift-capable mobile manipulator or a task
scene/trajectory designed to clear the tabletop without a rigid attachment.
Three long-running pillars steer the next releases alongside the phased goals above:
Build one shared legged-control foundation, validate it on a quadruped first, then reuse the same articulation, contact, observation, and policy interfaces for a humanoid. Core crates remain robot-native and ROS2-free.
| Phase | Area | Deliverable | Status |
|---|---|---|---|
| A | URDF / Physics | Generic named joint-position targets and per-link contact impulse observations for URDF articulations | Done (UrdfSceneSim::step_joint_position_targets, link_contact_impulse_ns, and seeded scene loading) |
| B | Quadruped | Vendored 12-DoF quadruped URDF, deterministic standing controller, four-foot contact test, headless example | Done (rne_quadruped, example 36; 12 motors and four loaded feet validated headlessly) |
| C | Quadruped locomotion | Seeded gait episode, action/observation/reward API, deterministic forward-walk baseline | Done: seeded gait-phase resets, action/observation/reward episode, four-foot impulses, exact action replay, pure-torque velocity/terrain control, and deterministic speed validation |
| D | Humanoid | Humanoid URDF standing/balance episode reusing the same named-joint and foot-contact APIs | Done: 12-DoF URDF, force-limited standing, bilateral foot loads, balance action/observation/reward episode, exact replay test, and example 37 |
| E | Learning | Vectorized quadruped/humanoid environments and CEM/PPO smoke baselines | Done: shared LocomotionPolicy, seeded Go2/G1 vectorized batches, replay checkpoints/digests, native Go2 Python adapter, dependency-free CEM smoke, and SB3 PPO smoke |
| F | Humanoid locomotion v0.1 | Typed forward/stop/differential-steering commands, robust CEM overlay search, light-disturbance and exact-replay benchmark, example 67, and refreshed G1 hero/docs/CI | Done |
| G | Humanoid heading-yaw v0.2 / v0.2.1 | Bounded true-heading target/error metrics, stance/swing-aware hybrid control, deterministic bilateral CEM candidate search, example 68, and updated G1 docs/CI | Done (v0.2: 240-tick final-yaw sign; v0.2.1: 480-tick mean yaw-rate sign; sustained integrated-yaw hold remains future work) |
| H | Photoreal material maps v0.2 | Backend-neutral normal/roughness maps, OBJ/MTL map loading, tangent-frame GGX shading, and mapped G1 test-bay floor | Done (HDRI and TAA were added in later increments) |
| I | Photoreal asset foundation v0.3-A | Static glTF/GLB scene import, node-transform baking, packed metallic-roughness/emissive/occlusion maps, and backend-neutral PBR texture semantics | Done (HDRI and TAA were added in later increments; skinning and animation remain future work) |
| J | Photoreal environment lighting v0.3-B | Backend-neutral Radiance HDR loading, opt-in WGPU equirectangular sky, diffuse/specular image-based lighting, map caching, and G1 capture integration | Done |
| K | Photoreal temporal anti-aliasing v0.3-C | Opt-in deterministic camera jitter, depth reprojection, history clamping, resize-safe accumulation, and G1 capture integration | Done |
| L | Photoreal prefiltered IBL v0.3-D | Deterministic GGX/Hammersley specular mip pyramid, cosine-weighted diffuse environment map, and roughness-driven WGPU sampling | Done |
| M | Photoreal humanoid motion v0.3-E | glTF node hierarchy, inverse-bind skinning, deterministic linear/step TRS animation clips, and bind-pose-safe CPU sampling for dynamic meshes | Done |
| N | Photoreal GPU skinning v0.3-F | Simulation-driven animation player, WGPU JOINTS_0/WEIGHTS_0 vertex inputs, storage-buffer joint matrices, and shadow-pass deformation |
Done |
| O | Photoreal humanoid asset integration v0.3-G | Pinned attributed rigged humanoid GLB fixture, animation-player render example, material/texture propagation, and GPU color/shadow validation | Done |
| P | Photoreal Unitree G1 capture v0.3-H | Official G1 URDF/STL visual hierarchy in the photoreal test bay, PBR floor maps, optional HDRI/TAA capture, and deterministic mesh-resolution smoke | Done |
| Q | Photoreal RGB-D sensor loop v0.3-I | G1 head_link camera mount, renderer-independent CameraSpec effects, paired DataBus RGB/depth streams with latency, GPU capture manifest, and deterministic headless replay smoke |
Done |
| R | Photoreal industrial environment v0.3-J | CC0 Poly Haven Machine Shop HDRI and Hand Truck glTF package with provenance/SHA-256, default G1 capture integration, procedural fallback controls, and asset-aware headless smoke | Done |
| S | G1 long-horizon stability v0.3 | 50 s no-fall sustained walk envelope, library test, and hero capture (example 92) | Done |
The measured locomotion frontier (Go2 foot-clearance/parkour wall, G1 sustained-turn and 60 Hz solver-stability walls) and the next campaign are recorded in PLAN_LEGGED_LOCOMOTION_FRONTIER.md.
Scripted joint-space gaits hit their steering and disturbance-rejection ceiling. The next campaign builds the deterministic model-based stack those gaits cannot express (ZMP/DCM, whole-body control, centroidal MPC), starting from a native dynamics foundation so no control algorithm depends on a physics backend.
| Phase | Area | Deliverable | Status |
|---|---|---|---|
| A | Native dynamics | rne_dynamics spatial algebra, CRBA mass matrix, recursive Newton-Euler inverse/forward dynamics, floating base, center of mass and Jacobian, analytic tests, and a floating-base Go2 example |
Done (crates/rne_dynamics, example 103, docs/architecture/012_dynamics.md) |
| B | Gait template | LIPM/ZMP/DCM templates, capture-point foot placement, and ZMP preview-control walking patterns | Done (crates/rne_legged, example 104, docs/architecture/013_legged_templates.md); terrain costmap consumption moves to Phase D |
| C | Whole-body control | Hierarchical-QP / inverse-dynamics whole-body control with contact and friction constraints | Partial (crates/rne_wbc, example 105, docs/architecture/014_whole_body_control.md): weighted inverse dynamics, contact no-slip, friction projection, and torque recovery are done; hard-inequality QP and closed-loop scheduling remain |
| D | Footstep planning | Discrete footstep planner over elevation and cost maps | Planned |
| E | Centroidal / DDP | Centroidal-momentum MPC and multi-contact DDP built on analytical derivatives | Planned |
Official robot-model integration has started with Unitree Go2: the upstream
BSD-3-Clause URDF/meshes are vendored with provenance, COLLADA visuals are
reproducibly converted for RNE's mesh loader, and example 38 generates a real
wgpu GIF for the README. Go2 now also has a dynamic multibody scene with a
four-foot standing/contact test and bounded diagonal-pair trot; example 38 now
captures that contact-driven motion. The same path covers the official Unitree G1
23-DoF humanoid, including 29 STL meshes and an articulated example 39 capture.
UnitreeGo2Episode adds bounded stride/lift actions, planar locomotion delta,
four-foot contact observations, gait phase, and exact short-rollout replay.
Generic URDF observations and both official gait episodes now expose Y-up
roll/pitch plus base linear and angular velocities for policy state estimation.
They also expose yaw/pitch/roll relative to the scene-load base orientation,
removing each URDF's fixed basis conversion from upright-policy inputs.
G1 and Go2 gait termination now combines minimum base height with a configurable
relative-tilt limit, and both rewards penalize pitch/roll departure from upright.
G1 also has a dynamic standing scene that retains the official primitive foot
and leg contacts while excluding unstable mesh-AABB collision approximations.
Its deterministic balance episode exposes pelvis pose, bilateral foot loads,
progress, four low-dimensional controls, and an upright/load-balance reward.
A bounded, periodic G1 gait generator now supplies asymmetric stance/swing leg
trajectories and arm counter-swing. The learned locomotion foundation is now
shared: LocomotionPolicy separates typed policy inputs from episode ownership,
VectorizedUnitreeGo2GaitEnv and VectorizedUnitreeG1GaitEnv preserve
environment order and per-environment seeds, and replay checkpoints reconstruct
transitions through reset-and-replay with a stable digest. The native Go2 gait
episode is also exposed to the Python RL adapter; example 66 covers vectorized
Rust, CEM, and SB3 PPO smoke paths without requiring a renderer.
Backend-neutral collision groups can now disable same-robot link contacts while
preserving environment contacts. Reduced-coordinate multibody articulation is now
selectable per URDF asset; G1 uses it for real dynamic standing, balance replay,
and a settle-then-gait rollout without destabilizing existing impulse-joint robots.
Only actuated links and their ancestors enter the multibody, keeping fixed visual
accessories out of the solver while preserving them in the rendered URDF hierarchy.
The G1 gait now widens its support stance and advances in positive X after a
standing settle, with bounded height and yaw verified by a headless rollout.
UnitreeG1GaitEpisode exposes stride, foot-lift, and yaw-correction actions;
forward delta, gait phase, bilateral contacts, and pose observations; and a
forward/upright reward whose short rollouts replay exactly.
Example 39 and the README media now capture that dynamic multibody gait after
standing settle instead of animating the former fixed-base showcase.
| Pillar | Meaning | Status |
|---|---|---|
| Browser-native visualization | The engine's own wgpu renderer running in the browser (wasm32, WebGPU/WebGL2) — no parallel JS rendering stack | MVP shipped (feat/web-viewer, web/rne_web_viewer) |
| External URDF support | Ingest real-world URDFs (SO-101 / LeRobot arms, mobile carts): joint limits, mesh-collision fallback, vendored assets, viewer profiles | Done (feat/external-urdf-so101) |
| Precise dynamics validation | Analytic-reference physics accuracy suite (free fall, pendulum period, friction stick/slip, energy drift) with documented tolerances — the trust foundation for friction-based grasping (Phase B). Phase 2: Pinocchio golden trajectory comparisons (tests/golden/pinocchio/) |
Done (feat/dynamics-validation) |
| Area | Idea |
|---|---|
| Perception | Wrist-camera grasp target estimation (visuomotor pick) — pairs naturally with Phase B |
| CI | Behavior-contract failures emit a deterministic seed/replay bundle and one-command local reproduction (M1) |
| Scene diversity | Domain randomization + curriculum over clutter layouts |
| DevEx | run_program(Path, args) without cmd /C reparsing |
| CI | rne_ros2_node, rne_ros2_bridge) are red on the runner: simulation_interfaces package missingros-jazzy-simulation-interfaces (Python msgs for the bridge, share/*/rust crate patched in by generate_cargo_config.sh for the node) |
- The README hero live trajectory digest is compared only on Windows (the generating platform): cross-platform contact dynamics are outcome-stable but not bit-identical. Outcome-level hero checks run everywhere.
- The explicit headless gate is
cargo run -p xtask -- ci-headless; it runs the renderer-independentrne_renderand sensor test suites without a feature flag.
Primary development target for v0.13. Shipped 2026-07-06. See CHANGELOG.md.
Closes the v0.12 stretch goal: full mobile navigate → grasp → place on mm_mobile_clutter
(example 34, IkMobileClutterPickPlacePolicy).
| Phase | Area | Deliverable | Status |
|---|---|---|---|
| A | Manipulation | Tune IkMobileClutterPickPlacePolicy carry/place; un-ignore mobile_clutter_policy_completes_place and mobile_clutter_transport_script_places_cube_a |
Done (PR #31) |
| B | Examples | Example 34 --smoke asserts grasp + place (mirrors example 33) |
Done (PR #31) |
| C | RL | train_mobile_clutter.py (CEM + replay) and PPO smoke on mobile_clutter_pick_place_center; wire into xtask ci |
Done (PR #33) |
| D | Release | README hero / CHANGELOG / ROADMAP update, ship v0.13.0 | Done |
Shipped 2026-07-06. See CHANGELOG.md.
| Area | Feature |
|---|---|
| Manipulation | Mobile clutter place E2E: navigate → poke-grasp → retreat-drag → carry → release (example 34) |
| Physics | mm_minimal/mm_mobile settle fixes: collider interpenetration removed, spring-damper position holds, kinematic base integration with corrected yaw sign |
| RL | train_mobile_clutter.py (CEM + deterministic replay), train_mobile_clutter_ppo.py (SB3 smoke) |
| CI | Cross-platform green: all linux settle gates removed; SB3 pin numpy-2 compatible |
| Media | README hero retuned to the corrected base dynamics and regenerated |
| Area | Idea |
|---|---|
| Physics | |
| Physics | Wire URDF prismatic joints to Rapier (carried-over architecture gap) |
| Perception | Wrist-camera grasp target estimation (visuomotor pick) — natural v0.14 follow-up |
| Scene diversity | Domain randomization + curriculum over clutter layouts |
Primary development target for v0.11. Shipped 2026-07-03. See CHANGELOG.md.
| Phase | Area | Deliverable | Status |
|---|---|---|---|
| A | Perception | Wrist RGB-D on DataBus + depth in observations; VisuomotorReachPolicy |
Done (ImageDepth, scene-aware wrist sampling, depth obs fields) |
| B | RL | CEM pick-and-place + visuomotor reach bench; SB3 PPO smoke in CI | Done (train_place.py, train_visuomotor.py, train_ppo.py smokes) |
| C | Scene diversity | Clutter pick + mobile navigate-and-place episodes | Done (clutter_pick_place, mobile_clutter_pick_place, clutter scenes) |
| Area | Idea |
|---|---|
| RL | Converging clutter pick-and-place on SB3 PPO / CEM + reproducible bench + replay |
| Manipulation | Analytic IK for mm_minimal SCARA (mirrors MmLiftKinematics) |
| Scene diversity | Full mobile navigate → grasp → place E2E on clutter scenes |
| Physics | Wire URDF prismatic joints to Rapier (architecture gap) |
Shipped 2026-07-03. See CHANGELOG.md. Fixed-base clutter place E2E and RL bench are complete; mobile navigate-and-place remains a stretch goal (example 34, policy skeleton).
| Phase | Area | Deliverable | Status |
|---|---|---|---|
| A | Kinematics | MmMinimalKinematics — analytic FK/IK for the mm_minimal SCARA chain |
Done |
| B | Scene / E2E | IkClutterPickPlacePolicy + example 33_clutter_pick_place_e2e |
Done |
| C | RL | train_clutter.py + train_clutter_ppo.py converging bench + replay |
Done |
Shipped 2026-07-03. See CHANGELOG.md.
| Area | Feature |
|---|---|
| Kinematics | MmMinimalKinematics analytic FK/IK for mm_minimal SCARA |
| Manipulation | IkClutterPickPlacePolicy; example 33 fixed-base clutter place E2E |
| RL | train_clutter.py (CEM + replay); train_clutter_ppo.py (SB3 smoke) |
| Scenes | clutter_place_center; mm_minimal_clutter ground place target |
| Stretch | IkMobileClutterPickPlacePolicy, example 34 (mobile place tuning) |
Shipped 2026-07-03. See CHANGELOG.md.
| Area | Feature |
|---|---|
| Perception | ImageDepth on DataBus; wrist depth obs fields; VisuomotorReachPolicy |
| RL | train_place.py, train_visuomotor.py, train_ppo.py smokes; pinned CPU torch in CI |
| Scenes | mm_minimal_clutter / mm_mobile_clutter; clutter + mobile navigate-place episodes |
| AI | Snapshot v2 with v1 restore; pre-grasp approach reward on Place tasks |
Primary development target for v0.10. Closes the one capability the mobile-manipulator
architecture doc still marks Partial (architecture/006_mobile_manipulator.md):
analytic IK + joint-space trajectory following now exist; IkLiftPickPlacePolicy drives carry
via IK joint targets. LiftPickPlacePolicy remains as a scripted regression baseline.
| Phase | Area | Deliverable | Status |
|---|---|---|---|
| A | Kinematics | Analytic IK helper for the mm_lift lift+arm chain (pure, deterministic, seed-free), rustdoc + unit test |
Done (MmLiftKinematics, fk_ik_roundtrip, fk_matches_sim_at_idle) |
| B | Control | Joint-space trajectory following: interpolate the IK solution into position-motor targets (_rad / _m / _s units), crate-approved tolerances |
Done (JointTrajectory, joint_tracking_action, ik_reaches_arbitrary_target) |
| C | AI | Replace LiftPickPlacePolicy internals with IK-solved targets; existing determinism/golden tests guard regression |
Done (IkLiftPickPlacePolicy; LiftPickPlacePolicy retained for regression) |
| D | Adapters | ROS 2 trajectory_msgs/JointTrajectory (subset) subscribe; expose IK / trajectory API via rne_py |
Done (step_hold_lift_joints in rne_py; /arm_joint_trajectory 3-DOF on RNE_ROS2_MODE=mm_lift) |
Why IK first: it is the base every other theme rides on — perception (vision → target pose → IK), RL (act in EE space), and scene diversity (reach an arbitrary object position) all get simpler once IK exists.
| Area | Idea |
|---|---|
| Kinematics | Analytic IK for the column-lift + revolute arm; keep it out of core as a pure helper |
| Control | Interpolated joint-space trajectories driving the existing position motors |
| AI | LiftPickPlacePolicy re-expressed as IK-to-target instead of a fixed step sequence |
| ROS 2 | Subscribe trajectory_msgs/JointTrajectory (subset), map to arm joint targets |
| Python | rne_py IK / trajectory bindings alongside the existing episode API |
Shipped 2026-07-02. See CHANGELOG.md.
| Area | Feature |
|---|---|
| Kinematics | MmLiftKinematics analytic FK/IK for mm_lift (sim shoulder sign corrected) |
| Control | Direct joint targets (hold_lift_joints), JointTrajectory, joint_tracking_action |
| AI | ik_reaches_arbitrary_target; LiftPickPlacePolicy::kinematics() helper |
| Python | rne_py MmLiftKinematics, step_hold_lift_joints, MobileManipulatorSim("mm_lift") |
Shipped 2026-07-02. See CHANGELOG.md.
| Area | Feature |
|---|---|
| Manipulation | mm_lift column + sliding carriage; vertical lift position motor; top-down claw; full 3D pick → lift → carry → place |
| Control | Position (spring-damper) arm joints; per-motor max_force; per-world solver iterations for stiff chains |
| AI | LiftPickPlacePolicy; lift_pick_place episode; Place observation goal offset; reach curriculum + goal-conditioned reach |
| ROS 2 | /lift_command (std_msgs/Float64) drives the vertical lift |
| Rendering | Interactive viewer --manipulator-lift profile (R / F lift, arm + claw teleop) |
| Docs | README 3D pick-and-place showcase + 32_lift_pick_place_hero sim-captured hero |
Shipped 2026-06-16. See CHANGELOG.md.
| Area | Feature |
|---|---|
| Physics | Prismatic + fixed (weld) joints; deterministic backend iteration |
| Manipulation | Contact-triggered weld grasp, Place task, example 26 pick-and-place |
| AI / RL | reach task, CEM training loop (example 27), vectorized env (example 28), rne_py bindings + SB3 PPO integration |
| ROS 2 | Arm velocity / position / trajectory control + gripper command + ee_link TF |
| Assets | mm_mobile drive-wheel fix (was spinning in place) |
Shipped 2026-06-12. See CHANGELOG.md.
| Area | Feature |
|---|---|
| AI | MobileManipulatorEpisode (reach / grasp / transport / inspect tasks + rewards) |
| Sensors | [wrist_camera] on mm_mobile; wrist camera DataBus in sim |
| Rendering | Viewer wrist camera PiP (P toggle) on --manipulator profiles |
| ROS 2 | /camera/image_raw from wrist camera in mobile_manipulator mode |
| Examples | Example 25 episode smoke (inspect + transport termination) |
Shipped 2026-06-12. See CHANGELOG.md.
| Area | Feature |
|---|---|
| Manipulation | Dynamic scene obstacles; transport helpers + mm_minimal_transport scene |
| Sensors | Wrist camera DataBus (ImageRgb8); example 24 wrist cam smoke |
| Examples | Example 23 transport smoke (finger contact + cube displacement) |
| Physics | Zero-velocity ECS→Rapier sync on spawn for repeatable initial EE pose |
Shipped 2026-06-12. See CHANGELOG.md.
| Area | Feature |
|---|---|
| AI | MobileManipulatorSim::from_scene_path, scene path helpers |
| Assets | mm_minimal / mm_minimal_grasp scenes, parallel-jaw gripper URDF |
| Examples | Example 22 grasp contact smoke |
| Adapters | ROS mobile manipulator loads mm_mobile scene by default |
Shipped 2026-06-12. See CHANGELOG.md.
| Area | Feature |
|---|---|
| Physics | URDF → Rapier articulation (attach_urdf_articulation) |
| Assets | mm_minimal / mm_mobile URDF + scene assets |
| AI | MobileManipulatorSim, reach example, DataBus JointState |
| Rendering | Arm teleop in interactive viewer (--manipulator, --manipulator-mobile) |
| ROS 2 | mobile_manipulator mode: /joint_states, /cmd_vel, /arm_joint_velocity |
Shipped 2026-06-12. See CHANGELOG.md.
| Area | Feature |
|---|---|
| Rendering | LiDAR hit visualization in wgpu and interactive viewer (19_lidar_render, append_lidar_overlay) |
| Rendering | Normal-based Lambert lighting in wgpu (rne_render_wgpu) |
| Sensors | Scene-defined LiDAR mounts and obstacles ([lidar], [[obstacles]]) |
| ROS 2 | Native /points and /scan from simulation DataBus (rne_ros2_node) |
Primary development target for v0.6 (shipped in v0.6.0). See architecture/006_mobile_manipulator.md.
| Phase | Area | Deliverable | Status |
|---|---|---|---|
| A | Physics | URDF → Rapier revolute chain, JointMotor on arm |
Done (attach_urdf_articulation, parent-aware sync) |
| A | Assets | Minimal mobile-manipulator URDF + .rne.scene.toml |
Done (mm_minimal, mm_mobile scene) |
| B | AI | MobileManipulatorSim, joint/EE observations, reach example |
Done (MobileManipulatorSim, 21_mobile_manipulator_reach) |
| B | Rendering | Arm teleop in interactive viewer | Done (--manipulator, --manipulator-mobile) |
| C | Manipulation | Gripper, wrist camera, pick/transport/place episodes | Done (contact-triggered weld grasp, Place task, example 26 pick-and-place) |
| D | ROS 2 | /joint_states, base + arm command topics |
Done (mm_mobile mode: 4 joints, /cmd_vel, /arm_joint_velocity, /gripper_command, ee_link TF) |
| Area | Idea |
|---|---|
| Physics | Wire URDF joints to Rapier impulse joints (revolute + prismatic) |
| Robot | [mobile_manipulator] section in .rne.robot.toml |
| AI | MobileManipulatorSim with base velocity + arm joint commands |
| Sensors | JointState and end-effector pose on DataBus |
| Examples | 20_mobile_manipulator_reach headless smoke |
| Rendering | Joint sliders + base teleop in 14_interactive_viewer |
| Manipulation | Tabletop object spawn, reach/grasp termination (v0.7 stretch) |
| ROS 2 | Publish /joint_states; subscribe to arm trajectory or joint targets |
| Area | Idea | Status |
|---|---|---|
| Rendering | LiDAR hit visualization in wgpu and interactive viewer | Done (19_lidar_render, append_lidar_overlay, L toggle) |
| Rendering | Simple normal-based lighting in wgpu fragment shader | Done (Lambert + ambient in rne_render_wgpu) |
| Sensors | Scene-defined LiDAR mounts (not demo-only wall spawn) | Done ([lidar] robot asset, [[obstacles]] scene asset) |
| ROS 2 | Publish /scan from native node when LiDAR is present |
Done (/points + /scan from DataBus, RNE_ROS2_SCENE_PATH) |
Shipped 2026-06-12. See CHANGELOG.md.
| Area | Feature |
|---|---|
| AI | Goal-conditioned policies and curriculum (16_goal_conditioned_agent) |
| Physics | Multi-robot collision and interaction (17_multi_robot_collision) |
| ROS 2 | Services, actions, and parameter parity with native node |
| Rendering | URDF world transforms, orbit camera, multi-draw wgpu fix, sim-captured README hero |
| DevEx | rne_urdf_import promoted to core crate; CI boundary lint passes |
Shipped 2026-06-12. See CHANGELOG.md.
| Area | Feature |
|---|---|
| AI | Multi-robot episodes, richer observation spaces (13_multi_robot_agent) |
| Physics | Shared-world agents (agent ECS ↔ sim world) (12_shared_world_agent) |
| Rendering | Interactive viewer / camera teleop (14_interactive_viewer) |
| Assets | Hot reload, asset pipeline CLI (15_asset_hot_reload, rne-asset, xtask asset) |
| ROS 2 | Python bridge CI, topic parity with native node (ros2-bridge.yml, xtask ci-ros2-bridge) |
Shipped 2026-06-13. See CHANGELOG.md.
| Area | Feature |
|---|---|
| AI | Episode API, reward/termination (rne_ai, 05_episode_diff_drive) |
| Robot | URDF → collider/visual auto attach (rne_urdf_import) |
| Assets | .rne.scene.toml / .rne.robot.toml (rne_assets, 06_scene_load) |
| Rendering | Mesh rendering, depth pass (07_render_primitives) |
| ROS 2 | Native rclrs node (rne_ros2_node) |
| Area | Feature |
|---|---|
| Integration | End-to-end scene + episode (08_scene_episode) |
| Rendering | URDF mesh load + wgpu draw (09_urdf_mesh_render) |
| AI | Domain randomization, vectorized envs (10_vectorized_episode) |
| Robot | Rapier joint-driven wheels (DiffDriveDriveMode::JointDriven) |
| Agent | Agent Entity + policy attach (11_agent_policy) |
| ROS 2 | Optional CI for rne_ros2_node (.github/workflows/ros2-node.yml, xtask ci-ros2) |
| CI | GitHub Actions core workspace job (ci.yml) |
- Core ECS + world + math
- Rapier physics + determinism tests
- Diff-drive robot + sensors + DataBus
- Render skeleton + Python bindings
- URDF import + ROS 2 Python bridge
- Installed indoor mobile-manipulation TaskSpec proof from native archives
- Rapier/MuJoCo success and intentional-failure comparison
- Browser-viewable, replay-bearing Failure Capsule and exact producer binding
- Named-machine 15-minute measurement and independent evidence intake
- Rust API baseline retargeted to absorb breaking changes merged into
mainsince the0.2.0freeze (notablyMobileManipulatorActiongaining public fields and therne_robotAPI changes) rne_nav,rne_slam, andrne_planningpromoted frompublish = falseworkspace-internal crates to public, semver-checked release packages- Unblocks
cargo package -p rne_adapter_ros2, which path-depends onrne_nav
- Rust API baseline retargeted a second time, absorbing the 94 breaking changes
merged into
mainsince the0.3.0freeze: 80 items removed from the public surface, 10 structs given a newpubfield, three types no longer derivingCopy(ColliderShapegained owned-geometry variants), one associated const hidden. Full list in COMPATIBILITY.md; decision in ADR 035 release/rust-api-additions-v1.tomlfolded back into the single registry, which covers all 36 publishable packages again- Operational rule recorded: do not merge while
semverorworkspaceis red
| Area | Idea | Status |
|---|---|---|
| AI | Goal-conditioned policies, curriculum / multi-task episodes | Done (GoalSeekingPolicy, GoalCurriculum, 16_goal_conditioned_agent) |
| Rendering | Viewer + scene assets integration, URDF mesh in interactive mode | Done (14_interactive_viewer, [visuals] robot assets) |
| Physics | Multi-robot collision and interaction scenarios | Done (multi_robot helpers, 17_multi_robot_collision) |
| ROS 2 | Services, actions, and parameter parity with native node | Done (simulation_interfaces, wheel_velocity_rad_s) |
| DevEx | Live asset reload wired into interactive viewer | Done (14_interactive_viewer) |
Two runtime paths are available:
- Python (
adapters/ros2/rne_ros2_bridge/):rclpynode, optionalrne_pybindings - Rust (
adapters/ros2/rne_ros2_node/): nativerclrsnode with headlessrne_aisim
On Jazzy:
sudo apt install ros-jazzy-rosidl-generator-rs ros-jazzy-test-msgs
source /opt/ros/jazzy/setup.bash
cargo run -p xtask -- ci-ros2
cargo run -p xtask -- ci-ros2-bridgeThe native node is built with --manifest-path and is not part of the core workspace CI.
After merging release changes, set RNE_VERSION to the exact version being
shipped and run the clean release gate before creating generated release notes:
RNE_VERSION=0.4.0
cargo run --locked -p xtask -- ci
cargo run --locked -p xtask -- release-exit --output artifacts/release-exit/report.json
git diff --exit-code
git tag -a "v${RNE_VERSION}" -m "Robot Native Engine v${RNE_VERSION}"
git push origin "v${RNE_VERSION}"
gh release create "v${RNE_VERSION}" --title "v${RNE_VERSION}" --generate-notes --verify-tagCreate the tag only from the protected, green release commit. A release candidate does not advance to final until its clean-checkout rehearsal and published artifacts have both been verified.