Taking Your Custom Mobile Robot from CAD to Isaac Sim

16 April 2025 - 12 mins read time
Tags: Simulation ROS2 URDF

TL;DR: Bringing your custom robot into NVIDIA’s Isaac Sim for realistic simulations doesn’t have to be painful. In this post, I’ll walk you step-by-step using MoMo, a modular research robot

Note: This guide assumes you have basic familiarity with Isaac Sim. If you’re new, please first complete the official Isaac Sim getting-started tutorials. NVIDIA also offers excellent courses on robotics fundamentals and Isaac Sim that you might find helpful.


To follow along comfortably, ensure you have:

Why I’m Writing This Post

When I started working alongside Markus Knitt on MoMo, our modular mobile robot at the Institut für Technische Logistik (ITL), TU Hamburg , the goal was to create a versatile robot platform for diverse research experiments. The idea was simple, to allow researchers to quickly swap out top modules for various tasks like navigation, manipulation, or perception experiments.

While we made strong progress on MoMo over the last year, getting it to behave accurately in Isaac Sim was still a challenge.

The Struggle

Have you ever imported your custom robot into Isaac Sim, only to witness it spectacularly fall apart? Here’s MoMo falling apart in one of the early attempts:

MoMo falling apart in Isaac Sim

The problem wasn’t Isaac Sim itself, but rather the lack of consolidated, clear instructions online. While information is available, it’s scattered across forums, tutorials, videos, and documentation, making it hard to know what steps to take and in which order.

After several frustrating weeks spent piecing together scattered information, it became clear that a comprehensive, step-by-step guide didn’t yet exist. This guide is created specifically to save you (and future me) from experiencing those same struggles.

URDF Conversion

To simulate your robot in Isaac Sim, you need a URDF (Unified Robot Description Format) file, a standardized format for robot descriptions.

I’ve been using SolidWorks for years and have become deeply familiar with its capabilities. I’ve worked with various URDF exporters like fusion2urdf for Fusion 360 and sw2urdf for SolidWorks, and I’ve always been confident in SolidWorks as my go-to tool. That said, I was genuinely impressed by Onshape, despite never considering a switch.

Specifically, Onshape’s approach to mating parts using mate connectors made the URDF export straightforward, clear, and less error-prone.

Meet MoMo: The Modular Mobile Robot

For this guide, I’ll use MoMo as a concrete example. MoMo is open-source, modular, and features mecanum wheels ideal for omnidirectional movement. Here’s what MoMo looks like in Onshape:

MoMo CAD model in Onshape

MoMo CAD model in Onshape

You can explore MoMo’s full documentation and GitHub repository to learn more or replicate this setup yourself. It serves as an ideal example for demonstrating a realistic and practical workflow from CAD to Isaac Sim.

Step-by-Step: From CAD to URDF to Isaac Sim

We’re preparing the robot model specifically for the onshape-to-robot tool. This tool converts an Onshape CAD assembly into a URDF that simulation tools like Isaac Sim can understand.

Here’s how to smoothly take your robot from CAD to Isaac Sim simulation:

1. Preparing Your Robot in Onshape

If you’re unfamiliar with Onshape assemblies, I recommend watching this YouTube playlist.

Already assembled your robot in another CAD tool? No worries. You can import your assembled model directly into Onshape. Just zip your assembly files and import them. Onshape will load the robot as it is, but keep in mind: mates and joints won’t be preserved during the import.

To avoid reassembling everything from scratch:

To make this work correctly, the tool expects a certain naming convention and structure in the Onshape model. Checkout the design time considerations for more details. The creator of onshape-to-robot provides clear instructions in this video. Although slightly outdated, it still offers valuable insights.

Follow these naming conventions for URDF compatibility:

Using this naming pattern ensures that the exporter recognizes and handles each part correctly when generating your URDF. If you assign materials to parts in your Onshape model, the onshape-to-robot tool will automatically include those material properties in the generated URDF.

After assigning your links, frames, and joints in Onshape, your model should look something like this:

Onshape model with clearly defined links, frames, and joints

MoMo Onshape model after defining links, frames, and joints.

To easily follow along, you can directly access MoMo’s fully set-up Onshape model here:👉 MoMo Robot Onshape Model

2. Generating and Verifying Your URDF

Use onshape-to-robot to generate your URDF. After exporting your URDF, always verify it quickly using the Online URDF Viewer. You can drag and drop your generated folder into the viewer to visualize the URDF.

Config file to generate URDF 

# This config.json file is used to generate the URDF from Onshape
# Replace the URL with your own Onshape document URL

{
    "url": "https://cad.onshape.com/documents/0f7ba08d49760d832652e76c/w/f802382a554ac4e5d967eb06/e/176c79e9883e5c00c7190ba1",
    "output_format": "urdf",
}

# In case you want to use scad manual approximation (as explained in the video), it will be as follows:

{
    "url": "https://cad.onshape.com/documents/0f7ba08d49760d832652e76c/w/f802382a554ac4e5d967eb06/e/176c79e9883e5c00c7190ba1",
    "output_format": "urdf",
    "use_scads": true,
    "post_import_commands": [
        "cp momo_urdf/scad/*.scad momo_urdf/assets/"
    ]
}

 

Ensure:

Here’s how your verified URDF should look, with joint sliders working correctly:

URDF verification showing working joint sliders

URDF verification showing functional joint sliders

Also, you can define the collision meshes in your URDF. This is important for accurate physics simulation in Isaac Sim. The online URDF viewer allows you to visualize the collision meshes.

Here’s how the collision meshes should appear in the URDF verification. Here, the collision meshes are simplified using OpenSCAD manual approximation so that the simulation runs smoothly without complexity:

URDF verification showing collision meshes

URDF verification showing collision meshes clearly

3. Importing the Robot into Isaac Sim

This tutorial targets Isaac Sim version 4.5 and is intended for wheeled mobile robots. The steps may slightly vary for other types of robots.

Steps to import:

Here’s the Isaac Sim import dialog box with all correct options selected:

Isaac Sim import dialog with correct options

Isaac Sim import dialog with correct options selected

After importing, a folder structure with .usd files appears:

If the Collision From Visuals box is checked, collisions will be defined based on the meshes. The robot_base.usd in Isaac Sim appears as follows (collisions are enabled for visualization): robot_base.usd in Isaac Sim

robot_base.usd in Isaac Sim

Adjust the articulation root from base_link to the main robot prim (/world/robot_name). Check Isaac Sim documentation for more details about the articulation root.

✅ Verifying Wheel Actuation

Before proceeding further, it’s a good idea to test if your joints and articulation are working correctly.

  1. Open robot.usd in Isaac Sim and create a ground plane so that the robot doesn’t fall through the floor.
  2. In the Stage panel, select any of the actuated revolute joints (e.g., one of the wheels).
  3. Set a Target Angular Velocity.
  4. Start the simulation.

If the wheel rotates as expected, everything is working perfectly.

Repeat this for all the wheels to make sure joint configurations are correct and that your robot is able to move.

Customizing Appearance, Physics, and Sensors

Realistic MoMo model in Isaac Sim after applying appearance, physics, and sensors

MoMo model in Isaac Sim

4. Connecting to ROS 2 Using Omnigraph in Isaac Sim

Omnigraph, Isaac Sim’s visual scripting tool, makes integration with ROS2 straightforward. For mecanum-wheeled mobile robots like MoMo, you’ll typically need:

Omnigraph shortcuts

To enable communication between your simulated robot and ROS 2, Isaac Sim provides a set of Omnigraph nodes under the Robotics menu. These nodes make it easy to hook up sensors, time, and transformations with your ROS 2 system. Here’s a high-level overview of what you’ll need:

RTX LiDAR
Go to Tools → Robotics → ROS2 Omnigraphs → RTX LiDAR and select the LiDAR prim. Make sure the LiDAR prim (Create → Sensors → RTX LiDAR → Rotating) already exists in your scene. You can configure topic names, frame IDs, and other parameters directly in the Omnigraph node.

ROS Clock
Add a clock node via Tools → Robotics → ROS2 Omnigraphs → Clock to sync simulation time with ROS 2.

ROS TF Publisher
To publish the robot’s TF tree, use Tools → Robotics → ROS2 Omnigraphs → TF Publisher. Select your robot’s articulation root (e.g., /World/momo) as the target prim. This will include all joints in the TF tree.

To include sensors like LiDAR or cameras in the TF tree:

  • Open the ROS TF Omnigraph.
  • Duplicate the ROS2PublishTransformTree node.
  • Set parentPrim to something like /World/momo/base_link.
  • Set targetPrim to the sensor path, e.g., /World/momo/base_link/velodyne.
  • You can add more sensors by clicking +Add Target and selecting the sensor prims.

Holonomic Control Setup
In the Holonomic control Omnigraph (check out the o3dyn robot model for reference), select the USD Setup Holonomic Robot node. In the properties panel, set:

  • comPrimPath to /World/momo/base_link
  • robotPrimPath to /World/momo (the prim with the articulation root)
Then, select the Articulation Controller node and set the targetPrim to /World/momo in the property panel.

 

Important Note on Holonomic Controllers:

To make the Holonomic Controller work properly, you must explicitly define the angles of your wheels relative to the robot frame. I found a helpful forum post that clearly explains how to set this up correctly:

→ Setting wheel angles for holonomic robots

TL;DR

Click on the actuated wheel joints in the Stage, then go to Add → Attribute

  • For wheel angles:
    • Name: isaacmecanumwheel:angle
    • Type: Float
  • For wheel radius:
    • Name: isaacmecanumwheel:radius
    • Type: Float

Set the wheel radius and the angles in the joint properties .The wheel radius for MoMo is 0.1015 m and the wheel angles are:

  • Front Left: -135 degrees
  • Front Right: -45 degrees
  • Back Left: -45 degrees
  • Back Right: -135 degrees

 

Ensure you follow these steps precisely, as incorrect wheel angle definitions can prevent the robot from moving as intended in simulation.

5. Testing Your Robot in Realistic Environments

Here’s MoMo simulated in a realistic warehouse environment within Isaac Sim, highlighting its potential for logistics or warehouse-based robotics research:

MoMo robot in Isaac Sim warehouse environment

MoMo in a realistic warehouse simulation environment

6. Final Check in RViz

Confirm your setup visually in RViz. Your data visualization should appear organized and correct, like this:

Data visualization in RViz

Data visualization in RViz

7. See your robot in action!

Finally, here’s MoMo moving smoothly and realistically within Isaac Sim, demonstrating a successful integration.
The velocity commands are sent from ROS 2 via the /cmd_vel topic.

MoMo moving in Isaac Sim simulation.

Congratulations! You’ve successfully brought your mobile robot from CAD into Isaac Sim for simulation.

Final Thoughts

I created this detailed yet conversational guide because I wished something like this had existed when I started working on MoMo simulation. Hopefully, this guide simplifies your robotics journey, saving you from weeks of frustration.

Have questions, comments, or experiences you’d like to share? I’d love to hear from you!

Additional Resources

If you are also working with mecanum-wheeled robots, I highly recommend checking out the o3dyn robot model available in Isaac Sim. It’s a great reference for omnidirectional mobile robot simulation.There’s an excellent ROSCon Talk that dives deep into:

They also published a paper that explores how various simulation parameters affect sim2real outcomes.

For additional context, this YouTube tutorial also does a great job explaining how to simulate wheeled mobile robots in Isaac Sim.

Happy simulating!