Unified Robot Description Format

URDF is how a robot describes itself

A URDF file is XML that lists a robot's rigid bodies, the joints connecting them, the mass and inertia of each part, and the meshes that give it shape. ROS, Gazebo, MuJoCo and Isaac all read it. Open one below and see what is inside.

Open a URDF file How the format works

Sample 6-axis arm

What you can do with a robot description here

Viewer

Open URDF, MJCF, SDF or Xacro in the browser. Toggle collision geometry, joint axes, centre of mass and inertia. Drag any joint through its range.
URDF editor

Build a robot link by link, or open a URDF and change it — in a form or as text, with the 3D view and the check following every edit. The inertia is computed from the shapes and meshes, and the result exports to URDF, MJCF, SDF or USD.
Motion

Build a movement: pose the robot onto a timeline, bake a gait from the structure of whatever model is open, or retarget motion capture from BVH or AMASS. Then check it against the file it came from — the torque each joint is asked for versus the effort declared for it, joints resting on their limits, feet sliding, and whether the robot is still upright at the end.
Physics lab

Run the robot instead of looking at it. Gravity, contact and motors in the browser, a controller you write yourself, and four tests that answer with a number: does it stand, what shove does it take, what slope, what load. It is MuJoCo, with nothing to install.
Converter

Move a model between URDF, MJCF, SDF, USD and Xacro. Every direction states what it could not carry across — on the page, and again inside the file you download.
ros2_control

The block, the controllers.yaml and the launch file, generated from your description rather than retyped from it — joints, interfaces and limits read out of the file you already have.
Robot models

A hundred robots in URDF and MJCF — quadrupeds, humanoids, arms, hands — opened in a tab instead of a clone. Download one as a folder that works: description, meshes, licence. Each keeps its own licence and links back to where it came from.
From CAD

Coming out of SolidWorks, Onshape or Fusion? The exporter is somebody else's; what is here is what those exports get wrong — the wrong unit, mesh paths that only work on one machine, inertia copied between links — and the check that says which of them happened to yours.
Validator

Every model opened in the viewer is checked as it loads: inertias that disagree with the geometry, impossible masses, links with no collision shape, meshes too dense to simulate.

What is inside a URDF file

Two elements carry the structure. A <link> is a rigid body: it holds mass, an inertia tensor, visual geometry for display and collision geometry for physics. A <joint> connects a parent link to a child link and states how they may move relative to each other. Links and joints together form a tree with one root, and that tree is the whole robot.

Because links reference mesh files rather than embedding them, a URDF is rarely a single file. It is a description plus a folder of STL, DAE or glTF geometry, and a model that loads on one machine may fail on another simply because those paths resolve differently.

A URDF file, line by line

A complete, valid URDF: a base and an arm, joined by one motor. It passes ROS's own parser and the checks on this site, and it is short enough to read in one go.

two-link-arm.urdf Open it in the viewer

<?xml version="1.0"?>
<robot name="two_link_arm">

  <!-- A link: its mass, its inertia, a shape to draw and one to collide. -->
  <link name="base">
    <inertial>
      <mass value="2.0"/>
      <inertia ixx="0.00412" iyy="0.00412" izz="0.0049" ixy="0" ixz="0" iyz="0"/>
    </inertial>
    <visual>
      <geometry><cylinder radius="0.07" length="0.10"/></geometry>
    </visual>
    <collision>
      <geometry><cylinder radius="0.07" length="0.10"/></geometry>
    </collision>
  </link>

  <link name="arm">
    <inertial>
      <origin xyz="0.15 0 0"/>
      <mass value="0.8"/>
      <inertia ixx="0.000213" iyy="0.00611" izz="0.00611" ixy="0" ixz="0" iyz="0"/>
    </inertial>
    <visual>
      <origin xyz="0.15 0 0"/>
      <geometry><box size="0.30 0.04 0.04"/></geometry>
    </visual>
    <collision>
      <origin xyz="0.15 0 0"/>
      <geometry><box size="0.30 0.04 0.04"/></geometry>
    </collision>
  </link>

  <!-- A joint: where the child sits on the parent, and how it moves. -->
  <joint name="shoulder" type="revolute">
    <parent link="base"/>
    <child link="arm"/>
    <origin xyz="0 0 0.05" rpy="0 0 0"/>
    <axis xyz="0 0 1"/>
    <limit lower="-1.57" upper="1.57" effort="12" velocity="2.0"/>
    <dynamics damping="0.1"/>
  </joint>

</robot>

<inertial> — mass in kilograms and the inertia tensor in kg·m², taken about the centre of mass. The <origin> inside it is where that centre sits in the link's frame: the arm's is 15 cm out, in the middle of its box.
<visual> and <collision> — what is drawn and what is simulated. Here they are the same primitive; on a real robot the visual is usually a detailed mesh and the collision a much simpler shape.
<origin> on the joint — where the joint sits in the parent's frame: xyz in metres, rpy in radians, as rotations about the fixed X, Y and Z axes in that order. The child link's frame is the joint's frame, so everything inside arm is measured from the shoulder.
<axis> — the direction the joint turns about, in the joint's own frame. Leave it out and it is X, which is a common reason an imported joint swings the wrong way.
<limit> — the range in radians (metres for a sliding joint), the most torque the motor may apply in N·m, and its top speed in rad/s. <dynamics> adds damping, which a simulator otherwise takes as zero.

URDF joint types

There are six, and the type decides what the rest of the joint must say. The column that matters most is the middle one: ROS's parser refuses the entire file when a joint that needs a limit does not have one, not just the joint.

Type	Moves	`<limit>`	In practice
revolute	Turns about the axis, between a lower and an upper angle	Required	The ordinary motor joint: arms, legs, grippers
continuous	Turns about the axis without end	Optional	Wheels, spindles, anything that spins
prismatic	Slides along the axis, between two positions	Required	Linear actuators, lifts, parallel fingers
fixed	Not at all	—	Sensors and brackets; Gazebo and MuJoCo merge them into the parent
floating	Freely, in all six directions	—	In the specification; ROS's own KDL parser treats it as fixed
planar	Within the plane normal to the axis	—	In the specification; rarely honoured by anything downstream

Two details catch people out. A <limit> must state effort and velocity even on a continuous joint, or the file is rejected. And a revolute joint whose limit gives effort and velocity but no lower and upper is accepted — with both at zero, as a joint that cannot move. The viewer reports each of these by name rather than letting a simulator discover them.

URDF, MJCF, SDF and USD

URDF is the oldest and most widely supported, and it is a tree: every link has exactly one parent, so closed kinematic chains cannot be expressed directly. MJCF is MuJoCo's format and covers what URDF cannot — loops, tendons, contact parameters — which is why reinforcement learning work tends to live there. SDF is Gazebo's, and describes whole worlds rather than one robot. USD comes from graphics and is what NVIDIA's Isaac stack builds on.

Conversion between them is rarely lossless. A capsule in MJCF has no URDF equivalent and becomes a cylinder; contact parameters have nowhere to go at all. Anything that claims a clean round trip is hiding something, so this converter lists every loss.

Common questions

What is URDF, and what does it stand for?

Unified Robot Description Format: an XML format, born in ROS, that describes a robot as rigid links connected by joints, with the shape, mass and limits of each. It is read far beyond ROS now — Gazebo, MuJoCo, Isaac Sim, Drake and PyBullet all import it.

What units does a URDF use?

Metres, radians, kilograms, and kilogram-square-metres for inertia. Nothing in the file says so — there is no unit attribute anywhere — which is why a CAD export in millimetres opens without complaint as a robot a thousand times too big. The viewer states the size of every model it opens, in metres, for exactly that reason.

How do I open a URDF file?

Drop it into the viewer. If the model references meshes, add the whole folder or a ZIP archive so those paths resolve. Nothing is installed and the file is parsed for display, not published.

What is the difference between URDF and Xacro?

Xacro is URDF with macros, properties and simple arithmetic, so repeated structure — four identical legs, six similar joints — is written once. It expands into plain URDF before anything else reads it.

Can MuJoCo load a URDF directly?

It can, but it ignores everything URDF has no place for, and its defaults for contact and damping rarely match what you want. Converting to MJCF first makes those choices explicit instead of implicit.

How do I get a URDF into Isaac Sim?

Isaac Sim has an importer of its own; without Isaac installed, convert it to USD here. Isaac opens a stage, not a description, and the conversion writes the physics schemas it looks for — rigid bodies, collision APIs, joints with limits — along with the full inertia tensor rather than just its diagonal. OpenUSD for robots goes through what the stage holds.