> This page is for version Release 3.0 (default).
> For other versions, use one of these documentation indexes:
> - Release 3.0 (default): https://docs.nvidia.com/isaaclab/3.0/llms.txt
> - Release 2.3: https://docs.nvidia.com/isaaclab/2.3/llms.txt
> - Release 2.2: https://docs.nvidia.com/isaaclab/2.2/llms.txt
> - Release 2.1: https://docs.nvidia.com/isaaclab/2.1/llms.txt

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/isaaclab/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/isaaclab/_mcp/server.

# Importing a New Asset

NVIDIA Omniverse relies on the Universal Scene Description (USD) file format to
import and export assets. USD is an open source file format developed by Pixar
Animation Studios. It is a scene description format optimized for large-scale,
complex data sets. While this format is widely used in the film and animation
industry, it is less common in the robotics community.

To this end, NVIDIA has developed various importers that allow you to import
assets from other file formats into USD. These importers are available through
Omniverse Kit workflows, and the URDF/MJCF Python importers can also be used
from a standalone pip wheel:

* **URDF Importer** - Import assets from URDF files.
* **MJCF Importer** - Import assets from MJCF files.
* **Mesh Importer** - Import assets from various file formats, including
  OBJ, FBX, STL, and glTF.

The recommended workflow from NVIDIA is to use the above importers to convert
the asset into its USD representation. Once the asset is in USD format, you can
use the Omniverse Kit to edit the asset and export it to other file formats. Isaac Sim includes
these importers by default. They can also be enabled manually in Omniverse Kit.

Isaac Lab's URDF and MJCF converter utilities first use the importer APIs from
Isaac Sim when the full runtime is installed. In kit-less environments they fall back
to the standalone importers described in
[Standalone URDF/MJCF importers](/source/how-to/import_new_asset#standalone-urdf-mjcf-importers) below.
The Kit visualizer and GUI import dialogs still require an Omniverse Kit runtime.

An important note to use assets for large-scale simulation is to ensure that they
are in [instanceable](https://openusd.org/dev/api/_usd__page__scenegraph_instancing.html) format. This allows the asset to be efficiently loaded
into memory and used multiple times in a scene. Otherwise, the asset will be
loaded into memory multiple times, which can cause performance issues.
For more details on instanceable assets, please check the Isaac Sim [documentation](https://docs.isaacsim.omniverse.nvidia.com/latest/isaac_lab_tutorials/tutorial_instanceable_assets.html).

## Standalone URDF/MJCF importers

The URDF and MJCF converter scripts run without Isaac Sim. The standalone
importers are optional; install them with the `isaaclab[importers]` command in
[Installing the `importers` extra](/source/setup/installation/index#installing-the-importers-extra) before running these scripts.
Optionally pass `--viz newton_gl` (or `rerun` / `viser`) to preview the converted asset in a
kit-less Isaac Lab visualizer:

```bash
uv run --extra importers isaaclab -p scripts/tools/convert_urdf.py \
  path/to/robot.urdf path/to/output_dir --merge_joints

uv run --extra importers isaaclab -p scripts/tools/convert_mjcf.py \
  path/to/model.xml path/to/output.usd --merge_mesh
```

If Isaac Sim is installed in the same environment, Isaac Lab uses the Isaac Sim importer
extensions first. The standalone wheel is used only when the full Isaac Sim runtime is not
available.

## Multi-backend assets

A converted asset can carry shared USD physics and backend-specific attributes. The
Isaac Sim 6.2 standalone URDF and MJCF importers produce layered output such as:

```text
robot_name.usda                    interface USD and Physics variant selection
payloads/base.usda                 composed asset
payloads/instances.usda            reusable geometry
payloads/Physics/physics.usda      shared physics and compatible backend attributes
```

Additional physics layers depend on the source asset and importer version. A layer named
`physx.usda` or `mujoco.usda` does not by itself mean that a variant with that name exists.
Inspect the interface USD's `Physics` variant set before requesting a backend-specific variant.

`sim.converters.AssetConverterBaseCfg.physics_variant` defaults to `physics`.
The tested Isaac Sim 6.2 output exposes `physics` and `none`; `none` omits the physics
payload. Isaac Lab selects the requested variant explicitly and raises an error if the
asset has a `Physics` variant set without that variant. Do not assume that `physx`
or `mujoco` is selectable on every converted asset.

`run_multi_physics_conversion`, enabled by default, asks the importer to convert supported
backend-specific physics attributes. This does not guarantee equivalent solver behavior or
support for every source feature. Validate masses, inertias, collisions and joint control on
the intended physics backend.

With `run_asset_transformer=False`, the tested converters produce flat output without a
`Physics` variant set. Isaac Lab leaves that output unchanged rather than selecting a variant.
For an existing layered asset, `sim.UsdFileCfg.variants` can override an available
selection at spawn time.
Use [Choosing shared and backend-specific settings](/source/how-to/write_articulation_cfg#choosing-shared-and-backend-specific-settings) to choose configuration overrides for the selected backend.

## Using URDF Importer

For using the URDF importer in the GUI, please check the documentation at [URDF importer](https://docs.isaacsim.omniverse.nvidia.com/latest/importer_exporter/ext_isaacsim_asset_importer_urdf.html). For using the URDF importer from Python scripts, we include a utility tool called `convert_urdf.py`. This script creates an instance of `~sim.converters.UrdfConverterCfg` which
is then passed to the `~sim.converters.UrdfConverter` class.

> **Note**
>
> The URDF importer was upgraded to version 3.0 in Isaac Sim 6, replacing the previous C++
> binding-based API with a Python pipeline (`urdf-usd-converter`). Assets are now made
> instanceable by default — `make_instanceable` is no longer a configuration option.
> See the [/source/migration/migrating_to_isaaclab_3-0](/source/migration/migrating_to_isaaclab_3-0) for a full list of breaking changes.

The URDF importer has various configuration parameters that can be set to control the behavior of the importer.
The default values for the importer's configuration parameters are specified in the `~sim.converters.UrdfConverterCfg` class, and they are listed below. We made a few commonly modified settings to be available as command-line arguments when calling the `convert_urdf.py`, and they are marked with `*` in the list. For a comprehensive list of the configuration parameters, please check the documentation at [URDF importer](https://docs.isaacsim.omniverse.nvidia.com/latest/importer_exporter/ext_isaacsim_asset_importer_urdf.html).

### Articulation and joint structure

* `sim.converters.UrdfConverterCfg.fix_base` \* - Whether to fix the base of the robot.
  This depends on whether you have a floating-base or fixed-base robot. The command-line flag is
  `--fix_base` where when set, the importer will fix the base of the robot, otherwise it will default to floating-base.
* `sim.converters.UrdfConverterCfg.merge_fixed_joints` \* - Whether to merge the fixed joints.
  Usually, this should be set to `True` to reduce the asset complexity. The command-line flag is
  `--merge_joints` where when set, the importer will merge the fixed joints, otherwise it will default to not merging the fixed joints.
* `sim.converters.UrdfConverterCfg.joint_drive` - The configuration for the joint drives on the robot.

  * `sim.converters.UrdfConverterCfg.JointDriveCfg.drive_type` - The drive type for the joints.
    This can be either `"acceleration"` or `"force"`. We recommend using `"force"` for most cases.
  * `sim.converters.UrdfConverterCfg.JointDriveCfg.target_type` - The target type for the joints.
    This can be either `"none"`, `"position"`, or `"velocity"`. We recommend using `"position"` for most cases.
    Setting this to `"none"` will disable the drive and set the joint gains to 0.0.
  * `sim.converters.UrdfConverterCfg.JointDriveCfg.gains` - The drive stiffness and damping gains for the joint.
    We support two ways to set the gains:

    * `sim.converters.UrdfConverterCfg.JointDriveCfg.PDGainsCfg` - To directly set the stiffness and damping.
      Both `stiffness` and `damping` accept a single float (applied uniformly).
    * `sim.converters.UrdfConverterCfg.JointDriveCfg.NaturalFrequencyGainsCfg` - To set the gains using the
      desired natural frequency response of the system. **Deprecated in URDF importer 3.0** — use
      `PDGainsCfg` instead.

### Geometry, collisions, and materials

* `sim.converters.UrdfConverterCfg.collision_from_visuals` - Whether to create collision geometry
  from visual geometry when no explicit `<collision>` is defined for a link. Defaults to `False`.
* `sim.converters.UrdfConverterCfg.collision_type` - The collision shape simplification to apply.
  One of `"Convex Hull"` (default), `"Convex Decomposition"`, `"Bounding Sphere"`, or `"Bounding Cube"`.
* `sim.converters.UrdfConverterCfg.self_collision` - Whether to activate self-collisions between
  links of the articulation. Defaults to `False`.
* `sim.converters.UrdfConverterCfg.merge_mesh` - Whether to merge meshes where possible to optimize
  the model. Defaults to `False`.
* `sim.converters.UrdfConverterCfg.link_density` - Default density in `kg/m^3` for links whose
  `<inertial>` properties are missing. `0.0` (default) leaves densities unchanged.

### Asset resolution and output

* `sim.converters.UrdfConverterCfg.ros_package_paths` - List of ROS package name/path mappings used
  to resolve `package://` URLs in the URDF. Each entry is a dict with keys `name` and `path`.
* `sim.converters.UrdfConverterCfg.robot_type` - Robot type applied by the USD robot schema.
  Defaults to `"Default"`. Must be one of: `"Default"`, `"End Effector"`, `"Manipulator"`,
  `"Humanoid"`, `"Wheeled"`, `"Holonomic"`, `"Quadruped"`, `"Mobile Manipulators"`, `"Aerial"`.
* `sim.converters.UrdfConverterCfg.run_asset_transformer` - Run the asset transformer to convert
  the flattened USD into a layered USD (interface USD + payloads). Defaults to `True`.
* `sim.converters.UrdfConverterCfg.run_multi_physics_conversion` - Also emit MuJoCo-compatible joint
  attributes alongside the PhysX ones, so the asset carries both backends. Defaults to `True`.
  See [Multi-backend assets](/source/how-to/import_new_asset#multi-backend-assets).
* `sim.converters.UrdfConverterCfg.debug_mode` - Write intermediate conversion artifacts next to the
  output USD for inspection. Defaults to `False`.

### Deprecated (no-op in URDF importer 3.0)

The following options are retained for backwards compatibility but are ignored by the URDF importer 3.0.
A warning is logged when they are set.

* `sim.converters.UrdfConverterCfg.root_link_name` - The link on which the PhysX articulation root
  was previously placed.
* `sim.converters.UrdfConverterCfg.convert_mimic_joints_to_normal_joints` - Convert mimic joints to
  normal joints during conversion.
* `sim.converters.UrdfConverterCfg.replace_cylinders_with_capsules` - Replace cylinder shapes with
  capsule shapes during conversion.

For more detailed information on the configuration parameters, please check the documentation for `~sim.converters.UrdfConverterCfg`.

### Example Usage

In this example, we use the pre-processed URDF file of the ANYmal-D robot. To check the
pre-process URDF, please check the file the [anymal.urdf](https://github.com/isaac-orbit/anymal_d_simple_description/blob/master/urdf/anymal.urdf). The main difference between the
pre-processed URDF and the original URDF are:

* We removed the `<gazebo>` tag from the URDF. This tag is not supported by the URDF importer.
* We removed the `<transmission>` tag from the URDF. This tag is not supported by the URDF importer.
* We removed various collision bodies from the URDF to reduce the complexity of the asset.
* We changed all the joint's damping and friction parameters to `0.0`. On PhysX this ensures that we
  can perform effort-control on the joints without the imported drive adding damping of its own. On
  Newton the actuator configuration decides the target mode instead --- see
  [Importing a New Asset](/source/how-to/import_new_asset).
* The `<dont_collapse>` URDF tag is **no longer supported** in URDF importer 3.0. Fixed joint
  merging is now a Python pre-processing step that merges all fixed joints when
  `merge_fixed_joints` is enabled. If you need to preserve a specific fixed joint, disable
  `merge_fixed_joints` entirely or restructure the URDF to use a non-fixed joint type
  (e.g. revolute with zero-range limits).

Map the ROS package directory with `--ros_package_path NAME PATH` so the importer can
resolve the robot's `package://` mesh references, including when fixed joints are merged.

The following shows the steps to clone the repository and run the converter:

#### Linux

```bash
# clone a repository with URDF files
git clone git@github.com:isaac-orbit/anymal_d_simple_description.git

# go to top of the Isaac Lab repository
cd IsaacLab
# run the converter
uv run --extra importers isaaclab -p scripts/tools/convert_urdf.py \
  ../anymal_d_simple_description/urdf/anymal.urdf \
  source/isaaclab_assets/data/Robots/ANYbotics/ \
  --merge_joints \
  --ros_package_path anymal_d_simple_description ../anymal_d_simple_description \
  --joint_stiffness 0.0 \
  --joint_damping 0.0 \
  --joint_target_type none \
  --viz kit
```

#### Windows

```batch
:: clone a repository with URDF files
git clone git@github.com:isaac-orbit/anymal_d_simple_description.git

:: go to top of the Isaac Lab repository
cd IsaacLab
:: run the converter
uv run --extra importers isaaclab -p scripts\tools\convert_urdf.py ^
  ..\anymal_d_simple_description\urdf\anymal.urdf ^
  source\isaaclab_assets\data\Robots\ANYbotics\ ^
  --merge_joints ^
  --ros_package_path anymal_d_simple_description ..\anymal_d_simple_description ^
  --joint_stiffness 0.0 ^
  --joint_damping 0.0 ^
  --joint_target_type none ^
  --viz kit
```

Executing the above script will create a USD file inside the
`source/isaaclab_assets/data/Robots/ANYbotics/anymal/` directory (the subdirectory name
is derived automatically from the robot name in the URDF):

* `anymal.usda` - This is the main asset file.

> **Note**
>
> The URDF importer auto-deduplicates the per-robot subdirectory when it already exists.
> If you re-run the converter against the same `usd_dir` with a changed configuration
> (for example, flipping `fix_base`), the importer writes to a new numbered folder
> (`anymal_1/`, `anymal_2/`, …) rather than overwriting the previous output.
> `sim.converters.UrdfConverter.usd_path` reflects whichever folder the importer
> actually used. Delete stale subdirectories manually (or wipe `usd_dir`) if you do not
> want them to accumulate on disk.

The examples pass `--viz kit` to open the converted asset in the Isaac Sim viewport, which
requires a full Isaac Sim installation. Use `--viz newton_gl`, `--viz rerun`, or `--viz viser`
for a kit-less preview instead. Omit `--viz` to exit as soon as the conversion completes.

Inspect the converted geometry and articulation in the viewer, then validate dynamics in the
intended simulation backend. Check self-collisions, masses, inertias, and actuator gains if
the asset is unstable.

![result of convert\_urdf.py](/isaaclab/_fern-img/8b305f97ee55134120f20227d14811da4988be67eb45663d9a7380066c746745.webp)

## Using MJCF Importer

Similar to the URDF Importer, the MJCF Importer also has a GUI interface. Please check the documentation at
[MJCF importer](https://docs.isaacsim.omniverse.nvidia.com/latest/importer_exporter/ext_isaacsim_asset_importer_mjcf.html) for more details. For using the MJCF importer from Python scripts, we include a utility tool
called `convert_mjcf.py`. This script creates an instance of `~sim.converters.MjcfConverterCfg`
which is then passed to the `~sim.converters.MjcfConverter` class.

The default values for the importer's configuration parameters are specified in the
`~sim.converters.MjcfConverterCfg` class. The configuration parameters are listed below.
We made a few commonly modified settings to be available as command-line arguments when calling the
`convert_mjcf.py`, and they are marked with `*` in the list. For a comprehensive list of the configuration
parameters, please check the documentation at [MJCF importer](https://docs.isaacsim.omniverse.nvidia.com/latest/importer_exporter/ext_isaacsim_asset_importer_mjcf.html).

> **Note**
>
> The MJCF importer was rewritten in Isaac Sim 5.0 to use the `mujoco-usd-converter` library.
> Settings such as `import_sites`, `import_inertia_tensor`, and `make_instanceable` are no
> longer needed — the converter now handles these automatically based on the MJCF file content.

### Geometry, collisions, and materials

* `sim.converters.MjcfConverterCfg.merge_mesh` \* - Whether to merge meshes where possible to
  optimize the model. The command-line flag is `--merge_mesh`.
* `sim.converters.MjcfConverterCfg.collision_from_visuals` \* - Whether to generate collision
  geometry from visual geometries. The command-line flag is `--collision_from_visuals`.
* `sim.converters.MjcfConverterCfg.collision_type` \* - The collision shape simplification to
  apply. One of `"Convex Hull"` (default), `"Convex Decomposition"`, `"Bounding Sphere"`, or
  `"Bounding Cube"`. The command-line flag is `--collision_type`.
* `sim.converters.MjcfConverterCfg.self_collision` \* - Whether to activate self-collisions
  between links of the articulation. The command-line flag is `--self_collision`.

### Articulation and physics

* `sim.converters.MjcfConverterCfg.fix_base` - Whether to add a fixed joint between the world
  and the root rigid-body link. Defaults to `False`.
* `sim.converters.MjcfConverterCfg.link_density` - Default density in `kg/m^3` for links whose
  `<inertial>` properties are missing in the MJCF. `0.0` (default) leaves densities unchanged.
* `sim.converters.MjcfConverterCfg.import_physics_scene` \* - Import physics scene properties
  (gravity, time step, etc.) from the MJCF file. Defaults to `False`. The command-line flag is
  `--import_physics_scene`.

### Actuator overrides

MuJoCo models actuators as an affine transformation `tau = gain @ control + bias`. The following
options override the values parsed from the MJCF on a per-actuator basis. Each defaults to `None`,
which leaves the parsed values unchanged.

* `sim.converters.MjcfConverterCfg.override_gain_type` - The actuator gain type override (e.g.
  `"fixed"`).
* `sim.converters.MjcfConverterCfg.override_bias_type` - The actuator bias type override (e.g.
  `"affine"`).
* `sim.converters.MjcfConverterCfg.override_gain_prm` - The actuator gain parameter array override.
  Example for position control: `[kp, 0, 0, 0, 0, 0, 0, 0, 0, 0]`.
* `sim.converters.MjcfConverterCfg.override_bias_prm` - The actuator bias parameter array override.
  Example for position control: `[0, -kp, -kd, 0, 0, 0, 0, 0, 0, 0]`.

### Asset resolution and output

* `sim.converters.MjcfConverterCfg.robot_type` - Robot type applied by the USD robot schema.
  Defaults to `"Default"`. Must be one of: `"Default"`, `"End Effector"`, `"Manipulator"`,
  `"Humanoid"`, `"Wheeled"`, `"Holonomic"`, `"Quadruped"`, `"Mobile Manipulators"`, `"Aerial"`.
* `sim.converters.MjcfConverterCfg.run_asset_transformer` - Run the asset transformer to convert
  the flattened USD into a layered USD (interface USD + payloads). Defaults to `True`.
* `sim.converters.MjcfConverterCfg.run_multi_physics_conversion` - Convert compatible MuJoCo
  attributes to PhysX attributes (e.g. actuator gains), so the asset carries both backends. Note this
  is the opposite direction to the URDF importer. Defaults to `True`.
  See [Multi-backend assets](/source/how-to/import_new_asset#multi-backend-assets).
* `sim.converters.MjcfConverterCfg.debug_mode` - Write intermediate conversion artifacts next to
  the output USD for inspection. Defaults to `False`.

For more detailed information on the configuration parameters, please check the documentation for `~sim.converters.MjcfConverterCfg`.

### Example Usage

In this example, we use the MuJoCo model of the Unitree's H1 humanoid robot in the [mujoco_menagerie](https://github.com/google-deepmind/mujoco_menagerie/tree/main/unitree_h1).

The following shows the steps to clone the repository and run the converter:

#### Linux

```bash
# clone a repository with MJCF files
git clone git@github.com:google-deepmind/mujoco_menagerie.git

# go to top of the Isaac Lab repository
cd IsaacLab
# run the converter
uv run --extra importers isaaclab -p scripts/tools/convert_mjcf.py \
  ../mujoco_menagerie/unitree_h1/h1.xml \
  source/isaaclab_assets/data/Robots/Unitree/h1.usd \
  --merge_mesh \
  --viz kit
```

#### Windows

```batch
:: clone a repository with MJCF files
git clone git@github.com:google-deepmind/mujoco_menagerie.git

:: go to top of the Isaac Lab repository
cd IsaacLab
:: run the converter
uv run --extra importers isaaclab -p scripts\tools\convert_mjcf.py ^
  ..\mujoco_menagerie\unitree_h1\h1.xml ^
  source\isaaclab_assets\data\Robots\Unitree\h1.usd ^
  --merge_mesh ^
  --viz kit
```

Executing the above script will create the USD file inside the
`source/isaaclab_assets/data/Robots/Unitree/` directory:

* `h1.usd` - This is the converted USD asset file.

> **Note**
>
> The MJCF importer auto-deduplicates the per-robot subdirectory when it already exists,
> matching the URDF importer's behavior. If you re-run the converter against the same
> `usd_dir` with a changed configuration, the importer writes to a new numbered folder
> (`h1_1/`, `h1_2/`, …) rather than overwriting the previous output.
> `sim.converters.MjcfConverter.usd_path` reflects whichever folder the importer
> actually used. Delete stale subdirectories manually (or wipe `usd_dir`) if you do not
> want them to accumulate on disk.

See [Previewing converted assets](/source/how-to/import_new_asset) for the `--viz` options.

![result of convert\_mjcf.py](/isaaclab/_fern-img/2c9a80d82cfb0b2ed64f8c0a6231a6364323db35716513deb16d9405a04c8a97.webp)

## Joint drives on each physics backend

The URDF and MJCF importers write joint drives into the USD. How those drives are then
interpreted depends on the physics backend, and on whether an Isaac Lab actuator configuration
takes over. (Mesh assets have no joints, so none of this applies to them.)

**PhysX** starts from the imported USD drive properties. Isaac Lab's actuator configuration
can override the gains and limits before simulation. The ANYmal example above passes
`--joint_stiffness 0.0 --joint_damping 0.0 --joint_target_type none` so the imported
drive does not add PD effort when the asset is used for effort control.

**Newton** resolves the target mode from the Isaac Lab actuator configuration instead of from the
USD alone. When an articulation uses an Isaac Lab actuator configuration, Newton resolves
each configured joint's target mode before constructing the solver. For an
`~isaaclab.actuators.ImplicitActuatorCfg`, stiffness-only, damping-only,
both-gain, and zero-gain configurations select position, velocity, combined
position/velocity, and effort modes respectively. A gain set to `None` keeps
the corresponding imported USD value. An explicit actuator configuration uses
effort mode because Isaac Lab computes its effort directly.

Joints without an Isaac Lab actuator configuration retain their imported USD settings.
Consequently, an asset with zero-gain USD drives no longer needs
`isaaclab.sim.schemas.JointDrivePropertiesCfg.ensure_drives_exist` solely
to make configured joints actuate in Newton.

The `ensure_drives_exist` option remains useful when a workflow needs to
author placeholder drives independently of an Isaac Lab actuator configuration.
When enabled, it assigns a minimal placeholder stiffness (`1e-3`) to zero-gain
drives before simulation startup so that every drive exists in the imported
model.

## Using Mesh Importer

Omniverse Kit includes the mesh converter tool that uses the ASSIMP library to import assets
from various mesh formats (e.g. OBJ, FBX, STL, glTF, etc.). The asset converter tool is available
as an extension to Omniverse Kit. Please check the [asset converter](https://docs.omniverse.nvidia.com/extensions/latest/ext_asset-converter.html) documentation for more details.
However, unlike Isaac Sim's URDF and MJCF importers, the asset converter tool does not support
creating instanceable assets. This means that the asset will be loaded into memory multiple times
if it is used multiple times in a scene.

Thus, we include a utility tool called `convert_mesh.py` that uses the asset converter tool to
import the asset and then converts it into an instanceable asset. Internally, this script creates
an instance of `~sim.converters.MeshConverterCfg` which is then passed to the
`~sim.converters.MeshConverter` class. Since the mesh file does not contain any physics
information, the configuration class accepts different physics properties (such as mass, collision
shape, etc.) as input. Please check the documentation for `~sim.converters.MeshConverterCfg`
for more details.

### Example Usage

We use an OBJ file of a cube to demonstrate the usage of the mesh converter. The following shows
the steps to clone the repository and run the converter:

#### Linux

```bash
# clone a repository with mesh files
git clone git@github.com:NVIDIA-Omniverse/IsaacGymEnvs.git

# go to top of the Isaac Lab repository
cd IsaacLab
# run the converter
uv run isaaclab -p scripts/tools/convert_mesh.py \
  ../IsaacGymEnvs/assets/trifinger/objects/meshes/cube_multicolor.obj \
  source/isaaclab_assets/data/Props/CubeMultiColor/cube_multicolor.usd \
  --make-instanceable \
  --collision-approximation convexDecomposition \
  --mass 1.0 \
  --viz kit
```

#### Windows

```batch
:: clone a repository with mesh files
git clone git@github.com:NVIDIA-Omniverse/IsaacGymEnvs.git

:: go to top of the Isaac Lab repository
cd IsaacLab
:: run the converter
uv run isaaclab -p scripts\tools\convert_mesh.py ^
  ..\IsaacGymEnvs\assets\trifinger\objects\meshes\cube_multicolor.obj ^
  source\isaaclab_assets\data\Props\CubeMultiColor\cube_multicolor.usd ^
  --make-instanceable ^
  --collision-approximation convexDecomposition ^
  --mass 1.0 ^
  --viz kit
```

The mesh converter requires Isaac Sim. The command writes the converted USD and its
instanceable mesh payload under `source/isaaclab_assets/data/Props/CubeMultiColor/` and opens
the Isaac Sim viewport. Select the asset and press `F` to frame it in the viewport.
Omit `--viz kit` to convert without opening a preview.

* If you do not set the `--mass` flag, then no rigid body properties will be added to the asset.
  It will be imported as a static asset.
* Set `--collision-approximation none` to omit collider properties. The default is
  `convexDecomposition`, so omitting this flag still creates collision geometry.

![result of convert\_mesh.py](/isaaclab/_fern-img/6ff640867e9ab3e75fa5d05cfa91d0c61dda9ce1e3e17c072f8bac855f5654d6.webp)