The Linter & Bridge for Robotics

LinkForge is The Linter & Bridge for Robotics, integrating directly into Blender.

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, simulation-ready code.

1. Forge Structure: Define links, joints, masses, and inertias visually.
2. Lint & Validate: Catch structural and physics errors before simulation export.
3. Perceive & Control: Attach sensors and configure ros2_control interfaces.
4. Export Production Code: Generate hardened URDF/XACRO files.

• Bidirectional Workflow: Import existing URDF or XACRO files for editing or build complex robot models from scratch using Blender native tools.
• Production-Ready Export: Generates strictly compliant URDF and XACRO files optimized for ROS, ROS 2, and Gazebo. Includes ROS-Agnostic Asset Resolution for cross-platform editing and Core API support for SRDF (Semantic Robot Description) generation.
• Linter for Robotics: Built-in integrity checker inspects robot topology, physics data, and joint limits. It catches simulation-breaking errors (negative inertias, detached links, circular chains) before you export.
• ROS2 Control Support: Automatically generates hardware interface configurations for ros2_control via a centralized dashboard, compatible with Gazebo and physical hardware.
• Complete Sensor Suite: Integrated support for Camera, Depth Camera, LiDAR, IMU, GPS, Force/Torque, and Contact sensors with configurable noise models.
• Automatic Physics: Scientifically accurate calculation of mass properties and inertia tensors for both primitive shapes and complex arbitrary meshes.
• Advanced XACRO Support: Intelligent extraction of repeated geometry into macros and shared materials, producing maintainable and modular code.
• Round-Trip Fidelity: The Import → Edit → Export cycle preserves all data with absolute precision, including sensor origins, transmission interfaces, and custom user properties.
• Modular Robot Assembly: High-level Composer API (Core library) for assembling robots from modular sub-components, enabling rapid prototyping and SRDF generation for complex multi-part systems.

Requirements: Blender 4.2 or later

1. Open Blender → Edit > Preferences > Get Extensions
2. Search for "LinkForge"
3. Click Install

1. Download the .zip package for your platform (e.g., linkforge-x.x.x-windows-x64.zip) from Latest Releases
2. Open Blender → Edit > Preferences > Get Extensions
3. Click dropdown (⌄) → Install from Disk
4. Select the downloaded .zip file

1. Create Links

   • Select a mesh → Forge panel → Create Link
   • Configure mass, inertia, and collision geometry in the Physics section.
   • Repeat for all robot parts.

2. Connect with Joints

   • Select child link → Forge panel → Create Joint
   • Choose joint type (Revolute, Prismatic, Continuous, Fixed, etc.)
   • Set limits, axis, and dynamics in the Joint section.

3. Add Sensors (Optional)

   • Select a link → Perceive panel → Add Sensor
   • Configure sensor properties in the Sensor section.

4. Configure Control (Optional)

   • Go to the Control panel → Enable Use ROS2 Control
   • Click + to add joints to the Joint Interfaces list.
   • Configure Command/State interfaces (Position, Velocity, Effort).

5. Validate & Export

   • Go to the Validate & Export panel.
   • Click Validate Robot to check for integrity errors.
   • Choose format (URDF/XACRO) and click Export.

1. Open the LinkForge sidebar tab (N-panel in 3D Viewport).
2. In the Forge panel, click Import URDF/XACRO.
3. Select your file and edit the robot structure normally.
4. Export back via the Validate & Export panel.

Complete examples in examples/ directory:

• roundtrip_test_robot.urdf: A comprehensive robot containing ALL 6 URDF joint types (fixed, revolute, continuous, prismatic, planar, floating), plus sensors. Perfect for testing full roundtrip capabilities.
• mobile_robot.urdf: A simple mobile robot base.
• diff_drive_robot.urdf: A differential drive robot with wheels.
• quadruped_robot.urdf: A 4-legged robot demonstrating complex kinematic chains and multi-link assemblies.

• User Guide - Comprehensive tutorials and getting started.
• API Reference - Technical reference for developers.
• Architecture Guide - System design and internals.
• CHANGELOG - Version history.
• Examples: examples/

# 1. Install 'just' (Command Runner)
brew install just

# 2. Clone repository
git clone https://github.com/arounamounchili/linkforge.git
cd linkforge

# 3. Install dependencies
just install

# Run all tests (Core + Blender)
just test

# Run only core tests
just test-core

# Run with coverage
just coverage

# Run all checks (Lint + Types)
just check

# Fix linting issues
just fix

To package LinkForge as a Blender extension:

# Build the production-ready .zip
just build

The package will be created in the dist/ directory.

• Example Files - Sample URDF files
• Community Forum - Ask questions

• v1.0.0: Core URDF/XACRO Export, Sensors, & ros2_control basics.
• v1.1.0: Enhanced Documentation, Workflow Polish, & Bug Fixes.
• v1.2.0: Architectural Stability (Hexagonal Core, Numerical Precision).
• v1.3.0: Performance & Control (NumPy Acceleration, Depsgraph, & ROS2 Control).
• [/] v1.4.0: Modular Assembly (SRDF, Composer API, linkforge_ros).
• v1.5.0: High-Fidelity Expansion pt.1 (MJCF/MuJoCo support).
• v1.6.0: High-Fidelity Expansion pt.2 (SDF/Gazebo support).
• v1.7.0: Mechanical Debugging (Real-time IK & Collision Interference Validation).
• v2.0.0: Intelligence-Driven Rigging (AI-assisted geometry analysis & Auto-Rigging).

For a deep dive into our long-term strategy, the Digital Twin philosophy, and our technical roadmap for AI and Kinematics, please read our Project Vision.

We welcome contributions! LinkForge is a community-driven project.

• 🙋 Review our Contributing Guide.
• 🏗️ Check our Architecture to understand the internals.
• 💬 Join the conversation on GitHub Discussions.

LinkForge follows a Split-License Model designed for both community-driven innovation and industrial-scale integration:

• linkforge-core (The Engine): Licensed under the Apache License 2.0. This permissive license allows industrial partners to integrate the core engine into proprietary pipelines and commercial products.
• platforms/blender (The UI): Licensed under the GNU General Public License v3.0. This ensures the visual modeling experience and its community-driven improvements remain open-source.

For more details, see the LICENSE (GPL) and core/LICENSE (Apache) files. For third-party component licenses, see THIRD-PARTY-NOTICES.md.

Thanks goes to these wonderful people (emoji key):

arounamounchili 💻 🎨 🤔 🚧

MagnusHanses 🐛

GeKo-8 🐛

Andreas Loeffler 💻 ⚠️

Julian Müller 🤔

Martin Pecka 🐛 🤔

Lionel Fung 🐛

This project follows the all-contributors specification. Contributions of any kind welcome!

Made with ❤️ for roboticists worldwide
Precision engineering meets creative modeling.