Online URDF editor
Build a robot description link by link, or open one and change it. The 3D view, the URDF
text and a model check follow every edit — and the numbers people get wrong by hand, the
inertia above all, are worked out for you. Nothing to install.
Build it link by link
Every robot here starts from one link, the root. + Link hangs a new one
from the selected link on a revolute joint, placed where the parent ends — so the first
thing you add already moves, and a chain of them bends. From there the form on the right
holds everything URDF can say about that link and its joint: the joint's type, its parent,
where it sits, the axis it turns about, its range, effort and speed; the link's mass and
the shapes it is made of.
Or write it. The URDF pane under the scene is the same robot as text, and it goes both
ways: type into it and the scene and the form follow once the text reads, with the line
number of anything that does not. Click a part in the scene to select it; drag the
joint gizmo to place a link by eye and let the numbers follow.
The inertia is computed, not guessed
A hand-written URDF usually carries an inertia tensor copied from a tutorial and never
recomputed — and a simulator given a tensor that disagrees with the part either refuses the
model or shakes it apart. Here you give each link its mass, and the editor spreads it evenly
through the link's shapes — the collision shapes if there are any, otherwise the visual ones —
and writes the tensor about the centre of mass:
Moments of inertia used for each primitive, mass m
| Shape | About its own x and y | About its own z |
|---|
| Box, sides a × b × c | m(b²+c²)/12, m(a²+c²)/12 | m(a²+b²)/12 |
|---|
| Cylinder, radius r, length h | m(3r²+h²)/12 | mr²/2 |
|---|
| Sphere, radius r | 2mr²/5 | 2mr²/5 |
|---|
| Mesh | integrated from its triangles; an open surface is treated as its bounding box, and says so |
|---|
A link made of several shapes combines them with the parallel axis theorem, and a shape
turned on its side has its tensor turned with it. The density this implies is shown next
to the result — a link that works out lighter than foam is usually a mesh exported in
millimetres. If CAD measured the real part, switch the link to Typed in
and enter its numbers instead.
Where a link goes is where its joint is
URDF has no position for a link. The joint's origin, written in the parent link's frame,
is the child link's frame, and every shape of the child is placed relative to it.
That is why a cylinder added to a new link is set half its length above the joint: the
joint stays at the end where it turns, and the part extends from it. Move the joint and the
whole link follows; move a shape and only that shape does.
Turn on link frames and joint axes under the eye button
when something turns the wrong way. An axis is read in the joint's own frame, after the
joint's rotation — so a joint rotated a quarter turn about x and turning about z actually
turns about the parent's y.
What a URDF reader refuses
These were checked against urdfdom, the parser ROS itself uses, and the editor writes
around every one of them:
- A revolute or prismatic joint with no
<limit> — urdfdom refuses the whole file, not just the joint.
- A
<limit> without effort or without velocity — refused even on a continuous joint, where the limit itself is optional.
- Angles in degrees. Every angle in a URDF is radians; the fields here take degrees and the file gets radians.
- A mesh in millimetres. CAD exports millimetres and URDF reads metres, so the part arrives a thousand times too big; the mesh card offers the 0.001 scale when a mesh is larger than a person.
Whatever else the check finds — a moving link with no mass, a locked joint, a tensor no rigid
body can have — is listed under Check, and clicking a finding selects the
part it is about.
Meshes from CAD or Blender
Drop STL, OBJ, DAE or GLB files on the scene and they become shapes of the selected link.
They stay in your browser — kept between visits — and travel with the download, which
becomes a ZIP with a meshes/ folder beside the URDF so the paths in it resolve.
For whole assemblies there are exporters that write the URDF for you:
from Blender,
from FreeCAD, and
SolidWorks, Onshape and Fusion; this is where their output gets fixed.
When it is done
Export saves the URDF — as a ZIP when it has meshes — or converts it: MJCF
for MuJoCo, SDF for Gazebo, USD for Isaac Sim, and the
ros2_control configuration for the controllers, and an
SRDF for MoveIt with its collision matrix measured in the page. The tool switch at
the top left takes the same robot into the viewer, the
motion editor or the physics lab, where it can
stand up, fall over and be driven. And the robot stays here, as you left it, the next time
you open the page.
Common questions
How do I make a URDF file from scratch?
Start from New → One link, then add links with + Link.
Each new link arrives hanging from the selected one by a revolute joint placed where the
parent ends, so a chain of them already bends. Give each its shapes, its joint an axis and a
range, and download the file. What comes out is plain URDF that ROS, Gazebo, MuJoCo's
importer and Isaac Sim's all read.
Can I edit a URDF I already have?
Yes — open it, with its mesh folder if it has one, or paste it into the URDF pane. A URDF
is read in the browser. Xacro, SDF and MJCF are converted to URDF on the way in, so what you
edit is the expanded robot: a Xacro's macros and properties do not survive. Elements the
editor does not model — <gazebo>, <transmission>,
<ros2_control> — are written back exactly as they were, comments and all.
How is the inertia calculated?
The link's mass is spread evenly through its shapes — the collision shapes if it has
any, the visual ones otherwise. Boxes, cylinders and spheres use the textbook formulas; a
mesh is integrated from its triangles. The parts are combined about their common centre of
mass with the parallel axis theorem. If you know better — CAD measured the real part — switch
the link to Typed in and enter your own numbers.
Why does every revolute joint get a limit?
Because urdfdom, the parser ROS uses, refuses the whole file if a revolute or prismatic
joint has no <limit>, and refuses a <limit> that lacks
effort or velocity — even on a continuous joint, where the limit
is optional. The editor always writes all of them, so nothing it saves is refused for that.
Where does a child link go?
Where its joint is. URDF has no separate position for a link: the joint's origin, given
in the parent's frame, is the child's frame, and every shape of the child is placed
relative to it. Move the joint and the whole link moves with it; move a shape and only the
shape does. Turn on link frames under the eye button to see them.
Degrees or radians?
Degrees in the fields, radians in the file, as URDF requires. Fields also take a little
arithmetic — 0.3/2, 90-15, pi/4 — and the arrow keys
step a value, ten times as far with Shift.
Is my robot uploaded anywhere?
Building it, the 3D view and the download all happen in your browser, and it is kept
there — the robot in local storage, its meshes in IndexedDB — so it is still here tomorrow.
The check sends the URDF text to our server, which reads it and keeps nothing. Converting to
another format or opening the robot in the viewer or the lab sends the files, which are kept
for a day so the link works.
Will the file work in ROS 2, Gazebo, MuJoCo or Isaac Sim?
ROS 2 reads URDF directly — robot_state_publisher takes it as it is — and
Gazebo converts URDF to SDF itself when it loads one. For the others, Export
gives MJCF for MuJoCo, USD for Isaac Sim, SDF, a ros2_control
configuration, and the SRDF MoveIt plans with, its collision
matrix measured over ten thousand poses.