DEV Community: Arouna Mounchili

Treating Robots as Code: Why We Built a Programmable IR for ROS 2

Arouna Mounchili — Mon, 01 Jun 2026 05:20:01 +0000

How LinkForge v1.4.0 moves beyond static XML (URDF/SRDF) to bring modern software engineering ergonomics to robotics simulation.

If you work in robotics, you know the pain of the XML monolith.

For years, we’ve treated URDF and SRDF files like static, hand-written documents. We copy-paste coordinates, manually estimate inertia tensors, and attempt to fix broken collision models only after our simulator crashes.

A while ago, I wrote about how we stopped hand-coding URDFs by bridging Blender and ROS 2. That was a massive step forward for visual design. But as robots become increasingly modular, and as Embodied AI demands headless, parallel training loops, visual design is no longer enough.

Robotics needs modern software engineering ergonomics.

Today, we are releasing LinkForge v1.4.0, an architectural shift that treats robot descriptions not as static XML files, but as a programmable, physically-validated Intermediate Representation (IR).

Here is why we built it, and how it changes the workflow.

The Problem with "Robots as XML"

URDFs and SRDFs are essentially compiled executables for simulators. They were never meant to be source code.

When you attach a robotic arm to a mobile base by hand, you are manually merging two complex, highly sensitive state machines. You have to:

Resolve joint name collisions.
Manually shift geometric origins.
Merge MoveIt 2 planning groups.
Pray you didn't accidentally type a mass of 0.0, which will silently crash Gazebo on launch.

This workflow is brittle, error-prone, and entirely disconnected from modern CI/CD practices.

The Paradigm Shift: Validated Composition

With LinkForge v1.4.0, we introduced a fluent Python API that acts as an Intermediate Representation (IR). You define your parameters once, compose modules programmatically, and compile headlessly to URDF, SRDF, or your chosen simulation target.

Look at the difference between guessing your physics in XML, versus strictly validating them in Python:

Instead of manually editing SRDF files for motion planning, LinkForge provides a robust API to compose subsystems:

from linkforge.core import RobotBuilder

base = RobotBuilder("mobile_base")
# ... load base parameters ...

arm = RobotBuilder("manipulator")
# ... load arm parameters ...

# Safely attach the arm to the base
base.attach(arm, at_link="top_plate", prefix="left_arm_")

Under the hood, the builder automatically re-namespaces conflicting joint names, shifts the topological tree, and seamlessly merges your MoveIt 2 semantic planning groups.

Mathematical Rigor: The Physics "Linter"

In standard workflows, you don't know your robot's physics are broken until the simulator rejects them. LinkForge introduces a RobotValidator that acts as a strict linter for rigid-body physics.

1. No More Guessing Inertia
Stop guessing your ixx, iyy, and izz values. LinkForge integrates Sylvester & Mirtich algorithms to calculate rigorous inertia tensors directly from your mesh geometry and mass.

2. Early Validation
The linter verifies kinematic trees for disconnected nodes, unintended loops, and non-physical inertia tensors. If a sub-assembly has a zero-mass link, the validator catches it and fails the build before you ever launch a simulation.

Headless Decoupling for Embodied AI

Perhaps the most important architectural change in v1.4.0 is the complete decoupling of linkforge-core.

We have fully separated the rigid-body core logic from the visual platforms (like Blender). This means you can now run the IR engine entirely headlessly on high-performance clusters.

If you are working in Reinforcement Learning or Embodied AI, you can programmatically generate, mutate, and validate thousands of robot morphologies (changing joint limits, mass, or geometries) inside parallel training loops with zero external UI dependencies.

Stop Editing XML. Start Compiling Robots.

Robotics is advancing too fast to be held back by fragile description files. By treating your robot as code, you unlock version control, continuous integration, and programmatic scale.

LinkForge is fully open-source and ready for your workflows.

🔗 Check out the repository on GitHub:
https://github.com/arounamounchili/linkforge

📦 Download on PyPI:
https://pypi.org/project/linkforge-core/

Or try it out immediately:

pip install linkforge-core

I would love to hear your thoughts on this architecture! How are you currently managing your URDF/SRDF pipelines, and what pain points do you face when migrating from CAD to Simulation? Let's chat in the comments!

Stop Hand-Coding URDFs: How We Bridged Blender and ROS 2 Seamlessly

Arouna Mounchili — Sat, 28 Feb 2026 19:31:58 +0000

If you work in robotics, you know the drill.

You spend weeks designing a beautiful, mechanically sound robot in CAD. Then, you need to simulate it in Gazebo or control it with ROS 2.

Suddenly, your engineering masterpiece becomes a nightmare of XML tags. You are staring at a robot.urdf file at 2 AM, trying to figure out why your inertia tensor has negative diagonal values, why your LiDAR is floating three meters above the chassis, or why your generic <ros2_control> hardware interface is throwing errors.

We’ve all been there. The gap between Visual Rigging and Mathematical Kinematics is the most frustrating bottleneck in robotics simulation.

That’s why I built LinkForge: The Linter & Bridge for Robotics.

What is LinkForge?

LinkForge is an open-source ecosystem designed to turn Blender 4.2+ into a production-grade robotics IDE.

It allows you to model your robot as naturally as sculpting a 3D scene, while acting as a strict safety net to guarantee the output is rigorous, mathematically sound code ready for ROS 2 and Gazebo.

Instead of writing XML, you use a native Blender interface to:

Define Physics: Automatically calculate perfect mass properties and inertia tensors for complex arbitrary meshes.
Attach Sensors: Visually place Cameras, LiDARs, IMUs, and Contact sensors.
Configure Control: Set up ros2_control Command and State interfaces (Position, Velocity, Effort) directly on your joints.
Lint & Export: Catch simulation-breaking errors before you export your final URDF/XACRO.

Why not just use existing exporters?

There are a few historical URDF exporters for Blender and SolidWorks. However, as ROS 2 has matured, the requirements for simulation have become stricter.

LinkForge was built completely from scratch with a Hexagonal Architecture to solve three major problems with older tools:

1. The "Garbage In, Garbage Out" Problem

Older exporters blindly translate whatever is in your 3D viewport into XML. If you accidentally detach a link, or if your collision mesh causes a physics engine singularity, you won't find out until Gazebo crashes.

LinkForge introduces The Linter for Robotics. Before it lets you export, the core Python engine validates your kinematic graph. It catches negative inertias, circular dependency chains, and invalid joint limits instantly.

2. Native `ros2_control` Generation

Writing <ros2_control> blocks by hand is tedious. LinkForge includes a dedicated control dashboard. You simply check the joints you want to actuate, choose your interfaces, and LinkForge generates the perfect, standard-compliant XACRO macros for your hardware interfaces.

3. Headless CI/CD Capabilities

Because LinkForge uses a Hexagonal Architecture, the core engine (linkforge-core) is completely decoupled from the Blender UI.

While artists and engineers use the Blender add-on visually, you can also install the core engine locally on your Linux CI/CD servers. You can run automated tests to validate the physics of your robot models every time someone opens a Pull Request on your repository! (And yes, an official standalone PyPI package is on our near-term roadmap!)

Fully Open Source (And Seeking Contributors!)

LinkForge is built by roboticists, for roboticists. We are licensed under GPLv3 to ensure the tool remains forever free and community-driven.

Whether you are building a simple differential drive robot for a university project, or a complex quadruped for research, LinkForge will save you hours of XML debugging.

Try it out today:

Check out the GitHub Repository. If you find it useful, I’d be honored if you left a Star ⭐!
Read the Official Documentation & Tutorials.
Download it directly inside Blender via the Get Extensions menu!

If you are a Python or Rust developer interested in kinematics, or if you just have ideas on how to improve the URDF workflow, we are actively looking for contributors to help shape our upcoming roadmap (which includes SRDF Support!). Come say hi in our GitHub Discussions!

Let's stop hand-coding XML, and get back to building robots. 🤖✨