diff --git a/_data/navigation.yml b/_data/navigation.yml
index 60b17258..6557d2ee 100644
--- a/_data/navigation.yml
+++ b/_data/navigation.yml
@@ -312,6 +312,8 @@ wiki:
url: /wiki/simulation/gazebo-classic-simulation-of-graspable-and-breakable-objects
- title: NVIDIA Isaac Sim Setup and ROS2 Workflow
url: /wiki/simulation/simulation-isaacsim-setup/
+ - title: Creating Custom Robot Models for MuJoCo
+ url: /wiki/simulation/mujoco_robot_modeling
- title: Interfacing
url: /wiki/interfacing/
children:
diff --git a/wiki/simulation/mujoco_robot_modeling.md b/wiki/simulation/mujoco_robot_modeling.md
new file mode 100644
index 00000000..ceb34e08
--- /dev/null
+++ b/wiki/simulation/mujoco_robot_modeling.md
@@ -0,0 +1,541 @@
+---
+date: 2026-04-29
+title: Creating Custom Robot Models for MuJoCo
+---
+MuJoCo (Multi-Joint dynamics with Contact) is a high-performance physics engine widely used in robotics research, reinforcement learning, and biomechanics. Creating a custom robot model involves two complementary phases: designing the physical robot and encoding its geometry and dynamics into a simulation-ready model file. This article covers the full pipeline from physical design to a working MuJoCo simulation, including link geometry, joint layout, actuator selection, and authoring both URDF and MJCF model files. Readers will also find guidance on physics parameter tuning, mesh preparation, and testing strategies. Whether you are building a robot arm, legged system, or aerial manipulator, this article provides the foundational knowledge to get your robot simulating correctly in MuJoCo.
+
+## Physical Model Design
+
+Before writing a single line of XML, you must define the robot's physical architecture. Decisions made here directly affect simulation accuracy, computational cost, and control complexity.
+
+### Kinematic Structure
+
+The kinematic chain is the ordered sequence of rigid bodies (links) connected by joints. Three common topologies appear in practice:
+
+- **Serial chains** — one parent per link; used in robot arms and leg segments.
+- **Parallel mechanisms** — closed-loop structures such as delta robots and Stewart platforms.
+- **Trees** — branching limbs used in humanoids and quadrupeds.
+
+Start with a Degrees of Freedom (DoF) analysis. Count the independent joints needed for your task. Each revolute or prismatic joint costs one DoF and one control signal.
+
+### Link Geometry
+
+Each link must be described by a collision geometry and optionally a separate visual geometry. MuJoCo supports several primitive shapes natively:
+
+| Shape | MJCF Tag | Common Use Case |
+|-------|----------|-----------------|
+| Box | `` | Chassis, base plates, cuboid links |
+| Sphere | `` | Ball joints, feet, sensors |
+| Capsule | `` | Limbs, fingers |
+| Cylinder | `` | Wheels, rollers |
+| Ellipsoid | `` | Organic approximations |
+| Mesh | `` | CAD-exported STL/OBJ geometry |
+
+> Prefer capsules over cylinders for link geometry. Capsules are computationally cheaper in contact detection and avoid edge-contact singularities that can destabilize the solver.
+
+### Joint Types
+
+MuJoCo uses different joint type names than URDF. The mapping is:
+
+| URDF Type | MJCF Type | Description |
+|-----------|-----------|-------------|
+| `revolute` | `hinge` | Rotation about a fixed axis |
+| `prismatic` | `slide` | Translation along an axis |
+| `floating` | `free` | 6-DoF floating base |
+| *(not supported)* | `ball` | 3-DoF spherical joint |
+| `fixed` | *(merge bodies)* | Rigid attachment, no DoF |
+
+### Mass and Inertia
+
+Accurate inertial parameters are critical for realistic dynamics. For each link you need the mass (kg), center of mass (CoM) position relative to the link frame, and the inertia tensor expressed as six unique values: `ixx`, `iyy`, `izz`, `ixy`, `ixz`, `iyz`.
+
+For uniform primitive shapes, inertia can be computed analytically. For example, for a solid cylinder of mass `m`, radius `r`, and height `h`:
+
+```python
+ixx = iyy = m * (3*r**2 + h**2) / 12
+izz = m * r**2 / 2
+ixy = ixz = iyz = 0.0
+```
+
+For mesh-based links, use MeshLab, SolidWorks, or Fusion 360 to export inertial properties from your CAD model. As a starting point, MuJoCo can auto-compute inertia from geometry by setting `inertiafromgeom="true"` in the `` tag.
+
+> The inertia tensor must be positive-definite. Verify these triangle inequalities for every link: `ixx + iyy > izz`, `ixx + izz > iyy`, `iyy + izz > ixx`. Violating them will produce `nan` values or simulation instability.
+
+### Actuator Selection
+
+MuJoCo provides several actuator models. The right choice depends on your hardware:
+
+| Actuator | Best For |
+|----------|----------|
+| `motor` | DC motors and linear actuators (pure torque/force output) |
+| `position` | Hobby servos and Dynamixel (PD position servo) |
+| `velocity` | Velocity-controlled motors |
+| `general` | Maximum flexibility with custom gain, bias, and dynamics chain |
+| `cylinder` | Pneumatic or hydraulic actuators |
+| `muscle` | Hill-type muscle model for biomechanics |
+
+## Creating the URDF Model
+
+URDF (Unified Robot Description Format) is an XML format originally developed for ROS. It describes a robot as a tree of links and joints and can be converted to MJCF using MuJoCo's built-in converter. URDF is the recommended starting format when ROS compatibility is needed.
+
+### URDF File Structure
+
+```xml
+
+
+
+
+ ...
+ ...
+
+
+
+
+
+
+
+
+
+
+```
+
+### Defining a Link
+
+Each link has three sub-elements: ``, ``, and ``. All three are optional but recommended for simulation:
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+### Defining a Joint
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+```
+
+### Validating Your URDF
+
+Always validate the URDF before converting to MJCF:
+
+```bash
+# ROS-based validation
+check_urdf my_robot.urdf
+
+# Python: parse with urdfpy (no ROS required)
+pip install urdfpy
+python -c "from urdfpy import URDF; r = URDF.load('my_robot.urdf'); print(r.link_names)"
+
+# Standalone parser
+pip install urdf-parser-py
+python -c "
+from urdf_parser_py.urdf import URDF
+robot = URDF.from_xml_file('my_robot.urdf')
+print('Links:', [l.name for l in robot.links])
+print('Joints:', [j.name for j in robot.joints])
+"
+```
+
+## MJCF: Native MuJoCo Format
+
+MJCF is the native description language of MuJoCo. It offers significantly richer features than URDF: tendons, actuator dynamics, contact parameters, sensors, keyframes, and more. You can author MJCF directly or convert from URDF and refine.
+
+### Converting URDF to MJCF
+
+```python
+import mujoco
+
+# Load from URDF and save as MJCF
+model = mujoco.MjModel.from_xml_path('my_robot.urdf')
+mujoco.mj_saveModel(model, 'my_robot.xml')
+```
+
+> The URDF-to-MJCF conversion may produce suboptimal contact and collision parameters. Always review the converted MJCF manually — especially the ``, `