URDF (Unified Robot Description Format) is an XML file format used to describe the physical structure, kinematics, and visual properties of a robot within the Robot Operating System (ROS). It defines a robot as a tree of links (rigid bodies) connected by joints (revolute, prismatic, fixed, etc.), specifying their geometry, inertial properties, and coordinate transforms. This model is essential for simulation in tools like Gazebo, for motion planning with MoveIt, and for visualization in RViz.
Glossary
URDF

What is URDF?
URDF (Unified Robot Description Format) is the fundamental XML schema used within the Robot Operating System (ROS) ecosystem to define a robot's physical and kinematic properties for simulation and control.
While foundational, URDF has limitations: it cannot describe closed kinematic chains, loops, or model flexibility. For more complex simulations, the SDF (Simulation Description Format) format is often used, as it supports nested models, advanced physics, and world descriptions. The URDF file serves as the single source of truth for a robot's mechanical design, enabling consistent behavior across perception, planning, and control software stacks by providing a standardized digital blueprint.
Key Components of a URDF File
A URDF file is an XML tree that defines a robot's physical structure for simulation and control. It is composed of several core elements that describe its rigid bodies, their connections, and their visual properties.
Link Element
A link element defines a rigid body segment of the robot. It is the fundamental building block representing a physical part, such as a chassis, arm segment, or wheel.
- Each link contains inertial properties (mass, center of mass, moment of inertia).
- It defines visual geometry (shape, color, texture for rendering).
- It defines collision geometry (a typically simplified shape used for physics calculations).
- Example:
<link name="base_link">describes the robot's main body.
Joint Element
A joint element defines the connection and relative motion between two links. It specifies the kinematic relationship and constraints.
- Key attributes include type (e.g.,
revolute,prismatic,fixed,continuous). - It defines the parent and child links.
- It specifies the axis of rotation or translation.
- It can include limits for position, velocity, and effort.
- Example: A
<joint type="revolute" name="elbow_joint">connects an upper arm link to a forearm link.
Visual Geometry
The visual property of a link describes its appearance in a 3D renderer or visualization tool. It is used for creating a realistic or schematic view of the robot.
- Geometry can be a box, cylinder, sphere, or mesh (imported from a file like
.stlor.dae). - Includes material properties for color (
<color rgba="0 0.5 1.0 1.0"/>) or texture. - Crucially, the visual geometry does not affect physics simulation; it is for display only.
- Example: A complex gripper might use a mesh file for detailed visual representation.
Collision Geometry
The collision property of a link defines the simplified shape used by the physics engine to compute contacts, collisions, and dynamics.
- Typically uses primitive shapes (box, cylinder, sphere) for computational efficiency, even if the visual geometry is a complex mesh.
- The collision geometry can be a different size and shape than the visual geometry to optimize simulation speed.
- Accurate collision geometry is critical for realistic contact dynamics and manipulation tasks in simulation.
- Example: A robot link shaped like an 'L' might use two overlapping boxes for its collision model.
Inertial Properties
The inertial tag within a link defines its dynamic properties, which are essential for accurate physics simulation.
- Mass: The weight of the link in kilograms.
- Origin: The pose of the center of mass relative to the link's coordinate frame.
- Inertia Matrix: A 3x3 matrix representing the rotational inertia about the center of mass. This determines how the link resists angular acceleration.
- Omitting or incorrectly specifying inertial properties leads to unrealistic or unstable simulation behavior.
- Example:
<inertia ixx="0.001" ixy="0.0" ... />
Extensions: Xacro & SDF
URDF has limitations, leading to the use of macros and more powerful formats.
- Xacro (XML Macros): A macro language that extends URDF, allowing for parameterization, code reuse, and conditional statements to manage complex robots without repetitive XML.
- SDF (Simulation Description Format): A more feature-rich successor used by simulators like Gazebo and Ignition. SDF supports nested models, plugins, atmosphere and physics properties, and is better suited for describing entire simulated worlds.
- URDF files are often processed by
xacrointo a flat URDF, which can then be converted to SDF for use in physics simulators.
How URDF Works in Simulation and Control
The Unified Robot Description Format (URDF) is the foundational XML schema used within the Robot Operating System (ROS) ecosystem to define a robot's physical and kinematic properties for simulation, visualization, and control.
A URDF file defines a robot as a tree of links (rigid bodies) connected by joints (revolute, prismatic, fixed). Each link contains visual geometry for rendering, collision geometry for physics, and inertial properties like mass. This hierarchical structure explicitly models the robot's kinematic chain, enabling algorithms for forward kinematics and inverse kinematics to compute end-effector poses and required joint angles. The format is essential for loading a robot into simulators like Gazebo or Ignition, where it serves as the blueprint for the simulated entity.
In control systems, the URDF's kinematic and dynamic descriptions are parsed to generate the Jacobian matrix for velocity control and to compute inverse dynamics for torque control. For sim-to-real transfer, the URDF's accuracy is critical; discrepancies between the modeled inertial properties, joint limits, and friction models and the real hardware create a reality gap. Engineers often refine the URDF through system identification to improve simulation fidelity, ensuring policies trained in simulation exhibit robust behavior when deployed to physical robots.
URDF vs. SDF: A Comparison
A feature comparison between the Unified Robot Description Format (URDF) and the Simulation Description Format (SDF), two XML-based standards for defining robots and environments in simulation.
| Feature | URDF (Unified Robot Description Format) | SDF (Simulation Description Format) | Primary Use Case |
|---|---|---|---|
Format Origin & Ecosystem | Created for ROS (Robot Operating System). | Created for the Gazebo/Ignition simulator family. | URDF: ROS-centric workflows. SDF: Gazebo/Ignition simulation. |
Model Scope | Describes a single robot. Cannot define static worlds or multiple independent models. | Describes entire simulated worlds, including multiple robots, static objects, lights, and terrain. | URDF: Single robot. SDF: Complete simulation scene. |
Kinematic Tree Structure | Strictly a single, rooted tree. No support for closed kinematic loops. | Supports nested models and model composition. Can represent closed kinematic chains via explicit joints. | URDF: Simple chains/trees. SDF: Complex, composite assemblies. |
Physics & Actuator Modeling | Basic joint properties (limits, damping). Lacks native support for detailed actuator dynamics (e.g., PID gains, friction models). | Extensive native support for detailed physics (ODE, Bullet), actuator transmission types, and advanced joint properties. | URDF: Kinematic/Simple dynamics. SDF: High-fidelity physics simulation. |
Sensor Definition | Limited, ROS-centric sensor tags. Often requires simulator-specific plugins for full functionality. | First-class, detailed sensor definitions (e.g., noise models, update rates) for cameras, IMUs, LiDAR, etc., within the format. | URDF: Basic declaration. SDF: Comprehensive sensor simulation. |
File Composition | Single XML file per robot. Can use Xacro (XML Macros) for programmatic generation. | Supports modular, included world and model files. Inherently supports composition and reuse. | URDF: Often requires preprocessing. SDF: Native modularity. |
Plugin System | Relies on ROS-specific <gazebo> extension tags and simulator plugins for advanced features. | Native, generic plugin architecture for customizing model, sensor, and world behavior within the SDF specification. | URDF: Simulator-specific extensions. SDF: Unified plugin interface. |
Standardization & Versioning | Relatively static specification tied to ROS. Less formalized versioning. | Formally versioned specification (e.g., SDF 1.7, 1.8). Actively developed independent of any single simulator. | URDF: De-facto standard. SDF: Versioned, evolving standard. |
Frequently Asked Questions
URDF (Unified Robot Description Format) is the fundamental XML schema used in ROS to define a robot's physical structure. These FAQs address its core purpose, limitations, and relationship to other critical simulation formats.
URDF (Unified Robot Description Format) is an XML file format used within the Robot Operating System (ROS) ecosystem to define a robot's physical structure, kinematics, and visual representation. Its primary purpose is to provide a standardized, machine-readable description of a robot's components, enabling software tools for visualization, simulation, and control to understand the robot's geometry and movement capabilities without hard-coded parameters.
A URDF file describes a robot as a tree of links (rigid bodies) connected by joints (movable connections). For each link, it defines visual geometry (for rendering), collision geometry (for physics simulation), and inertial properties (mass, inertia tensor). For each joint, it specifies the type (e.g., revolute, continuous, prismatic, fixed), the axis of rotation or translation, and kinematic limits. This model allows tools like RViz for 3D visualization and Gazebo for physics simulation to instantiate and interact with the robot programmatically.
Enabling Efficiency, Speed & Accuracy
Intelligent Analysis, Decision & Execution
We build AI systems for teams that need search across company data, workflow automation across tools, or AI features inside products and internal software.
Talk to Us
Search across company data
Give teams answers from docs, tickets, runbooks, and product data with sources and permissions.
Useful when people spend too long searching or get different answers from different systems.

Automate internal workflows
Use AI to route work, draft outputs, trigger actions, and keep approvals and logs in place.
Useful when repetitive work moves across multiple tools and teams.

Add AI to products and internal tools
Build assistants, guided actions, or decision support into the software your team or customers already use.
Useful when AI needs to be part of the product, not a separate tool.
Related Terms
URDF is a foundational component within a broader ecosystem of formats, simulators, and control concepts used to model and operate robotic systems. These related terms define the context in which URDF operates.
Forward & Inverse Kinematics
These are the core computational methods for understanding robot motion, directly informed by the kinematic chain defined in a URDF.
- Forward Kinematics (FK): Calculates the end-effector pose (position and orientation) given a set of joint angles. It answers: "Where is my robot's hand?"
- Inverse Kinematics (IK): Calculates the joint angles required to achieve a desired end-effector pose. It answers: "How do I move my robot's hand here?"
The
<joint>tags in a URDF (defining axis, limits, and type) provide the essential parameters for these calculations, which are performed by libraries like KDL (Kinematics and Dynamics Library) or TRAC-IK.
Actuator & Friction Models
While a basic URDF defines joint types and limits, realistic simulation requires detailed models of the actuation and friction dynamics within those joints.
- Actuator Model: Represents motor dynamics—how a commanded voltage or PWM signal translates to torque, accounting for saturation, back-EMF, and rotor inertia. This is critical for simulating torque control.
- Friction Model: Captures resistive forces like Coulomb (dry) friction, viscous damping, and stiction. These non-linear effects are often defined in the SDF or simulator-specific plugins, not the core URDF. Accurate modeling of these dynamics in simulation is essential for sim-to-real transfer, as real motors and gears are never ideal.
Visual vs. Collision Geometry
A URDF defines two distinct geometries for each link, a critical distinction for simulation and planning.
<visual>Geometry: Defines the appearance of the link for rendering. It can be high-detail and complex (e.g., a textured mesh of the robot's shell).<collision>Geometry: Defines the simplified shape used for physics-based contact and collision detection. It is typically composed of primitive shapes (boxes, cylinders, spheres) or very coarse meshes for computational efficiency. This separation allows a robot to look realistic while maintaining fast and stable physics simulation. Motion planners like MoveIt! use the collision geometry exclusively.

About the author
Prasad Kumkar
CEO & MD, Inference Systems
Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.
His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.
Partnered with leading AI, data, and software stack.
How We Work
Custom AI workflows for your Business
One-fit-all AI don't work for modern businesses. At Inferensys, we aim to understand your business & custom requirements; which we use to define most efficient agentic workflows, the data, and the tools for your business.
01
Review the use case
We understand the task, the users, and where AI can actually help.
Read more02
Pick the right approach
We define what needs search, automation, or product integration.
Read more03
Build the first useful version
We implement the part that proves the value first.
Read more04
Improve from there
We add the checks and visibility needed to keep it useful.
Read moreThe first call is a practical review of your use case and the right next step.
Talk to Us