Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
52 commits
Select commit Hold shift + click to select a range
ed4eeff
Merge unsigned Jetson shards in the split driver; CI verifies seconda…
plancherb1 Nov 3, 2026
54ab919
rizon4 inertials from the vendor's flexiv_description table
plancherb1 Nov 3, 2026
8041ce2
Record the mechanism of the JAX sanitizer fabric-handle warning
plancherb1 Nov 3, 2026
e620d8b
Shared thread-sweep helper for the CUDA equivalence runners; fingerpr…
plancherb1 Nov 3, 2026
c3ea688
fdsva_so forwards the model pointer to forward_dynamics_inner under r…
plancherb1 Nov 3, 2026
52b7a4d
Integrator backward on floating-base and spherical models; the retrac…
plancherb1 Nov 3, 2026
ee2843b
Runtime rotor armature: a per-slot reflected inertia on the joint-spa…
plancherb1 Nov 3, 2026
bcf8159
Frame velocity and acceleration kernels on the frame Jacobian family
plancherb1 Nov 3, 2026
6b96141
Frame velocity and acceleration on the three Python surfaces
plancherb1 Nov 3, 2026
35d9e19
Frame velocity and acceleration derivatives: reference, CUDA kernels …
plancherb1 Nov 3, 2026
b7031fa
Polynomial couplings on the dynamics kernels, their gradients and the…
plancherb1 Nov 3, 2026
bb75bc3
Polynomial couplings on the end-effector pose gradient; the URDF page…
plancherb1 Nov 3, 2026
da2b1d4
Polynomial couplings on the frame Jacobian family
plancherb1 Nov 3, 2026
3b297a1
Polynomial couplings: the integrators and their gradients, checked ag…
plancherb1 Nov 3, 2026
ecbab16
Polynomial couplings on the regressors, the centroidal quantities and…
plancherb1 Nov 3, 2026
12091cd
Python-surface smoke for a polynomial-coupled robot on the supported …
plancherb1 Nov 3, 2026
f0e5bc0
Polynomial couplings on the runtime pose family; the closed-loops con…
plancherb1 Nov 3, 2026
922a675
Joint damping and friction on coupled joints fold with alpha^2 and |a…
plancherb1 Nov 4, 2026
1bc2ca3
Coriolis matrix on polynomial couplings: the embedding's inertia term…
plancherb1 Nov 4, 2026
27cd4bf
dccrba and cmm_time_variation on polynomial couplings: the embedding …
plancherb1 Nov 4, 2026
b1fea81
External-force gradients on polynomial couplings: runtime alpha table…
plancherb1 Nov 4, 2026
3dc6996
Docs for the external-force gradients on polynomial couplings
plancherb1 Nov 4, 2026
5f2f24e
MuJoCo-convention integrators take the MuJoCo step; the gradient and …
plancherb1 Nov 4, 2026
4e7f63a
Spherical models build with integrator_gradient: the wrapper names on…
plancherb1 Nov 4, 2026
27db8d5
A lone polynomial follower keeps its runtime multiplier in the Jacobi…
plancherb1 Nov 4, 2026
d3def8a
fdsva_so forwards the model pointer to forward_dynamics_inner under r…
plancherb1 Nov 3, 2026
261c1f5
Runtime rotor armature: a per-slot reflected inertia on the joint-spa…
plancherb1 Nov 3, 2026
85a28ef
Repair armature ownership validation and energy accounting
plancherb1 Nov 5, 2026
2501611
Add baked armature and correct inverse-mass storage
plancherb1 Nov 6, 2026
19430bb
Add armature identification and parameter composition acceptance
plancherb1 Nov 7, 2026
9fe7f1d
Add installed armature and exact workspace release gates
plancherb1 Nov 7, 2026
df8b2cd
Align pose scratch and enforce optimized sanitizer regressions
plancherb1 Nov 8, 2026
096505a
Preserve pointer address space when aligning pose scratch
plancherb1 Nov 8, 2026
9fd795e
fix: validate allocation alignment and pure free-body first-order dyn…
plancherb1 Nov 8, 2026
7ea9b35
docs: distinguish historical Orin qualification from 0.7.1 candidate
plancherb1 Nov 8, 2026
1008cd4
Clarify inner and enclosing EE scratch alignment contracts
plancherb1 Nov 8, 2026
e8d8bf8
Serialize receipt phases with strict memory admission
plancherb1 Nov 9, 2026
63ed926
Reject armature lost to precision narrowing or flush-to-zero
plancherb1 Nov 10, 2026
dc18de5
Compose skew axes with spherical ABA and armature slots
plancherb1 Nov 10, 2026
6f46f1c
Plan exact release manifests and preserve prewarm resume state
plancherb1 Nov 10, 2026
467c881
Clamp overloaded native launches to their compiled thread limit
plancherb1 Nov 10, 2026
829e1e2
Cover armature on the complete floating default registration
plancherb1 Nov 10, 2026
a1be407
Document precision refusal and one-pass manifest planning
plancherb1 Nov 10, 2026
5e41f0b
Pin reconciled reference and polynomial parser for combined release
plancherb1 Nov 10, 2026
d928da0
Merge wave-0.8 into combined 0.7.1 candidate
plancherb1 Nov 10, 2026
295cd7b
Enforce planned scope when promoting completed receipts
plancherb1 Nov 10, 2026
8841419
Freeze combined 0.7.1 release validation scope
plancherb1 Nov 10, 2026
29080a0
test: qualify 0.7.1 shipping scope and measured receipt admission
plancherb1 Nov 11, 2026
4339b69
test: record fresh 0.7.1 release receipt
plancherb1 Nov 12, 2026
ce1c4c7
Changelog for 0.7.1: release date, the fdsva_so limit stated plainly
plancherb1 Nov 12, 2026
afd71ee
CI and developer install hold cmeel-tinyxml2 below 11 for pin 3.9
plancherb1 Nov 12, 2026
1bed06a
CI verifies secondary receipts at their recorded commit; the pool tes…
plancherb1 Nov 12, 2026
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
7 changes: 6 additions & 1 deletion .github/workflows/peer-suites.yml
Original file line number Diff line number Diff line change
Expand Up @@ -45,6 +45,8 @@ jobs:
run: |
pip install -r external/RBDReference/requirements-dev.txt
pip install -r external/URDFParser/requirements.txt
# cmeel-tinyxml2 11 ships libtinyxml2.so.11; pin 3.9 links .so.10.
pip install "cmeel-tinyxml2<11"

- name: Run RBDReference equivalence suite
env:
Expand All @@ -66,7 +68,10 @@ jobs:
python-version: "3.12"

- name: Install dependencies
run: pip install -r external/URDFParser/requirements-dev.txt
run: |
pip install -r external/URDFParser/requirements-dev.txt
# cmeel-tinyxml2 11 ships libtinyxml2.so.11; pin 3.9 links .so.10.
pip install "cmeel-tinyxml2<11"

- name: Run URDFParser tests
run: python -m pytest external/URDFParser/tests -q
39 changes: 38 additions & 1 deletion .github/workflows/verify-gpu-proof.yml
Original file line number Diff line number Diff line change
Expand Up @@ -53,6 +53,42 @@ jobs:
--policy test/gpu-proof-policy.yaml \
--expected-skips test/gpu-proof-expected-skips.txt

- name: Verify secondary receipts
# Every receipt listed in test/gpu-proof-receipts.yaml that exists on
# disk (the Jetson rows under receipts/) is verified against the commit
# it was recorded at: signature, scope, results and its own
# expected-skips baseline, with that commit an ancestor of this one. A
# secondary receipt attests the source it ran on, which the
# compatibility page states; it is not required to match the tip. A
# missing secondary is reported, not an error.
run: |
python - <<'PY'
import json, os, subprocess, sys, yaml
table = yaml.safe_load(open('test/gpu-proof-receipts.yaml'))
rc = 0
for row in table.get('secondary') or []:
path = row['receipt']
head = f"sm_{row['arch']} {row['label']} {path}"
if not os.path.exists(path):
print(f'{head}: not recorded')
continue
commit = json.load(open(path))['repo']['commit_sha']
if subprocess.run(['git', 'merge-base', '--is-ancestor', commit, 'HEAD']).returncode:
print(f'{head}: recorded commit {commit[:7]} is not an ancestor; FAIL')
rc = 1
continue
tree = os.path.join(os.environ['RUNNER_TEMP'], f"receipt-sm{row['arch']}")
subprocess.run(['git', 'worktree', 'add', '--detach', tree, commit], check=True)
skips = row.get('expected_skips', 'test/gpu-proof-expected-skips.txt')
proc = subprocess.run(
['gpu-proof', 'verify', '--receipt', os.path.abspath(path), '--repo', tree,
'--policy', os.path.join(tree, 'test/gpu-proof-policy.yaml'),
'--expected-skips', os.path.abspath(skips)])
print(f"{head}: attests {commit[:7]}; {'ok' if proc.returncode == 0 else 'FAIL'}")
rc |= proc.returncode != 0
sys.exit(rc)
PY

cpu-lane:
runs-on: ubuntu-latest
strategy:
Expand Down Expand Up @@ -81,7 +117,8 @@ jobs:
# The Pinocchio anchors of the CPU lane (test_manifold_conventions,
# test_urdf_oracle) import pinocchio; the same load-bearing pins as
# install/requirements-dev.txt and the RBDReference peer suite.
pip install "pin<4" cmeel-eigen "cmeel-urdfdom<5"
# cmeel-tinyxml2 11 ships libtinyxml2.so.11; pin 3.9 links .so.10.
pip install "pin<4" cmeel-eigen "cmeel-urdfdom<5" "cmeel-tinyxml2<11"

# The BROAD CPU set (audit W00, 2026-09-19): every test/test_*.py + the
# benchmark-spec guards + the CPU-only bindings modules. The former six-
Expand Down
207 changes: 204 additions & 3 deletions CHANGELOG.md
Original file line number Diff line number Diff line change
Expand Up @@ -10,12 +10,213 @@ Rigid Body Dynamics with Analytical Gradients*. That implementation is preserved
in the archival [robot-acceleration/GRiD](https://github.com/robot-acceleration/GRiD)
repository. Everything below describes the packaged A2R-Lab releases.

## [Unreleased]
## [0.7.1] — 2026-11-11

Output changes from 0.7.0: mimic and spherical inverse-mass matrices no longer
double off-diagonal entries in Python or forward-dynamics torque pullbacks;
native buffers have zeros below their symmetric upper triangle. Floating
MuJoCo integrators take the MuJoCo step and therefore have different values and
gradients. Retraction normalizes the input quaternion. Rizon4 uses vendor
inertials. Native and backend thread overrides clamp to the compiled kernel
limit, including overloaded and multitarget launches.

- Repair full six-axis bias-force projection and first derivatives for a lone
floating body. Document body-origin base wrenches and add independent
offset-COM discrete A/B, rotor-map and prepared-loading regressions.
- Initialize the entire reserved topology table before host-to-device upload,
including floating/mimic padding. Reject misaligned caller-owned allocation
slabs/cursors and overflowing requests without advancing the pool.
- Size the topology S-index section from its emitted entries as well as its
historical padding. Small floating mimic chains previously declared fewer
entries than their root and followers required and failed CUDA compilation.
- Preserve independent-slot armature in the polynomial embedding reference's
torque, mass and energy. Follower rotor parameters and floating-mimic
MuJoCo twins are not supported. Cross-feature tests cover the baked and
runtime dynamics, the frame derivatives and both integrator conventions.
- Align pose matrix scratch inside its queried allocation to prevent optimized
shared loads from overlapping the concurrently written matrix bank. Callers
still need only scalar alignment; regenerate headers and use the scratch
queries rather than hard-coded counts. Add optimized, exact-capacity
sanitizer coverage for pose and neighboring transform-chain consumers, and
account for trailing alignment padding in the debug arena equality check.
- Add compact armature torque regressors and explicit forward-dynamics parameter
sensitivity on native, NumPy, JAX and PyTorch surfaces. The sensitivity reuses
one forward solve under one model admission; ordinary builds gain no workspace.
Add a synthetic identification example with excitation and held-out checks.
- Clamp direct backend thread overrides to compiled kernel limits, consistently
with native host calls, including the register-heavy spherical Minv path.
- Read installed runtime inertias in the shared centroidal calculation, so
energy, CoM and momentum follow inertia updates rather than baked defaults.
- Accept a baked `armature` initializer at generator, registration and consumer
artifact entry points, with optional runtime tables. Expose parameter slots,
units and immutable initial values. New contexts and prepared loads start from
the artifact initializer; live updates do not change compilation identity.
Thanks to Felix Mühlenberend (`felixmueh`) for the baked-armature prototype in
PR #50 and the TIAGo application feedback.
- Preserve symmetric-upper inverse-mass storage on mimic and spherical models;
this prevents doubled off-diagonal entries in Python outputs and control-input
autograd. Ordinary scalar-joint recursion is unchanged.
- Validate runtime armature before precision conversion or mutation, reject
positive values lost to narrowing or flush-to-zero, reject unsupported and
constant-joint slots, and read installed values from their
owning context rather than a registration-name cache. Forward the runtime
option through JAX and PyTorch registration. Include rotor kinetic energy in
both generated energy paths; the ten-per-body inertial regressor is unchanged.
- Joint damping and friction on a coupled (mimic) joint now fold into the
leader's coordinate with `alpha^2 * damping` and `|alpha| * friction`
(the congruence `G^T B G` of the follower's own torque), in the generated
bias and gradients, the runtime joint-dynamics table and the numpy
reference. The previous fold used a single power of `alpha`, which
coincides on a ratio of one (fr3) and injected energy on a negative
ratio. Polynomial followers evaluate `alpha(q)` in the fold and gain the
`2 alpha alpha' b qd + sign(alpha) alpha' f s(qd)` term in `dtau/dq`;
the constant per-slot `runtime_joint_dynamics` table is refused for a
damped polynomial follower.
- `coriolis_matrix` generates for polynomial couplings: the embedding's
reduced matrix `G^T C_f G + G^T M_f Gdot`, whose inertia term the kernel
assembles from the composite inertias of its backward pass with `alpha(q)`
and `alpha'(q)` read at runtime; the numpy reference projects the same
expression and checks `C qd + g = bias` and `C + C^T = dM/dt`.
- `dccrba` and `cmm_time_variation` generate for polynomial couplings: the
derivative of `A_y = A_f G` adds the full tree's momentum column of each
follower times `alpha'(q)` at its leader's cell (times `qd` when
contracted); the reference projects the same and checks the tensor
against the chart, `Adot` along the flow and `hdot = A ydd + Adot yd`
analytically.
- MuJoCo-convention integrators on a floating base now take the MuJoCo step:
the velocity advances by `dt` times the MuJoCo-frame acceleration (whose
base-linear block carries `omega x v`), the base position by the
world-frame velocity of step k (euler) or k+1 (semi-implicit), the
quaternion and joints as pinocchio. The value kernels of `integrator` and
`plant_step` fed the raw world-frame base velocity and force into the
dynamics as local quantities and rotated nothing on output; the
`integrator_gradient` transform (numpy and kernel epilogue, and the
forward-mode clone of the `plant_step_hessian` twin) applied the plain
`G` reframe to the velocity rows, which disagrees with finite differences
of the MuJoCo step at first order in `dt`. The bottom rows are now
`[dt Fq | I + dt Fv | dt Fu]` with `F` the validated forward-dynamics
gradient transform. The floating-base mjx integrator backward is no longer
refused on the jax and torch surfaces and is checked against finite
differences of a loss through it in float64.
- A polynomial follower whose leader is not on an end effector's chain (a
gripper's cross-finger coupling) is now scaled by `alpha(q)` in the pose
and multitarget gradients; its lone Jacobian column was treated as an
unscaled single job. The multitarget smoke runners clamp their shared-tier
launches to the kernel's launch bound and check the launch.
- A spherical-joint model builds with `integrator_gradient` in its algorithm
list. Its gradient kernels support the single-stage schemes only (euler,
semi-implicit euler, constant acceleration; the multi-stage instantiations
are a static assertion), and the wrapper's gradient dispatch used to name
every scheme, so the build failed to compile. The generated header now
sets `GRID_INTEGRATOR_GRADIENT_SINGLE_STAGE_ONLY` and the integrator and
plant-step gradient dispatch on the three surfaces names only the
supported cases; a multi-stage request fails at call time with a message.
- `f_ext_gradient` and `f_ext_gradient_dq` generate for polynomial
couplings: `J_y^T = G^T J_f^T` with runtime `alpha(q)`, and the
configuration derivative adds `-(dG/dy)^T J_f^T` (the follower's own
pushdown row times `alpha'`) to the two-table `alpha_j alpha_m` product;
the reference projects the same and checks the affine identity in
`f_ext` and the chart.

- Frame kinematics: `frame_velocity` (the twist `J qd` of a frame) and
`frame_acceleration` (`J qdd + Jdot qd`, the spatial acceleration in
`LOCAL` and `WORLD` and the classical acceleration in
`LOCAL_WORLD_ALIGNED`) join the frame Jacobian family as opt-in generated
kernels with batched launchers and three-mode hosts; the numpy reference
gains the same functions, checked against Pinocchio's
`getFrameVelocity`, `getFrameAcceleration` and
`getFrameClassicalAcceleration`. Both are in the default `register_robot`
algorithm list and bound on the three Python surfaces as
`frame_velocity(q, qd, target_jid=, reference_frame=)` and
`frame_acceleration(q, qd, qdd, ...)`, returning `(B, 6)`; a floating
base gets the MuJoCo-convention twins (input conversion only, since the
outputs are frame quantities). Their derivatives follow:
`frame_velocity_gradient` (`[dv/dq | dv/dqd]`, 6 x 2 nv) and
`frame_acceleration_gradient` (`[da/dq | da/dqd | da/dqdd]`, 6 x 3 nv) in
the local tangent chart, on one generated inner (a world-origin Plücker
sweep, then one thread per velocity slot), bound on the three surfaces
with MuJoCo-convention twins (column reframe); the reference gains
`frame_velocity_derivatives` / `frame_acceleration_derivatives`, checked
against Pinocchio's `getFrameVelocityDerivatives` /
`getFrameAccelerationDerivatives` and against chart finite differences on
every robot of the manifest. Pinocchio's LOCAL_WORLD_ALIGNED
q-derivatives hold the frame origin fixed; GRiD's differentiate the
function, so they also carry the moving origin (and, for the
acceleration, the classical term), which is what a task-space constraint
needs.
- Closed loops by constraint embedding, first step: polynomial couplings. URDFParser reads `<mimic joint="l" polycoef="c0 c1
c2 c3 c4" q0="..."/>` (the MuJoCo joint equality, q = sum c_i (q_l -
q0)^i; a degree-one polynomial is the plain mimic) and offers
`parse(..., reduce_couplings=False)`, the full spanning tree with the
couplings recorded. The reference projects the full tree onto the
independent coordinates (`RBDReference/_embedding.py`: q = F(y),
qd = G yd, qdd = G ydd + Gdot yd, tau_y = G^T tau) for any robot with a
polynomial follower; on a mimic robot the projection equals the reduced
recursions to round-off. The generator evaluates alpha = dq_f/dq_l and
its two derivatives on the device from the leader's coordinate; inverse
dynamics, CRBA, Minv, forward dynamics, ABA and both first-order gradients
carry the new terms (the follower accelerates by alpha' qd_l^2, the
gradients gain the alpha' and alpha'' terms and (dG/dq)^T f) and are
checked on the GPU against the projection on both bases; so do the
end-effector pose and its gradient and the frame Jacobian family (J,
Jdot with its alpha' qd_l term, the task inertia, the frame velocity and
acceleration and their derivatives), the six integrators with their
`[A | B]` gradients, the joint-torque regressor and the energy
regressors, the forward-dynamics parameter gradient, the generalized
gravity and bias, the CoM, the centroidal momentum matrix and the
energies. Coriolis, momentum-matrix derivatives, external-force gradients
and runtime end-effector pose also support polynomial couplings. The pose
Hessian, regressor gradient, second-order dynamics and plant layer remain
refused. Polynomial followers own no armature slots: a constant hand-fold
of follower rotor inertia is not valid when alpha depends on configuration.
Armature on independent scalar slots remains a constant reduced inertia.
- Correctness: the floating-base integrator retract built the position update
from the raw input quaternion, so a non-unit quaternion moved the base by
its squared norm; the retract now normalises the input like every other
kernel (`f = f o normalize`). Unit inputs are unchanged.
- Differentiation: the integrator backward runs on floating-base and
spherical-joint models on the jax and torch surfaces. The state cotangent
of `x_{k+1}` is pulled onto the gradient kernel's tangent rows at `q_{k+1}`
through the chart's output map (`integrator_state_cotangent`: `R(q)` on the
pin linear block, `0.5 q (x) (delta, 0)` on each quaternion block, identity
on the MuJoCo linear block), then the `q` cotangent is pulled back to the
input quaternion as for every other op. Both surfaces refused these models
before; jax fell back to a non-differentiable call.
- Correctness: the second-order forward dynamics kernel (`fdsva_so`) now
forwards the model pointer to the forward dynamics inner it reuses. With
`runtime_joint_dynamics=True` on a damped robot the inner's bias read the
runtime table through a null pointer; builds without runtime joint dynamics
are byte-identical.
- Codegen: `enable_floating_second_order=False` no longer warns that
floating-base second order is "under development"; it is a plain opt-out.
- Known limit: on a free-floating arm at very high accelerations (hundreds
to thousands of rad/s^2) the float32 `fdsva_so` kernel returns two to three
significant digits. The inertia matrix of such a model has a condition
number near 5e4 and the kernel applies its inverse three times. The
behaviour is the same as in 0.7.0, and the double build agrees with the
reference. The floating diagnostic that compares `fdsva_so` with the
reference therefore stays opt-in
(`GRID_CUDA_FLOATING_SECOND_ORDER_ENABLE_FDSVA=1`) for every robot and is
outside the receipt; with the flag set, iiwa14, rizon4 and gen3 fail and
the five other floating robots pass.
- Tests: one shared thread-sweep helper (`test/cuda_equivalents/
thread_invariance.py`) replaces the per-module loops in fifteen CUDA
equivalence modules; the split driver fingerprints `from
test.cuda_equivalents import helper` imports too (two helper modules had
escaped it). gen3 joins the frame, tool-offset, quaternion-derivative,
dCCRBA and integrator oracle tests, with its continuous-joint round-off
classes recorded per key; the operational-space inertia oracle test checks
every sample through the backward-error tiers instead of skipping
ill-conditioned ones.
- Assets: the bundled rizon4 URDF's eight inertial elements now carry the
vendor's current table (flexiv_description `jazzy` at 7d5dd28c, 2026-10-19)
in place of hand-rounded values; kinematics and limits are unchanged.
`grid_assets/robots/URDF_SOURCES.md` records the provenance.
- Receipts: the first Jetson AGX Orin (sm_87) receipt,
`receipts/gpu-proof-sm87.json` with its header-key ledger, recorded at the
0.7.0 receipt commit 607efc2: 2056 tests, 2055 passed and the one expected
racecheck skip; `make verify-all` verifies it next to the primary. The
racecheck skip. It attests the 0.7.0 source, not this release; CI verifies
it against the commit it was recorded at. The
compatibility page's Orin row records that receipt in place of the 0.5.1
smoke runs.

Expand Down Expand Up @@ -615,7 +816,7 @@ update on top of that, organised here by theme:
- Closed kinematic loops are unsupported.
- No Windows, macOS, Jetson or precompiled-robot wheels.

[Unreleased]: https://github.com/A2R-Lab/GRiD/compare/v0.7.0...HEAD
[0.7.1]: https://github.com/A2R-Lab/GRiD/compare/v0.7.0...v0.7.1
[0.7.0]: https://github.com/A2R-Lab/GRiD/compare/v0.6.0...v0.7.0
[0.6.0]: https://github.com/A2R-Lab/GRiD/compare/v0.5.5...v0.6.0
[0.5.5]: https://github.com/A2R-Lab/GRiD/compare/v0.5.4...v0.5.5
Expand Down
Loading
Loading