Simulating your robot before it touches the real world is rapidly becoming an indispensable part of the development process. Testing in simulation means faster iteration, cheaper failure, and the ability to generate the kind of edge-case scenario-specific data that's nearly impossible to capture in the physical world. It means perception models train on synthetic sensor data before a single real LiDAR sweep is collected. It means controllers can get thousands of hours of validation that is simply not feasible with hardware time.

But none of that makes a difference if getting your robot into a simulator presents a significant barrier. Can engineers bring their robots into digital twin simulation with the tools they are already using?

With Falcon, the answer is quite simple: for anyone working with a robot and ROS2, that robot likely already has a Unified Robot Description Format (URDF) file. And if it has a URDF, getting it into Falcon as a fully articulated, controllable digital twin is remarkably straightforward.

The big picture

URDF is the standard format for defining a robot's structure, kinematics, and geometry in ROS workflows (learn more about URDF here). The Falcon URDF import pipeline takes that description and converts it (via Blender) into a skeletal mesh that preserves the full joint hierarchy. From there, an Animation Blueprint exposes each joint as a controllable variable, giving you a simulation-ready twin with complete articulation.

This workflow has been validated on arms like the Universal Robots UR5 and ABB IRB6640, and applies equally to any URDF-defined robot — manipulators, bipeds, quadrupeds, wheeled platforms, or custom designs.

Start where you already are

As we already said, chances are, your robot is already defined in URDF (or using an Xacro file that easily converts to standard URDF). Regardless of what kind of robot you are working with, the steps of the process are generally the same:

1. Install the Blender URDF Importer Plugin
2. Import your URDF defined robot into Blender
3. Export the skeletal mesh and textures as an FBX file. Filmbox, or FBX, is a 3D asset interchange format originally developed by Autodesk. It's become a standard way to move 3D models between different software as it makes it easy to carry over properties like geometry, bone/joint hierarchies, animations, and sometimes even materials.
4. Import the FBX file into Falcon (and confirm that the robot representation shows up correctly)

Create a sim-ready digital twin

Once promoted in Falcon, the robot's joints are exposed as public variables that can be driven interactively or via Python script. Using Falcon’s python system you can teleoperate the arm in forward kinematics mode — direct joint control — or switch to inverse kinematics and drive toward a target end-effector pose. Either way, the twin updates in real time inside Falcon's simulation environment.

1. Create the animation blueprints to control behaviors and govern the motions and articulations of the robots joints
   
   1. Optional: add further attachments or end effectors (ex: a robot arm gripper)
2. Set up kinematic controls in Python and verify control functions and robot behaviors
3. Bring the robot into any operational scenario — ex: load a robotic arm twin into a factory pick-and-place scenario
4. Attach relevant sensors from Falcon’s sensor library
5. Connect to any software stack over ROS2 and deploy robot for any relevant task

Once these steps are complete, the same robot you defined in URDF can now be placed in any Falcon environment, paired with virtual sensors, and used for perception training, planning validation, or task-level simulation — without rebuilding anything from scratch.

• For deeper detailing of the process, check out our docs on FalconCloud.
• And to see free-to-use sim-ready robots available to all Falcon users, browse our digital twin catalog.
• Questions for our team? Reach out here or at solutions@duality.ai

‍