RoboCompiler: Graph-Native Compilation of Closed-Chain Robots for Consistent Modeling, Control, and Simulation

Mehdi Heydari Shahna; Joongheon Kim; Jouni Mattila

cs.ROSep 28, 2026

RoboCompiler: Graph-Native Compilation of Closed-Chain Robots for Consistent Modeling, Control, and Simulation

Authors: Mehdi Heydari Shahna, Joongheon Kim, Jouni Mattila

Organizations: Faculty of Engineering and Natural Sciences, Tampere University, Tampere, Finland

Abstract

Robots with kinematic loops, coupled actuators, and changing contacts require consistent models of configuration, motion, force, and dynamics. Yet these interfaces are often reconstructed separately for control and simulation, making closure and actuation consistency difficult to maintain. This paper presents RoboCompiler, a graph-native framework that compiles a canonical mechanism graph into a shared mechanical interface. From bodies, joints, frames, inertias, and actuator ports, it constructs closure paths and analytic residual Jacobians, then assembles feasible configurations through rank-checked continuation and correction. A tangent lift maps independent velocities to full robot and task motion, while paired actuator-port maps preserve virtual work. A constraint-curvature correction extends the reduction to accelerations and projected rigid-body dynamics, including floating-base and support modes. Cycle-local evaluation, generated Jacobians, and dependency-aware reuse enable localized updates when closure inputs change. We evaluate physical loops and task-induced constraints on a industrial excavator, Unitree Go2, Franka Panda, Kangaroo, and a six-UPS Stewart platform. High-precision constrained-dynamics and independent Pinocchio checks confirm mechanical consistency; MuJoCo and Isaac Sim/PhysX executions demonstrate task performance and model reuse under native contact. For Kangaroo, compilation reduces residual-and-Jacobian evaluation time by 96.7% and closed-loop rollout wall time by 66.8%, with dynamics and control held fixed.

Figures & tables

Work	Loops in model	Auto. cut sel.	Closure types	Assem- bly	Tangent map	$\dot{J}\dot{q}$ term	Port maps	FD	Float. base + contact	Multi- sim.
Bordalba et al. [ 5 ]	–	–	holonomic $\Phi(q)=0$	$\checkmark$	$\circ$ a	–	–	manifold ODE	– b	–
HyRoDyn [ 6 , 7 ]	$\circ$	$\times$	submechanism library c	$\checkmark$	$\checkmark$	$\checkmark$ (A)	$\checkmark$	R	–	–
Kangaroo model [ 8 ]	$\checkmark$	$\times$	relative pose, selected axes	$\checkmark$	$\checkmark$	$\checkmark$ (A)	$\checkmark$	ID only d	$\checkmark$	$\circ$
URDF+ [ 2 ]	$\checkmark$	$\times$	URDF joint types, linear couplings	–	$\circ$	–	$\circ$	n/a e	–	–
Constraint embedding / GRBDA [ 10 , 11 ]	$\checkmark$ f	$\times$	explicit $G$ , implicit $\phi(q)$	$\circ$	$\checkmark$	$\checkmark$ (A)	$\circ$	Rec	$\circ$	$\circ$
LCABA [ 14 ] / Pinocchio 4.1 [ 13 , 15 ]	$\circ$	$\circ$ g	point (3D), weld (6D)	$\circ$ h	$\times$	$\checkmark$ (A) i	$\circ$	K, Rec	$\checkmark$	$\circ$ j

TABLE I: Capabilities of closed-chain modeling and dynamics tools.

\checkmark

: yes;

\circ

: partial;

\times

: no; –: not stated in the primary source; n/a: not applicable. Loops in model: closures are part of the model/graph description. Auto. cut sel.: spanning tree and cut joints chosen automatically from a general body–joint graph. Assembly: built-in position-level closure solve. Tangent map: explicit map from independent to full velocities. Port maps: explicit actuator-port velocity map with its dual (virtual-work-consistent) effort map;

\circ

= joint-space torques, gears or couplings only. FD: R = reduced/projected, K = Lagrange-multiplier/KKT, Rec = recursive, S = soft (regularized) constraints; A/N = analytic/numerical

\dot{J}\dot{q}

. Float. base + contact: floating-base models with contact or support constraints (bilateral or unilateral). Multi-sim.: execution or validation of the same model in external simulators or dynamics libraries (

\checkmark

: several;

\circ

: one).

Symbol	Definition
$q\in\mathcal{Q}$ , $v\in R^{n}$	Augmented configuration and generalized velocity
$\rho\in R^{s}$ , $C$	Full closure residual; $C=D\rho\,N$
$r$ , $d=n-r$	Closure rank and independent velocity dimension
$u\in R^{d}$ , $E$	Independent speeds and lift $v=Eu$
$v_{T}$ , $E_{T}$	Tree speeds and their lift $v_{T}=E_{T}u$
$x$ , $J$	Task coordinates and reduced task Jacobian

TABLE II: Principal quantities and their roles.

Robot	Mechanism or imposed constraints	Task	Native PhysX result
Komatsu PC138US-8	Nine revolute cuts; seven independent arm speeds	Excavation and settled soil transfer	92.153 kg delivered; 11.46- $\mu$ m peak arm gap
Unitree Go2	Tree; four foot targets and two- to four-foot support	26-s rail, turn, gate, and docking course	6.926-mm base-position RMS ( $t\geq 2$ s)
Franka Panda	Tree; equal finger displacements and six-dimensional tool target	22-s grasp, inspection, and keyed-socket placement	0.133-mm final planar placement error
Kangaroo	Sixteen point and eight universal cuts; six base and twelve motor speeds	10-s landing, crouch, and push recovery	120.078-mm crouch; 0.629- $\mu$ m peak point gap
Six-UPS Stewart	Six limbs with spherical closure; six independent lengths	22-s six-axis inspection with platform wrenches	0.717-mm platform-position RMS; 6.454- $\mu$ m peak gap

TABLE III: Evaluation systems and nominal native Isaac Sim/PhysX executions. The last column reports task-specific metrics.

Fig. 5: The five evaluation platforms (top) and the simulation models used in all experiments (bottom): the Komatsu PC138US-8 excavator, Unitree Go2, Franka Panda, Kangaroo, and six-UPS Stewart platform.

Robot	Set A: recorded states	Set B: randomized states
Stewart	All 1101 reference knots, with recorded actuator velocities and feedforward forces; no external wrench.	300 states. Reference knot sampled uniformly; actuator velocities $\mathcal{U}(\pm 0.25)$ m/s; actuator forces $\mathcal{U}(\pm 400)$ N; external force components $\mathcal{U}(\pm 120)$ N and moment components $\mathcal{U}(\pm 12)$ N m.
Excavator	48 dynamics witnesses at route indices evenly spaced from 20 to 4181.	252 states. Route index sampled uniformly from 20–4180; independent velocities $\mathcal{U}(\pm 0.3)$ rad/s. Each effort is sampled as $\mathcal{U}(\pm 1)$ times its scale: 5, 5, 30, 150, 150, and 500 kN for the six cylinders, and 1 and 25 kN m for the rotary drives. External force components are $\mathcal{U}(\pm 5)$ kN and moment components are $\mathcal{U}(\pm 2)$ kN m.
Kangaroo	48 dynamics witnesses at motion indices evenly spaced from 8 to 392, cycling through floating, left-sole, right-sole, and double-support modes.	152 states, with 38 per support mode. Motion index sampled uniformly from 8–392; independent velocities $\mathcal{U}(\pm 0.12)$ in their respective m/s or rad/s units; motor efforts $\mathcal{U}(\pm 200)$ N. External force components use ranges $\pm 15$ , $\pm 15$ , and $\pm 10$ N; moment components use $\mathcal{U}(\pm 2)$ N m.

TABLE IV: Sampling protocol for the dynamics comparison.

\mathcal{U}(\pm a)

denotes independent uniform draws in

[-a,a]

for each component. Set A contains recorded states; set B contains randomized velocities, efforts, and wrenches at configurations sampled from the reference motions.

Method	$\delta_{a}$ max	$\delta_{a}$ median	$\delta_{f}$ max	$r_{c}$ max	$t$
Stewart platform: 24 tree coordinates, 6 point cuts (18 rows, rank 18); 1,401 states
RoboCompiler (authors’ code)	$1.6{\times}10^{-8}$	$2.5{\times}10^{-10}$	$4.9{\times}10^{-10}$	$2.4{\times}10^{-7}$	$22.3\,\mathrm{ms}$
Pinocchio 4.1 lcaba , $\mu{=}10^{-6}$	$9.3{\times}10^{-9}$	$2.1{\times}10^{-9}$	$1.5{\times}10^{-9}$	$1.1{\times}10^{-13}$	$19\,\mu\mathrm{s}$
Pinocchio 4.1 lcaba , $\mu{=}10^{-2}$	$9.8{\times}10^{-13}$	$5.5{\times}10^{-13}$	$1.4{\times}10^{-13}$	$8.0{\times}10^{-13}$	$28\,\mu\mathrm{s}$
Pinocchio 4.1 constraintDynamics	$7.6{\times}10^{-14}$	$3.3{\times}10^{-14}$	$3.1{\times}10^{-15}$	$6.4{\times}10^{-13}$	$16\,\mu\mathrm{s}$
MuJoCo 3.3.7 equalities	$2.6{\times}10^{-1}$	$4.0{\times}10^{-3}$	$3.0{\times}10^{-3}$	$6.6{\times}10^{-1}$	$22\,\mu\mathrm{s}$

TABLE V: Constrained forward dynamics at identical feasible states. Errors use a 50-digit hard-constraint KKT reference and Eq. ( 23 );

r_{c}=\|J_{c,T}a+\gamma_{c,T}\|_{\infty}

has components in m/s 2 , rad/s 2 , or s -2 for universal-axis rows. Time

t

, the median of per-state mean call times, is measured separately on 100 Stewart/excavator or 40 Kangaroo states, on one 2.80-GHz Xeon core with one BLAS thread. RoboCompiler is a Python reference implementation. Pinocchio timings cover the native solver call; MuJoCo timings include native-array assignment and mj_forward ; Kangaroo timings cover the complete Schur recipe. State conversion and model construction are excluded from the native timing scopes. † Pinocchio 4.1 lacks native universal-loop rows; eight rows are added by a Schur recipe requiring ten native solver calls per acceleration. ‡ Below the estimated excavator reference floor from alternate well-conditioned independent subsets of redundant rows:

\delta_{a}

max

6.5\times 10^{-10}

, median

4.1\times 10^{-11}

;

\delta_{f}

max

2.3\times 10^{-12}

. Such entries agree with the reference to within its resolution and are mutually indistinguishable.

Robot	Paired operation	Reference	Generated/local	Reduction
Excavator	Residual + analytic Jacobian (ms)	4.097	0.984	76.0%
Excavator	Joint-reference correction + maps (s)	24.117	18.026	25.3%
Excavator	Held-cylinder correction + maps (s)	24.493	16.628	32.1%
Go2	One-foot update (ms)	3.467	1.326	61.8%
Go2	Colored FD / analytic correction (ms)	9.657	4.311	55.4%
Kangaroo	Residual + analytic Jacobian (ms)	10.172	0.339	96.7%

TABLE VI: Matched computational ablations. Times are medians except the final row, which averages two counterbalanced runs per evaluator. Scheduled excavator times are median summed correction-plus-map times over three traversals. Numerical derivative pairs use matched correctors and stopping criteria. Each row is a matched pair measured on a single host and workload. FD denotes finite differences.

Case	RMS (mm)	Final (mm)	Motor (%)
Nominal, 1-ms step	6.926	0.179	68.43
0.5-ms step	6.736	0.474	64.22
Friction 0.55	6.855	0.265	72.26
1.5-kg payload	8.897	6.655	59.88
25% stronger pushes	7.237	0.222	100.00

TABLE VII: Go2 native PhysX perturbations. RMS uses

t\geq 2

s; final error is at 26 s. Motor utilization is the maximum command normalized by the authored limit.

Explore similar work

Jun 25, 2026cs.RO

RelAfford6D: Relational 6D Affordance Graphs for Constraint-Driven Robotic Manipulation

Bridging abstract semantics and precise physical control remains a fundamental challenge in open-world robotic manipulation. While recent data-driven policies show promise, their reliance on isolated contact points or latent affordance embeddings lacks the rigorous kinematic constraints necessary for complex articulated objects.To overcome the limitation, we introduce RelAfford6D, a novel training-free framework centered on a Relational 6D Affordance Graph. Given a free-form instruction, our system deduces a semantic topology linking a primary interacting part to its physical anchor. By elevating these topological nodes into precise metric

SE(3)

poses via vision foundation models, we analytically formulate downstream execution as a kinematic constraint satisfaction problem. The robot synthesizes continuous trajectories by tracking strictly defined physical manifolds (e.g., revolute or prismatic orbits). Coupled with a closed-loop tracking mechanism for dynamic replanning against disturbances, our physically grounded approach achieves superior zero-shot success rates, cross-category generalization and execution robustness in both simulation and the real world environments, outperforming existing data-driven baselines.

Guodong Zhang, Qichen He, Wenyuan Xie +6

School of Computer Science, Shanghai Jiaotong University, Shanghai, P. R. China

Robotic Manipulation Kinematics Iterative Re-Planning

Ask PDF

May 29, 2026cs.RO

Batched Differentiable Rigid Body Dynamics in PyTorch for GPU-Accelerated Robot Learning

As robot control shifts toward large-scale reinforcement learning with in-loop dynamics computation, the community's reliance on CPU-bound libraries such as Pinocchio creates a throughput bottleneck in GPU-based training pipelines. We present BARD (Batched Articulated Rigid-body Dynamics), a self-contained PyTorch implementation of Featherstone's rigid-body dynamics algorithms, optimized for batched GPU evaluation and automatic differentiation. Three design choices make this efficient: a tiered lazy-evaluation cache that avoids redundant tree traversals, matmul-free joint transforms via pre-computed Rodrigues constants, and level-parallel propagation that reduces sequential operations to tree-depth batched steps. On five robot models (7-23 DOFs), BARD matches Pinocchio numerically while reaching up to 64x higher throughput for Forward Kinematics and 63x for Jacobians at batch size 4096 on an NVIDIA H200. We validate differentiability through gradient-based system identification on a 7-DOF manipulator, recovering link masses to 1.24% mean error under 5% torque noise, and integrate BARD into an Isaac Lab AMP training pipeline for an 11-DOF spined quadruped with 4096 parallel environments, where it is 8.5x faster than Pinocchio and 2.0x faster than ADAM for in-loop dynamics. BARD is open-sourced at: https://github.com/YueWang996/bard-pytorch-dynamics.

Yue Wang, Yanran Xu, Wenbo Wu +2

University of Southampton, Southampton, SO17 1BJ, UK

Rigid-Body Dynamics Pytorch Differentiable Physics Cpu-Gpu Hybrid Designs Multi-Turn Reinforcement Learning

Ask PDF

Sep 11, 2024cs.RO

Highly-Efficient Differentiable Simulation for Robotics

Robotics simulators have improved significantly in computational speed and scalability, enabling them to generate years of simulated data for complex systems in minutes or hours. Despite these advances, efficiently and accurately computing simulation derivatives remains an open challenge. Addressing this would accelerate the convergence of reinforcement learning and trajectory optimization algorithms, particularly for contact-rich problems. This paper introduces a unifying framework for robotic simulation that accounts for all factors, including dynamics, collisions, and friction. The resulting algorithm computes analytical derivatives of the simulation by implicit differentiation, explicitly handling the intrinsic non-smoothness of the collision and frictional stages while exploiting the sparsity induced by the multi-body structure. Benchmark results demonstrate state-of-the-art performance, with timings ranging from

5\,μ

s for a 7-dof manipulator to

95\,μ

s for a 36-dof humanoid, an improvement of at least two orders of magnitude over alternative methods. Implemented in C++, the code will be open-sourced after the review process to support applications such as simulation-driven learning and real-time control.

Quentin Le Lidec, Louis Montaut, Yann de Mont-Marin +3

Inria, Ecole normale sup´erieure CNRS, PSL Research University 75005 Paris, France

Rigid-Body Dynamics Differentiable Physics Robot Trajectories Implicit Differentiation

Ask PDF