MuJoCo

https://mujoco.readthedocs.io/en/stable/
Admin
MuJoCo is a general-purpose physics engine for robotics, biomechanics, graphics, animation, and...
Tokens:707,681
Snippets:4,810
Trust Score:8.3
Update:1 month ago
Show doc for...
Tokens:
Raw
### Record Execution Example

Source: https://mujoco.readthedocs.io/en/stable/programming/samples.html

Example command to record a 5-second animation at 60 frames per second.

```bash
record humanoid.xml 5 60 rgb.out
```

--------------------------------

### Minimal MuJoCo simulation example

Source: https://mujoco.readthedocs.io/en/stable/_sources/python.rst.txt

A complete example showing how to load a model from an XML string with assets and run a basic simulation loop.

```python
import mujoco

XML=r"""
<mujoco>
  <asset>
    <mesh file="gizmo.stl"/>
  </asset>
  <worldbody>
    <body>
      <freejoint/>
      <geom type="mesh" name="gizmo" mesh="gizmo"/>
    </body>
  </worldbody>
</mujoco>
"""

ASSETS=dict()
with open('/path/to/gizmo.stl', 'rb') as f:
  ASSETS['gizmo.stl'] = f.read()

model = mujoco.MjModel.from_xml_string(XML, ASSETS)
data = mujoco.MjData(model)
while data.time < 1:
  mujoco.mj_step(model, data)
  print(data.geom_xpos)
```

--------------------------------

### Install MJWarp via PyPI

Source: https://mujoco.readthedocs.io/en/stable/_sources/mjwarp/index.rst.txt

Standard installation command for the MJWarp package.

```shell
pip install mujoco-warp
```

--------------------------------

### Install MuJoCo Python Bindings

Source: https://mujoco.readthedocs.io/en/stable/_sources/python.rst.txt

Build and install the bindings from a source distribution, ensuring the MuJoCo library and plugin paths are set via environment variables.

```shell
cd dist
MUJOCO_PATH=/PATH/TO/MUJOCO \
MUJOCO_PLUGIN_PATH=/PATH/TO/MUJOCO/PLUGIN \
pip install mujoco-x.y.z.tar.gz
```

--------------------------------

### Install MJX with Warp support

Source: https://mujoco.readthedocs.io/en/stable/_sources/mjx.rst.txt

Installation command including the Warp implementation for NVIDIA GPU acceleration.

```shell
pip install mujoco-mjx[warp]
```

--------------------------------

### Setup virtual environment

Source: https://mujoco.readthedocs.io/en/stable/_sources/python.rst.txt

Create and activate a virtual environment for the build process.

```shell
python3 -m venv /tmp/mujoco
source /tmp/mujoco/bin/activate
```

--------------------------------

### Install MJWarp from source

Source: https://mujoco.readthedocs.io/en/stable/_sources/mjwarp/index.rst.txt

Commands to clone the repository and synchronize dependencies using uv.

```shell
git clone https://github.com/google-deepmind/mujoco_warp.git
cd mujoco_warp
uv sync --all-extras
```

--------------------------------

### Verify MJWarp installation

Source: https://mujoco.readthedocs.io/en/stable/_sources/mjwarp/index.rst.txt

Run the test suite to ensure the installation is functioning correctly.

```shell
uv run pytest -n 8
```

--------------------------------

### Install MJX via pip

Source: https://mujoco.readthedocs.io/en/stable/_sources/mjx.rst.txt

Standard installation command for the MJX package.

```shell
pip install mujoco-mjx
```

--------------------------------

### Install MuJoCo USD Dependencies

Source: https://mujoco.readthedocs.io/en/stable/_sources/python.rst.txt

Command to install the optional dependencies required for USD export functionality.

```shell
pip install mujoco[usd]
```

--------------------------------

### Control Callback Implementation

Source: https://mujoco.readthedocs.io/en/stable/programming/simulation.html

Defines a control callback function to apply damping and installs it globally.

```C
// simple controller applying damping to each DOF
void mycontroller(const mjModel* m, mjData* d) {
  if (m->nu == m->nv)
    mju_scl(d->ctrl, d->qvel, -0.1, m->nv);
}
```

```C
// install control callback
mjcb_control = mycontroller;
```

--------------------------------

### Replicate element usage example

Source: https://mujoco.readthedocs.io/en/stable/XMLreference.html

Demonstrates the use of nested replicate elements to create multiple geoms and sensors with specific offsets and rotations.

```xml
<mujoco>
  <worldbody>
    <replicate count="2" offset="0 1 0" euler="90 0 0">
      <replicate count="2" sep="-" offset="1 0 0" euler="0 90 0">
        <geom name="Alice" size=".1"/>
      </replicate>
    </replicate>
  </worldbody>

  <sensor>
    <accelerometer name="Bob" site="Alice"/>
  </sensor>
</mujoco>
```

```xml
<mujoco>
  <worldbody>
    <geom name="Alice-00" size="0.1"/>
    <geom name="Alice-10" size="0.1" pos="1 0 0" quat="1 0 1 0"/>
    <geom name="Alice-01" size="0.1" pos="0 1 0" quat="1 1 0 0"/>
    <geom name="Alice-11" size="0.1" pos="1 1 0" quat="0.5 0.5 0.5 0.5"/>
  </worldbody>

  <sensor>
    <accelerometer name="Bob-00" site="Alice-00"/>
    <accelerometer name="Bob-10" site="Alice-10"/>
    <accelerometer name="Bob-01" site="Alice-01"/>
    <accelerometer name="Bob-11" site="Alice-11"/>
  </sensor>
</mujoco>
```

--------------------------------

### Define a simple flexcomp

Source: https://mujoco.readthedocs.io/en/stable/XMLreference.html

Example of a flexcomp macro modeling a double pendulum with one end pinned to the world.

```xml
<mujoco>
  <worldbody>
    <flexcomp name="FL" type="grid" dim="1" count="3 1 1" mass="3" spacing="0.2 0.2 0.2">
      <pin id="0"/>
    </flexcomp>
  </worldbody>
</mujoco>
```

--------------------------------

### Generated XML from flexcomp

Source: https://mujoco.readthedocs.io/en/stable/XMLreference.html

The resulting XML structure after loading and saving the flexcomp example, showing the automatically created bodies and flex elements.

```xml
<mujoco>
  <worldbody>
    <body name="FL_1">
      <inertial pos="0 0 0" mass="1" diaginertia="1.66667e-05 1.66667e-05 1.66667e-05"/>
      <joint pos="0 0 0" axis="1 0 0" type="slide"/>
      <joint pos="0 0 0" axis="0 1 0" type="slide"/>
      <joint pos="0 0 0" axis="0 0 1" type="slide"/>
    </body>
    <body name="FL_2" pos="0.2 0 0">
      <inertial pos="0 0 0" mass="1" diaginertia="1.66667e-05 1.66667e-05 1.66667e-05"/>
      <joint pos="0 0 0" axis="1 0 0" type="slide"/>
      <joint pos="0 0 0" axis="0 1 0" type="slide"/>
      <joint pos="0 0 0" axis="0 0 1" type="slide"/>
    </body>
  </worldbody>
  <deformable>
    <flex name="FL" dim="1" body="world FL_1 FL_2" vertex="-0.2 0 0 0 0 0 0 0 0" element="0 1 1 2"/>
  </deformable>
  <equality>
    <flex flex="FL"/>
  </equality>
</mujoco>
```

--------------------------------

### Define a Mesh Asset in MJCF

Source: https://mujoco.readthedocs.io/en/stable/XMLreference.html

Example of declaring a mesh asset and referencing it within a body's geometry.

```xml
<asset>
  <mesh file="forearm.stl"/>
</asset>

<body pos="0 0 0.35"/>
  <joint type="hinge" axis="1 0 0"/>
  <geom type="mesh" mesh="forearm"/>
</body>
```

--------------------------------

### Verify MuJoCo Installation

Source: https://mujoco.readthedocs.io/en/stable/_sources/python.rst.txt

Check that the Python bindings are successfully installed by importing the module.

```shell
python -c "import mujoco"
```

--------------------------------

### Launch passive viewer with context manager

Source: https://mujoco.readthedocs.io/en/stable/_sources/python.rst.txt

A minimal example showing how to launch the viewer, step the physics, and safely modify viewer options using a lock.

```python
import time

import mujoco
import mujoco.viewer

m = mujoco.MjModel.from_xml_path('/path/to/mjcf.xml')
d = mujoco.MjData(m)

with mujoco.viewer.launch_passive(m, d) as viewer:
  # Close the viewer automatically after 30 wall-seconds.
  start = time.time()
  while viewer.is_running() and time.time() - start < 30:
    step_start = time.time()

    # mj_step can be replaced with code that also evaluates
    # a policy and applies a control signal before stepping the physics.
    mujoco.mj_step(m, d)

    # Example modification of a viewer option: toggle contact points every two seconds.
    with viewer.lock():
      viewer.opt.flags[mujoco.mjtVisFlag.mjVIS_CONTACTPOINT] = int(d.time % 2)
```

--------------------------------

### Get Renderer Information

Source: https://mujoco.readthedocs.io/en/stable/APIreference/APIfunctions.html

Gets active renderer information for the given filament context.

```C
void mjrf_getRendererInfo(mjrfContext* ctx, mjrRendererInfo* info);
```

--------------------------------

### Install MuJoCo via pip

Source: https://mujoco.readthedocs.io/en/stable/_sources/python.rst.txt

Use this command to install the MuJoCo Python package from PyPI.

```shell
pip install mujoco
```

--------------------------------

### Run a batched simulation with MJX

Source: https://mujoco.readthedocs.io/en/stable/_sources/mjx.rst.txt

Demonstrates initializing a model, creating data on device, and using jax.vmap to run parallel simulations.

```python
# Throw a ball at 100 different velocities.

import jax
import mujoco
from mujoco import mjx

XML=r"""
<mujoco>
  <worldbody>
    <body>
      <freejoint/>
      <geom size=".15" mass="1" type="sphere"/>
    </body>
  </worldbody>
</mujoco>
"""

model = mujoco.MjModel.from_xml_string(XML)
mjx_model = mjx.put_model(model)

@jax.vmap
def batched_step(vel):
  mjx_data = mjx.make_data(mjx_model)
  qvel = mjx_data.qvel.at[0].set(vel)
  mjx_data = mjx_data.replace(qvel=qvel)
  pos = mjx.step(mjx_model, mjx_data).qpos[0]
  return pos

vel = jax.numpy.arange(0.0, 1.0, 0.01)
pos = jax.jit(batched_step)(vel)
print(pos)
```

--------------------------------

### Benchmark and view environments via CLI

Source: https://mujoco.readthedocs.io/en/stable/_sources/mjwarp/index.rst.txt

Command line tools for testing performance and visualizing simulations.

```shell
mjwarp-testspeed benchmark/humanoid/humanoid.xml
```

```shell
mjwarp-viewer benchmark/humanoid/humanoid.xml
```

--------------------------------

### Simulate environment with viewer

Source: https://mujoco.readthedocs.io/en/stable/mjwarp/index.html

Launch the interactive viewer for a specified XML environment.

```bash
mjwarp-viewer benchmark/humanoid/humanoid.xml
```

--------------------------------

### Initialize and Run MuJoCo Visualization Loop

Source: https://mujoco.readthedocs.io/en/stable/_sources/programming/visualization.rst.txt

Demonstrates the standard lifecycle of a MuJoCo application using GLFW, including initialization of visualization structures, the main simulation-rendering loop, and cleanup.

```C
// MuJoCo data structures
mjModel* m = NULL;                  // MuJoCo model
mjData* d = NULL;                   // MuJoCo data
mjvCamera cam;                      // abstract camera
mjvOption opt;                      // visualization options
mjvScene scn;                       // abstract scene
mjrContext con;                     // custom GPU context

// ... load model and data

// init GLFW, create window, make OpenGL context current, request v-sync
glfwInit();
GLFWwindow* window = glfwCreateWindow(1200, 900, "Demo", NULL, NULL);
glfwMakeContextCurrent(window);
glfwSwapInterval(1);

// initialize visualization data structures
mjv_defaultCamera(&cam);
mjv_defaultPerturb(&pert);
mjv_defaultOption(&opt);
mjr_defaultContext(&con);

// create scene and context
mjv_makeScene(m, &scn, 1000);
mjr_makeContext(m, &con, mjFONTSCALE_100);

// ... install GLFW keyboard and mouse callbacks

// run main loop, target real-time simulation and 60 fps rendering
while( !glfwWindowShouldClose(window) ) {
  // advance interactive simulation for 1/60 sec
  //  Assuming MuJoCo can simulate faster than real-time, which it usually can,
  //  this loop will finish on time for the next frame to be rendered at 60 fps.
  //  Otherwise add a cpu timer and exit this loop when it is time to render.
  mjtNum simstart = d->time;
  while( d->time - simstart < 1.0/60.0 )
      mj_step(m, d);

  // get framebuffer viewport
mjrRect viewport = {0, 0, 0, 0};
glfwGetFramebufferSize(window, &viewport.width, &viewport.height);

  // update scene and render
mjv_updateScene(m, d, &opt, NULL, &cam, mjCAT_ALL, &scn);
mjr_render(viewport, &scn, &con);

  // swap OpenGL buffers (blocking call due to v-sync)
glfwSwapBuffers(window);

  // process pending GUI events, call GLFW callbacks
glfwPollEvents();
}

// close GLFW, free visualization storage
glfwTerminate();
mjv_freeScene(&scn);
mjr_freeContext(&con);
```

--------------------------------

### Band-dense matrix memory layout example

Source: https://mujoco.readthedocs.io/en/stable/APIreference/APIfunctions.html

Example memory layout for an arrowhead matrix with nband=3, ndense=2, and ntotal=8.

```text
0   1   2
    3   4   5
        6   7   8
            9   10  11
                12  13  14
                    15  16  17
        18  19  20  21  22  23  24  25
        26  27  28  29  30  31  32  33
```

--------------------------------

### Initialize Sparse qD_fullm Indices

Source: https://mujoco.readthedocs.io/en/stable/_modules/mujoco_warp/_src/io.html

Sets up indices for sparse qD_fullm used in RNE derivatives.

```python
  # indices for sparse qD_fullm (used in RNE derivatives)
  # D-structure is the full square sparsity pattern (both upper and lower triangle)
  m.qD_fullm_i, m.qD_fullm_j = [], []
  for i in range(mjm.nv):
    rowadr = mjm.D_rowadr[i]
    rownnz = mjm.D_rownnz[i]
    for k in range(rownnz):
      m.qD_fullm_i.append(i)
      m.qD_fullm_j.append(int(mjm.D_colind[rowadr + k]))
  m.nD = mjm.nD
```

--------------------------------

### Launch Equality Constraints via Warp

Source: https://mujoco.readthedocs.io/en/stable/_modules/mujoco_warp/_src/constraint.html

These snippets demonstrate the use of wp.launch to execute equality constraint kernels for various physical components in MuJoCo.

```python
          m.jnt_dofadr,
          m.dof_invweight0,
          m.eq_obj1id,
          m.eq_obj2id,
          m.eq_solref,
          m.eq_solimp,
          m.eq_data,
          m.eq_jnt_adr,
          d.qpos,
          d.qvel,
          d.eq_active,
          d.njmax,
          d.njmax_nnz,
        ],
        outputs=[
          d.ne,
          d.nefc,
          d.efc.type,
          d.efc.id,
          d.efc.jtdaj_adr,
          d.efc.jtdaj_nrow,
          d.efc.jtdaj_nblock,
          d.efc.J_rownnz,
          d.efc.J_rowadr,
          d.efc.J_colind,
          d.efc.J,
          d.efc.pos,
          d.efc.margin,
          d.efc.D,
          d.efc.vel,
          d.efc.aref,
          d.efc.frictionloss,
          efc_nnz,
        ],
      )
      wp.launch(
        _equality_tendon(m.is_sparse, newton),
        dim=(d.nworld, m.eq_ten_adr.size),
        inputs=[
          m.nv,
          m.opt.timestep,
          m.opt.disableflags,
          m.eq_obj1id,
          m.eq_obj2id,
          m.eq_solref,
          m.eq_solimp,
          m.eq_data,
          m.ten_J_rownnz,
          m.ten_J_rowadr,
          m.ten_J_colind,
          m.tendon_length0,
          m.tendon_invweight0,
          m.eq_ten_adr,
          d.qvel,
          d.eq_active,
          d.ten_J,
          d.ten_length,
          d.njmax,
          d.njmax_nnz,
        ],
        outputs=[
          d.ne,
          d.nefc,
          d.efc.type,
          d.efc.id,
          d.efc.jtdaj_adr,
          d.efc.jtdaj_nrow,
          d.efc.jtdaj_nblock,
          d.efc.J_rownnz,
          d.efc.J_rowadr,
          d.efc.J_colind,
          d.efc.J,
          d.efc.pos,
          d.efc.margin,
          d.efc.D,
          d.efc.vel,
          d.efc.aref,
          d.efc.frictionloss,
          efc_nnz,
        ],
      )
```

```python
      if m.nflex > 0:
        wp.launch(
          _equality_flex(m.is_sparse, newton),
          dim=(d.nworld, m.eq_flex_adr.size, m.nflexedge),
          inputs=[
            m.nv,
            m.opt.timestep,
            m.opt.disableflags,
            m.flex_interp,
            m.flex_edgeadr,
            m.flex_edgenum,
            m.flexedge_length0,
            m.flexedge_invweight0,
            m.flexedge_J_rownnz,
            m.flexedge_J_rowadr,
            m.flexedge_J_colind,
            m.eq_obj1id,
            m.eq_solref,
            m.eq_solimp,
            m.eq_flex_adr,
            d.qvel,
            d.eq_active,
            d.flexedge_J,
            d.flexedge_length,
            d.njmax,
            d.njmax_nnz,
          ],
          outputs=[
            d.ne,
            d.nefc,
            d.efc.type,
            d.efc.id,
            d.efc.jtdaj_adr,
            d.efc.jtdaj_nrow,
            d.efc.jtdaj_nblock,
            d.efc.J_rownnz,
            d.efc.J_rowadr,
            d.efc.J_colind,
            d.efc.J,
            d.efc.pos,
            d.efc.margin,
            d.efc.D,
            d.efc.vel,
            d.efc.aref,
            d.efc.frictionloss,
            efc_nnz,
          ],
        )

        if m.eq_flexstrain_adr.size:
          wp.launch(
            _equality_flexstrain(m.is_sparse, newton),
            dim=(d.nworld, m.eq_flexstrain_adr.size),
            inputs=[
              m.nv,
              m.opt.timestep,
              m.opt.disableflags,
              m.body_parentid,
              m.body_rootid,
              m.body_dofnum,
              m.body_dofadr,
              m.body_invweight0,
              m.dof_bodyid,
              m.flex_interp,
              m.flex_cellnum,
              m.flex_nodeadr,
              m.flex_nodenum,
              m.flex_stiffnessadr,
              m.flex_nodebodyid,
              m.flex_node,
              m.flex_node0,
              m.flex_stiffness,
              m.flex_centered,
              m.eq_obj1id,
              m.eq_solref,
              m.eq_solimp,
              m.eq_data,
              m.body_isdofancestor,
              m.eq_flexstrain_adr,
              m.flexstrain_J_rownnz,
              m.flexstrain_J_rowadr,
              m.flexstrain_J_colind,
              d.qvel,
              d.eq_active,
              d.xpos,
              d.xmat,
              d.subtree_com,
              d.cdof,
              d.njmax,
              d.njmax_nnz,
              d.flexnode_xpos,
              d.face_quat,
            ],
            outputs=[
              d.ne,
              d.nefc,
              d.efc.type,
              d.efc.id,
              d.efc.jtdaj_adr,
              d.efc.jtdaj_nrow,
              d.efc.jtdaj_nblock,
              d.efc.J_rownnz,
              d.efc.J_rowadr,
              d.efc.J_colind,
              d.efc.J,
              d.efc.pos,
              d.efc.margin,
              d.efc.D,
              d.efc.vel,
              d.efc.aref,
              d.efc.frictionloss,
              efc_nnz,
            ],
          )
```

--------------------------------

### Implementing a Minimal Decoder

Source: https://mujoco.readthedocs.io/en/stable/_sources/programming/extension.rst.txt

A complete example showing the implementation of decoding logic, validation, and registration for a binary mesh format.

```C
#include <mujoco.h>

static mjSpec* MyDecode(mjResource* resource, const mjVFS* vfs) {
  const void* bytes = NULL;
  int nbytes = mju_readResource(resource, &bytes);
  if (nbytes < 0) {
    mju_warning("failed to read resource '%s'", resource->name);
    return NULL;
  }

  /* ... parse bytes into vertex/face arrays ... */

  mjSpec* spec = mj_makeSpec();
  mjsMesh* mesh = mjs_addMesh(spec, NULL);
  mjs_setString(mesh->file, resource->name);
  mjs_setFloat(mesh->uservert, vertices, nvert * 3);
  mjs_setInt(mesh->userface, faces, nface * 3);
  return spec;
}

static int MyCanDecode(const mjResource* resource) {
  /* check file extension */
  const char* name = resource->name;
  int len = strlen(name);
  return len > 4 && strcmp(name + len - 4, ".myf") == 0;
}

mjPLUGIN_LIB_INIT(my_format_decoder) {
  mjpDecoder decoder;
  mjp_defaultDecoder(&decoder);
  decoder.content_type = "model/my-format";
  decoder.extension = ".myf";
  decoder.decode = MyDecode;
  decoder.can_decode = MyCanDecode;
  mjp_registerDecoder(&decoder);
}
```

--------------------------------

### Get Frame

Source: https://mujoco.readthedocs.io/en/stable/APIreference/APIfunctions.html

Retrieves the parent frame of an element.

```c
mjsFrame* mjs_getFrame(const mjsElement* element);
```

--------------------------------

### Run MuJoCo simulation samples

Source: https://mujoco.readthedocs.io/en/stable/_sources/programming/index.rst.txt

Commands to execute the simulation binary from the bin directory on different operating systems.

```Text
     Windows:           simulate ..\model\humanoid\humanoid.xml
     Linux and macOS:   ./simulate ../model/humanoid/humanoid.xml
```

--------------------------------

### Get Parent

Source: https://mujoco.readthedocs.io/en/stable/APIreference/APIfunctions.html

Retrieves the parent body of an element.

```c
mjsBody* mjs_getParent(const mjsElement* element);
```

--------------------------------

### Sensor Data Processing and Kernel Launches

Source: https://mujoco.readthedocs.io/en/stable/_modules/mujoco_warp/_src/sensor.html

Initializes sensor contact buffers and launches various kernels for contact matching, sorting, acceleration, and force calculations.

```python
  sensor_contact_nmatch = wp.empty((d.nworld, m.nsensorcontact), dtype=int)
  sensor_contact_matchid = wp.empty((d.nworld, m.nsensorcontact, m.opt.contact_sensor_maxmatch), dtype=int)
  sensor_contact_direction = wp.empty((d.nworld, m.nsensorcontact, m.opt.contact_sensor_maxmatch), dtype=float)
  if m.nsensorcontact:
    sensor_contact_criteria = wp.empty((d.nworld, m.nsensorcontact, m.opt.contact_sensor_maxmatch), dtype=float)
    # TODO(team): fill_ operations in one kernel?
    sensor_contact_nmatch.fill_(0)
    sensor_contact_matchid.fill_(-1)
    sensor_contact_criteria.fill_(1.0e32)

    wp.launch(
      _contact_match,
      dim=(m.sensor_contact_adr.size, d.naconmax),
      inputs=[
        m.opt.cone,
        m.opt.contact_sensor_maxmatch,
        m.opt.warn_overflow,
        m.body_parentid,
        m.geom_bodyid,
        m.site_type,
        m.site_size,
        m.sensor_objtype,
        m.sensor_objid,
        m.sensor_reftype,
        m.sensor_refid,
        m.sensor_intprm,
        m.sensor_contact_adr,
        d.site_xpos,
        d.site_xmat,
        d.contact.dist,
        d.contact.pos,
        d.contact.frame,
        d.contact.friction,
        d.contact.dim,
        d.contact.geom,
        d.contact.efc_address,
        d.contact.worldid,
        d.contact.type,
        d.efc.force,
        d.njmax,
        d.nacon,
      ],
      outputs=[d.overflow, sensor_contact_nmatch, sensor_contact_matchid, sensor_contact_criteria, sensor_contact_direction],
    )

    # sorting
    wp.launch_tiled(
      _contact_sort(m.opt.contact_sensor_maxmatch),
      dim=(d.nworld, m.sensor_contact_adr.size),
      inputs=[m.sensor_intprm, m.sensor_contact_adr, sensor_contact_nmatch, sensor_contact_matchid, sensor_contact_criteria],
      outputs=[sensor_contact_matchid],
      block_dim=m.block_dim.contact_sort,
    )

  if m.sensor_rne_postconstraint:
    smooth.rne_postconstraint(m, d)

  wp.launch(
    _sensor_acc,
    dim=(d.nworld, m.sensor_acc_adr.size),
    inputs=[
      m.opt.cone,
      m.body_rootid,
      m.jnt_dofadr,
      m.geom_bodyid,
      m.site_bodyid,
      m.cam_bodyid,
      m.sensor_type,
      m.sensor_datatype,
      m.sensor_objtype,
      m.sensor_objid,
      m.sensor_intprm,
      m.sensor_dim,
      m.sensor_adr,
      m.sensor_cutoff,
      m.sensor_acc_adr,
      m.sensor_adr_to_contact_adr,
      d.xpos,
      d.xipos,
      d.geom_xpos,
      d.site_xpos,
      d.site_xmat,
      d.cam_xpos,
      d.subtree_com,
      d.cvel,
      d.actuator_force,
      d.qfrc_actuator,
      d.cacc,
      d.cfrc_int,
      d.contact.dist,
      d.contact.pos,
      d.contact.frame,
      d.contact.friction,
      d.contact.dim,
      d.contact.efc_address,
      d.efc.force,
      d.njmax,
      d.nacon,
      sensor_contact_nmatch,
      sensor_contact_matchid,
      sensor_contact_direction,
    ],
    outputs=[d.sensordata],
  )

  wp.launch(
    _tendon_actuator_force,
    dim=(d.nworld, m.sensor_tendonactfrc_adr.size, m.nu),
    inputs=[
      m.actuator_trntype,
      m.actuator_trnid,
      m.sensor_objid,
      m.sensor_adr,
      m.sensor_tendonactfrc_adr,
      d.actuator_force,
    ],
    outputs=[
      d.sensordata,
    ],
  )

  wp.launch(
    _tendon_actuator_force_cutoff,
    dim=(d.nworld, m.sensor_tendonactfrc_adr.size),
    inputs=[
      m.sensor_type,
      m.sensor_datatype,
      m.sensor_adr,
      m.sensor_cutoff,
      m.sensor_tendonactfrc_adr,
      d.sensordata,
    ],
    outputs=[d.sensordata],
  )

  wp.launch(
    _limit_frc,
    dim=(d.nworld, d.njmax, m.sensor_limitfrc_adr.size),
    inputs=[
      m.sensor_type,
      m.sensor_datatype,
      m.sensor_objid,
      m.sensor_adr,
      m.sensor_cutoff,
      m.sensor_limitfrc_adr,
      d.ne,
      d.nf,
      d.nl,
      d.efc.type,
      d.efc.id,
      d.efc.force,
    ],
    outputs=[
      d.sensordata,
    ],
  )

  # apply sensor delay/interval for acceleration sensors
  history.apply_sensor_delay(m, d, m.sensor_acc_adr)
  history.apply_sensor_delay(m, d, m.sensor_limitfrc_adr)

  if m.callback.sensor:
    m.callback.sensor(m, d, Stage.ACC)
```

--------------------------------

### Get Spec

Source: https://mujoco.readthedocs.io/en/stable/APIreference/APIfunctions.html

Retrieves the specification from a body element.

```c
mjSpec* mjs_getSpec(const mjsElement* element);
```

--------------------------------

### mj_getCacheCapacity

Source: https://mujoco.readthedocs.io/en/stable/APIreference/APIfunctions.html

Get the capacity of the asset cache in bytes.

```APIDOC
## size_t mj_getCacheCapacity(const mjCache* cache)

### Description
Get the capacity of the asset cache in bytes.

### Parameters
- **cache** (const mjCache*) - Required - Pointer to the asset cache.
```

--------------------------------

### Enable USD Support with Pre-built USD and pxr_DIR

Source: https://mujoco.readthedocs.io/en/stable/OpenUSD/building.html

Configure MuJoCo to use a pre-built USD library by passing the `MUJOCO_WITH_USD` and `pxr_DIR` flags. This command sets the flags and builds MuJoCo.

```bash
cd ~/mujoco
cmake -Bbuild -S. -DMUJOCO_WITH_USD=True -Dpxr_DIR=/path/to/my_usd_install_dir
cmake --build build -j 64
```

--------------------------------

### Get sensor dimension

Source: https://mujoco.readthedocs.io/en/stable/APIreference/APIfunctions.html

Returns the dimension of the provided sensor.

```c
int mjs_sensorDim(const mjsSensor* sensor);
```

--------------------------------

### Factorization Entry Point

Source: https://mujoco.readthedocs.io/en/stable/_modules/mujoco_warp/_src/smooth.html

Main entry point for factoring the inertia-like matrix M.

```python
[docs]
@event_scope
def factor_m(m: Model, d: Data):
  """Factorization of inertia-like matrix M, assumed spd.

  Compact blocks use reciprocal diagonals, full small blocks use scalar Cholesky, larger dense
  blocks use tile Cholesky, and oversized blocks use sparse LDL.
  """
  if m.M_tiles:
    _factor_blocks(m, d, d.M, d.qLD, d.qLDiagInv)
  if d.qLD.shape[1] > m.qLD_block_total:
    _factor_i_sparse(m, d, d.M, d.qLD[:, m.qLD_block_total :], d.qLDiagInv)
```

--------------------------------

### Manage MuJoCo GPU Context

Source: https://mujoco.readthedocs.io/en/stable/_sources/programming/visualization.rst.txt

Demonstrates the lifecycle of an mjrContext, including initialization, creation for a model, and freeing resources.

```C
mjModel* m;
mjrContext con;

// clear mjrContext only once before first use
mjr_defaultContext(&con);

// create window with OpenGL context, make it current
GLFWwindow* window = glfwCreateWindow(1200, 900, "Demo", NULL, NULL);
glfwMakeContextCurrent(window);

// ... load MuJoCo model

// make model-specific mjrContext
mjr_makeContext(m, &con, mjFONTSCALE_100);

// ... load another MuJoCo model

// make mjrContext for new model (old context freed automatically)
mjr_makeContext(m, &con, mjFONTSCALE_100);

// free context when done
mjr_freeContext(&con);
```

--------------------------------

### Get Light Type

Source: https://mujoco.readthedocs.io/en/stable/APIreference/APIfunctions.html

Returns the type of the light (mjrLightType).

```c
int mjrf_getLightType(const mjrfLight* light);
```

--------------------------------

### mj_getCache

Source: https://mujoco.readthedocs.io/en/stable/APIreference/APIfunctions.html

Get the internal asset cache used by the compiler.

```APIDOC
## mjCache* mj_getCache(void)

### Description
Get the internal asset cache used by the compiler.
```

--------------------------------

### Build USD with build_usd.py Script

Source: https://mujoco.readthedocs.io/en/stable/OpenUSD/building.html

Build USD using its `build_usd.py` script for more customization. It is recommended to use a separate installation directory outside the cloned repository.

```bash
git clone https://github.com/PixarAnimationStudios/OpenUSD
python OpenUSD/build_scripts/build_usd.py /path/to/my_usd_install_dir
```

--------------------------------

### mj_getCacheSize

Source: https://mujoco.readthedocs.io/en/stable/APIreference/APIfunctions.html

Get the current size of the asset cache in bytes.

```APIDOC
## size_t mj_getCacheSize(const mjCache* cache)

### Description
Get the current size of the asset cache in bytes.

### Parameters
- **cache** (const mjCache*) - Required - Pointer to the asset cache.
```

--------------------------------

### Initialize Data for JAX

Source: https://mujoco.readthedocs.io/en/stable/_modules/mujoco/mjx/_src/io.html

Internal logic for setting up JAX-compatible data structures, including zero-initialization of specific fields and device placement.

```python
  if m.opt.cone == types.ConeType.ELLIPTIC and np.any(contact.dim == 1):
    raise NotImplementedError(
        'condim=1 with ConeType.ELLIPTIC not implemented.'
    )

  zero_impl_fields = {
      'solver_niter': (int_,),
      'cinert': (m.nbody, 10, float_),
      'ten_wrapadr': (m.ntendon, np.int32),
      'ten_wrapnum': (m.ntendon, np.int32),
      'ten_J': (m.ntendon, m.nv, float_),
      'wrap_obj': (m.nwrap, 2, np.int32),
      'wrap_xpos': (m.nwrap, 6, float_),
      'actuator_moment': (m.nu, m.nv, float_),
      'crb': (m.nbody, 10, float_),
      'M': (m.nC, float_) if support.is_sparse(m) else (m.nv, m.nv, float_),
      'qLD': (m.nC, float_) if support.is_sparse(m) else (m.nv, m.nv, float_),
      'qLDiagInv': (m.nv, float_) if support.is_sparse(m) else (0, float_),
      'ten_velocity': (m.ntendon, float_),
      'actuator_velocity': (m.nu, float_),
      'cacc': (m.nbody, 6, float_),
      'cfrc_int': (m.nbody, 6, float_),
      'cfrc_ext': (m.nbody, 6, float_),
      'subtree_linvel': (m.nbody, 3, float_),
      'subtree_angmom': (m.nbody, 3, float_),
      'efc_J': (nefc, m.nv, float_),
      'efc_pos': (nefc, float_),
      'efc_margin': (nefc, float_),
      'efc_frictionloss': (nefc, float_),
      'efc_D': (nefc, float_),
      'efc_aref': (nefc, float_),
      'efc_force': (nefc, float_),
  }
  zero_impl_fields = {
      k: np.zeros(v[:-1], dtype=v[-1]) for k, v in zero_impl_fields.items()
  }
  impl = types.DataJAX(
      ne=ne,
      nf=nf,
      nl=nl,
      nefc=nefc,
      ncon=ncon,
      contact=contact,
      efc_type=efc_type,
      **zero_impl_fields,
  )

  d = types.Data(
      qpos=jp.array(m.qpos0, dtype=float_),
      eq_active=m.eq_active0,
      _impl=impl,
      **_make_data_public_fields(m),  # pyrefly: ignore[bad-argument-type]
  )

  if m.nmocap:
    # Set mocap_pos/quat = body_pos/quat for mocap bodies as done in C MuJoCo.
    body_mask = m.body_mocapid >= 0
    body_pos = m.body_pos[body_mask]
    body_quat = m.body_quat[body_mask]
    d = d.replace(
        mocap_pos=body_pos[m.body_mocapid[body_mask]],
        mocap_quat=body_quat[m.body_mocapid[body_mask]],
    )

  d = jax.device_put(d, device=device)
  return d
```

--------------------------------

### mju_user_free

Source: https://mujoco.readthedocs.io/en/stable/APIreference/APIglobals.html

Allows the user to install a custom memory deallocation mechanism.

```APIDOC
## mju_user_free

### Description
If this is installed, MuJoCo will free any heap memory it allocated by calling this function.

### Signature
`extern void (*mju_user_free)(void*);`
```

--------------------------------

### name2id

Source: https://mujoco.readthedocs.io/en/stable/mjx_api.html

Gets the id of an object with the specified mjtObj type and name.

```APIDOC
## name2id(m, typ, name)

### Description
Gets the id of an object with the specified mjtObj type and name.

### Parameters
- **m** (Model | MjModel) - Required - mujoco.MjModel or mjx.Model
- **typ** (mjtObj) - Required - mujoco.mjtObj type
- **name** (str) - Required - the name of the object

### Returns
- **int** - the id, or -1 if not found
```

--------------------------------

### Initialize elements using default classes

Source: https://mujoco.readthedocs.io/en/stable/_sources/programming/modeledit.rst.txt

Demonstrates how to set default properties and initialize a geometry element using the MuJoCo specification API.

```C
mjSpec* spec = mj_makeSpec();
mjsDefault* main = mjs_getSpecDefault(spec);
main->geom.type = mjGEOM_BOX;
mjsGeom* geom = mjs_addGeom(mjs_findBody(spec, "world"), main);
```
Tokens:
Raw