Universal Robot Description Directory (URDD)

• Universal Robot Description Directory (URDD) is a modular, versioned framework that organizes robot models into interoperable, precomputed components.
• It improves efficiency and standardization by eliminating redundant runtime computations inherent in legacy formats like URDF.
• URDD employs an extensible directory structure and automated conversion pipeline, facilitating seamless integration with simulation, planning, and control applications.

The Universal Robot Description Directory (URDD) is a modular, versioned, data-centric framework for encoding, organizing, and distributing robot models, designed to supercede monolithic formats such as URDF by precomputing and packaging derived kinematic, dynamic, and geometric information into interoperable modules. URDD enables direct ingestion of comprehensive robot model data by simulation, planning, and control pipelines, eliminating the pervasive redundancy and fragmentation that arise when each tool independently parses and postprocesses legacy description files (Klein-Seetharaman et al., 29 Dec 2025).

1. Motivation and Context

Traditional robot description formats such as Unified Robot Description Format (URDF), Simulation Description Format (SDF), MuJoCo XML (MJCF), and Pixar’s Universal Scene Description (USD) encode only basic connectivity, inertial, and mesh information. Consequently, robotics frameworks—including MoveIt!, Drake, and MuJoCo—must repeatedly infer additional data (e.g., forward kinematic chains, joint mappings, Jacobians, dynamic parameter arrays, collision hulls) with each use of the specification, resulting in redundant computations, schema fragmentation, and limited cross-tool standardization (Klein-Seetharaman et al., 29 Dec 2025). URDD was introduced to address this by structuring all derived robot information into standardized, human-readable, and easily parsed modules, accessible to any downstream application via a unified interface.

2. URDD Directory Structure and Schema

URDD decomposes robot model information into a directory of version-tagged subfolders, each containing a specific module in JSON and YAML formats. The schema is extensible, allowing new modules (e.g., precomputed Jacobians, symbolic dynamic models) to be added without breaking backward compatibility or requiring parser updates.

Canonical URDD directory structure:

Subdirectory	Content Domain	Example Module
metadata.yaml/json	Robot name, version, schema, tags	metadata.yaml
urdf/	Base URDF structure (JSON/YAML)	robot.json
dof/	DOF↔joint mappings	dof.yaml
chain/	Link–joint hierarchy	chain.json
connections/	All link↔link paths	connections.json
bounds/	Joint limits	bounds.yaml
mesh/	Raw and converted meshes	.glb, .obj, .stl
convex_hulls/	Precomputed convex hulls	link0_hull.glb
convex_decomps/	Convex decomposition elements	link0_decomp.glb
link_shapes/	OBBs, spheres, skip-pair statistics	link_shapes.json

Additional or future modules encompass learned collision models, link distance statistics, Jacobians, and dynamic models.

Version tags per module (e.g., "chain-0.1.0") facilitate compatibility verification and selective regeneration by automated tools (Klein-Seetharaman et al., 29 Dec 2025).

3. URDF-to-URDD Conversion Pipeline

The URDD toolkit is implemented in Rust, providing a series of transformation and computation passes that automatically extract, precompute, and serialize all required modules from an input URDF. The pipeline includes:

1. Parsing URDF XML to construct an in-memory representation of links, joints, inertias, and meshes.
2. Counting non-fixed DOFs, generating forward and inverse joint–DOF mappings, and emitting the dof/ module.
3. Computing the kinematic chain for chain/, recording the parent–child link hierarchy per link.
4. For every link pair, computing the minimal joint/link path and storing in connections/.
5. Extracting joint bounds from URDF and exporting to bounds/.
6. For each referenced mesh, exporting graphical assets (.glb/.obj/.stl) to mesh/, computing convex hulls (e.g., via QuickHull) for convex_hulls/, and performing convex decompositions for convex_decomps/.
7. Computing oriented bounding boxes, bounding spheres, and collision skip-pairs for link_shapes/.
8. Optionally packaging per-link learned collision models using external learning pipelines.
9. Finalizing output as version-tagged JSON and YAML modules within the output directory (Klein-Seetharaman et al., 29 Dec 2025).

Every module is written atomically and carries independent versioning, supporting fine-grained consumption and third-party extensibility.

4. Precomputed Kinematics and Dynamics

URDD directly encodes robotics primitives typically rederived at runtime. Each link’s transform matrix for forward kinematics, $T_i(q)$, is provided in the module content and computed as: $$T_i(q) = \begin{bmatrix} R_{i-1,i}(q) & p_{i-1,i}(q)\ 0 & 1 \end{bmatrix}$$ with derivatives yielding Jacobians $J(q) = \partial p/\partial q$. Inertial matrices, provided per-link in their local frames ($I_i$), and the system’s rigid-body dynamics are expressed in the canonical form: $$M(q)\,\ddot{q} + C(q,\dot{q})\,\dot{q} + g(q) = \tau$$ This schema supports downstream modules for symbolic, numeric, or learned dynamics, all shareable as future URDD extensions (Klein-Seetharaman et al., 29 Dec 2025).

5. Visualization and Application Integration

URDD includes open-source visualization and inspection tools:

• Bevy/Rust Application: Uses a loader subsystem to ingest metadata, discover modules, and spawn ECS resources per module; MeshSystem attaches graphical assets to link entities, HullSystem/DecompSystem overlay collision geometry. Module parsing is unified under serde_json/serde_yaml-based deserialization.
• JavaScript/Three.js Viewer: Web-based client loads each .json module, reconstructs a scene graph with THREE.Group nodes per robot link, and exposes UI for geometry toggling, FK-driven joint angle manipulation, and collision shape overlay.

These tools enforce module independence: consumers load only the modules required for their task. For instance, a dynamics solver may ingest dof/, chain/, and bounds/ without requiring mesh/ or convex_hulls/ (Klein-Seetharaman et al., 29 Dec 2025).

6. Empirical Benchmarks and Standardization Impact

Experimental benchmarks on real robot platforms show that URDD generation remains computationally tractable. For example, conversion (Apple M3, 32 GB RAM):

• UR5e (6 DOF/11 links): 25.6 s
• XArm7 (7 DOF/10 links): 21.3 s
• B1 Quadruped (12 DOF/35 links): 60.0 s
• Orca hand (17 DOF/55 links): 90.5 s
• H1 (19 DOF/25 links): 69.3 s

Data size grows relative to URDF due to storage of additional mesh formats, collision decompositions, and kinematic/dynamic modules, e.g., UR5e: 6.7 MB (URDF+meshes) versus 31.8 MB (URDD+meshes), reflecting the incorporation of the full module set (Klein-Seetharaman et al., 29 Dec 2025).

A key metric: "lines-of-code to first forward kinematics (FK) call" is reduced to zero in URDD (Rust/Python); all preprocessing dependencies are captured in modules. In contrast, URDF backends require significant code for parsing and computation: PyKDL (~730 lines), Drake (~880), Klampt (~315), IsaacSim (USD, ~1,892), MuJoCo (MJCF, ~3,784) (Klein-Seetharaman et al., 29 Dec 2025).

7. Extensibility, Community Conventions, and Future Directions

URDD’s module-per-file organization allows seamless addition of new informational domains (e.g., precomputed dynamics, symbolic solutions, learned skills) without disruption to existing workflows or parsers. Per-module version tags support stale-data detection and partial regeneration. The open specification anticipates a registry of community-contributed modules, provenance and licensing metadata (SPDX tags), and automated CI pipelines for cross-tool validation (Tola et al., 2023, Klein-Seetharaman et al., 29 Dec 2025).

Best practices, informed by URDF community analyses, include:

• Adopting a meta-information schema with controlled vocabularies for robot types, licensing, and Xacro provenance flags
• Folder hierarchies matching established conventions for mesh and description colocation
• Provision of multiple mesh fidelities and explicit separation between collision and visual geometry
• Automated schema and module validation against canonical parsers (ROS, urdfpy, pybullet, yourdfpy)
• Encouragement of author-provided contact fields to support model provenance and correction (Tola et al., 2023)

Future URDD work targets dependency DAGs between modules, tighter CAD-to-URDD pipelines, and a collaborative ecosystem for continued schema evolution.

---

URDD establishes a unified, open-source, module-based intermediary between raw robot specifications and the growing suite of tools in robotics. By precomputing all downstream dependencies and standardizing their representation, URDD reduces integration latency, eradicates redundant computation, and provides a foundation for robust, extensible, and cross-community sharing in robot modeling (Klein-Seetharaman et al., 29 Dec 2025).