URDF-to-URDD Conversion Pipeline

• URDF-to-URDD Conversion Pipeline is an automated framework that translates URDF/URDF+ robot models into a modular, extensible URDD format supporting closed-chain kinematics.
• It employs efficient algorithms such as constraint dependency digraph construction and SCC decomposition to aggregate links and encode loop and coupling constraints.
• The modular output enhances integration with dynamics engines, simulation frameworks, and planning systems for advanced real-time robotics control.

The URDF-to-URDD conversion pipeline is the set of algorithms, data structures, and software components that automatically translate standard Universal Robot Description Format (URDF) or its loop-augmented extension (URDF+) files into the Universal Rigid-Body Dynamics Description (URDD), a modular, machine-readable robot model representation designed to support standardized, constraint-embedded, and extensible robotics workflows—including, critically, closed-chain kinematic topologies. This pipeline synthesizes canonical robot description XML into a directory of JSON or C++ object modules, embedding not only basic geometry and kinematics but also richer dynamics, constraint topologies, and precomputed analysis products essential for control, planning, and visualization frameworks (Chignoli et al., 2024, Klein-Seetharaman et al., 29 Dec 2025).

1. Motivation and Context

Traditional URDF captures robots as kinematic trees—an inherent limitation that precludes direct representation of closed chains and kinematic loops common in modern robots. While some simulation environments implement workarounds, the absence of first-class loop support in URDF fragments software stacks and complicates analytical derivations. URDF+ addresses this by introducing backward-compatible XML elements (<loop>, <coupling>) encoding both implicit loop closure constraints and explicit kinematic couplings. The goal of the URDF-to-URDD pipeline is to create a faithful, lossless, and extensible translation from (possibly looped) robot specifications to a modular data directory (URDD) consumable by both real-time dynamics engines and high-level toolchains (Chignoli et al., 2024, Klein-Seetharaman et al., 29 Dec 2025).

2. Pipeline Architecture and Workflow

The automated URDF-to-URDD pipeline, as detailed in (Chignoli et al., 2024), consists of five major stages designed for both expressivity and computational efficiency:

1. URDF+ XML Parsing: Consumes <robot>, <link>, <joint>, <loop>, and <coupling> XML, producing a connectivity graph $G$ comprising the robot’s bodies and joints, both tree and loop.
2. Constraint Dependency Digraph Construction: Constructs digraph $D$ capturing dependencies induced by both joints and closed-chain loops. Paths and nearest common ancestors are computed to correctly index dependencies and coupling chains.
3. Strongly Connected Component (SCC) Decomposition: Applies linear-time algorithms (Tarjan/Kosaraju) to partition $D$ into maximal subgraphs—“super-links”—whose contents are mutually dependent due to loops, forming the basis for subsequent aggregation.
4. Loop-Aggregated Connectivity Graph: Aggregates links and maps constraints, emitting a tree over super-links while embedding local loop/coupling constraints within the super-link structure.
5. URDD Generation: Materializes objects linking back to URDD::Model, URDD::Link, URDD::TreeJoint, URDD::LoopJoint, and URDD::CouplingConstraint, converting both topology and attributes into JSON or C++ objects compatible with rigid-body-dynamics solvers.

This process executes in time $O(|B| + |T| + |L|)$, where $|B|$ is number of bodies, $|T|$ of tree joints, and $|L|$ of loops, and is thus suitable for robots of substantial complexity (Chignoli et al., 2024).

3. Enhanced Schema: URDF+ Elements and Their URDD Mapping

URDF+ extends standard URDF with:

• <loop> nodes, parameterized by joint type, predecessor/successor link, origin, and axis. These encode loop-closure constraints $\varphi_k(q)=0$.
• <coupling> nodes, expressing explicit joint space couplings as $\sum_{i\in\nu_p} q_i = \eta\sum_{j\in\nu_s}q_j$.
• independent="true|false" attribute on joints, for marking independent (generalized) coordinates.

These are parsed to equivalent URDD classes:

XML Tag	URDD Class	Field Mapping
<robot>	URDD::Model	name
<link>	URDD::Link	inertial, visual, collision
<joint>	URDD::TreeJoint	parent, child, transform, type, axis, isIndependent
<loop>	URDD::LoopJoint	predecessor, successor, transforms, type, axis
<coupling>	URDD::CouplingConstraint	predChain, succChain, ratio

This mapping is both explicit and backward-compatible, ensuring legacy toolchains ignore unknown extensions (Chignoli et al., 2024).

4. Algorithms, Data Structures, and Module Generation

The core of the pipeline is the automated clustering of interconnected bodies into super-links using SCC decomposition to maximize computational efficiency for downstream recursive dynamics:

• Connectivity and Dependency Graphs: Built using adjacency lists, supporting efficient traversal and ancestor queries.
• Nearest-Common-Ancestor (NCA) Computation: Optimized via level-ancestor data structures to avoid repeated tree traversals.
• Aggregation and Remapping: All links, tree-joints, and loop/coupling constraints are remapped to operate at the granularity of super-links.
• Parser Algorithms and Code: Pseudocode for the pipeline, C++ routines for LoopJoint construction, and XML schema snippets for URDF+ extensions are explicitly provided (Chignoli et al., 2024).
• Modular Output (URDD Modules): For conventional tree kinematics, each link’s origin, inertial, and visual meshes are extracted. Preprocessing additionally yields convex hulls (Quickhull), convex decompositions (VHACD), OBBs (covariance-based), and minimum enclosing spheres (Welzl’s algorithm) for accurate collision proxies (Klein-Seetharaman et al., 29 Dec 2025).

Modules are serialized to per-robot directory trees as JSON and YAML with version tags and externally referenced mesh assets, assembling a resource-efficient, human- and machine-readable model (Klein-Seetharaman et al., 29 Dec 2025).

5. Dynamics Integration for Closed-Chain Systems

The output URDD, by design, is fully compatible with recursive rigid-body dynamics libraries handling closed-chain constraints. The formulation is as follows:

Let $q\in\mathbb{R}^n$ be spanning-tree joint coordinates. Implicit constraints $\varphi(q)=0$ (enforced by loop joints) are captured via their Jacobian $K(q)=\partial\varphi/\partial q$ and time derivative $k(q,\dot{q})$; dynamics evolve per: $$H(q)\ddot{q} + C(q,\dot{q}) + G(q) = \tau + K(q)^\top\lambda\ K(q)\ddot{q} + k(q,\dot{q}) = 0$$ with $\lambda\in\mathbb{R}^m$ as constraint forces (Chignoli et al., 2024).

Aggregating bodies by SCC into super-links reduces closed-chain internal solves to local, low-dimensional linear systems, preserving $O(n)$ recursion for systems with sparse, local loops. Explicit form coupling, where $q = \gamma(y)$ for minimal coordinates $y$, results in $q = G(y)\dot{y}$ and corresponding augmentations of the above dynamics (Chignoli et al., 2024).

6. Software Toolchain and Visualization

URDF-to-URDD pipelines have been implemented in Rust, with three main components (Klein-Seetharaman et al., 29 Dec 2025):

• urdd-core: Core data types (RobotModel, Module<T>), trait-based module generator architecture.
• urdd-cli: Command-line interface for ingesting URDF, managing module/toggles, orchestrating parallel processing (rayon), mesh file organization, and convex decomposition.
• urdd-bevy-viewer: Bevy 0.11 ECS engine plugin, loads modules as resources, spawns scene-graph entities for links, shapes, and collision/geometry proxies; egui-based UI for toggling collision-skip matrices.

Additionally, a pure JavaScript/Three.js web viewer consumes URDD modules (via REST), reconstructs scene graphs, animates joint kinematics with on-the-fly origin/axis transforms, visualizes geometric proxies, and overlays user-editable collision matrices. All modules are loaded as JSON/YAML, enabling unified toolchain consumption and direct browser-based inspection (Klein-Seetharaman et al., 29 Dec 2025).

Performance is near-interactive: typical 20-link robots parse, process, and serialize all modules in under 1 second (CPU-bound parallel mesh steps included), with optional convex decompositions requiring a few additional seconds. Scene graph rendering and geometry overlays support real-time feedback with 10K-triangle model loads at 60 fps (Klein-Seetharaman et al., 29 Dec 2025).

7. Significance, Extensibility, and Current Limitations

The URDF-to-URDD pipeline standardizes the extraction and enrichment of robot models for a broad spectrum of downstream tasks. By supporting closed chains with constraint embedding (URDF+), modular output, and parallelized enrichment (mesh hulls, collision proxies, kinematic path precompute), URDD enables reduction of redundant computation and model-dependent code across simulation, planning, and control (Chignoli et al., 2024, Klein-Seetharaman et al., 29 Dec 2025).

The modular design also supports version tracking, per-module update, and selective downstream consumption. As of v1.0, forward kinematic transforms and Jacobians are mentioned as future module extensions (Klein-Seetharaman et al., 29 Dec 2025). A plausible implication is that closed-chain support and explicit constraint modules, as formalized in URDF+/URDD, will facilitate further integration with symbolic planners and learning-based controllers.

Existing limitations include the requirement that original URDF files be syntactically standard or URDF+ compliant; legacy URDF remains unperturbed by URDF+ tags due to backward compatibility. Mesh processing for very large models (1000+ links) remains computationally bounded by hull and decomposition algorithms, although these are parallelized.

• "URDF+: An Enhanced URDF for Robots with Kinematic Loops" (Chignoli et al., 2024)
• "Beyond URDF: The Universal Robot Description Directory for Shared, Extensible, and Standardized Robot Models" (Klein-Seetharaman et al., 29 Dec 2025)