OmniIsaacGymEnvs

Reinforcement Learning Environments for Omniverse Isaac Gym

1,010

235

1,010

122

View on GitHub

Top Related Projects

IsaacGymEnvs

2,764

Isaac Gym Reinforcement Learning Environments

gym

36,752

A toolkit for developing and comparing reinforcement learning algorithms.

stable-baselines3

12,002

PyTorch version of Stable Baselines, reliable implementations of reinforcement learning algorithms.

The Unity Machine Learning Agents Toolkit (ML-Agents) is an open-source project that enables games and simulations to serve as environments for training intelligent agents using deep reinforcement learning and imitation learning.

football

3,508

Check out the new game server:

dm_control

4,313

Google DeepMind's software stack for physics-based simulation and Reinforcement Learning environments, using MuJoCo.

Quick Overview

OmniIsaacGymEnvs is a set of reinforcement learning environments and tasks built on top of NVIDIA's Isaac Sim and Isaac Gym. It provides a suite of robotics and physics-based environments for training and testing RL algorithms, leveraging the power of GPU-accelerated simulation.

Pros

GPU-accelerated simulation for faster training and experimentation
Diverse set of pre-built environments and tasks for robotics and physics-based RL
Integration with popular RL frameworks like OpenAI Gym
High-fidelity physics simulation using NVIDIA PhysX

Cons

Requires NVIDIA GPU for optimal performance
Limited documentation and community support compared to more established RL libraries
Steep learning curve for users unfamiliar with Isaac Sim or Isaac Gym
Dependency on proprietary NVIDIA software stack

Code Examples

Creating and running a simple environment:

from omniisaacgymenvs.utils.config_utils import load_config, parse_sim_params
from omniisaacgymenvs.utils.task_util import initialize_task

cfg = load_config(task_config="OmniIsaacGymEnvs/omniisaacgymenvs/cfg/task/Cartpole.yaml")
sim_params = parse_sim_params(cfg, "cuda")
env = initialize_task(cfg, sim_params)

obs = env.reset()
for _ in range(1000):
    action = env.action_space.sample()
    obs, reward, done, info = env.step(action)

Accessing environment information:

print(f"Observation space: {env.observation_space}")
print(f"Action space: {env.action_space}")
print(f"Number of environments: {env.num_envs}")

Custom reward function:

def custom_reward_function(self):
    # Access state information
    cart_pos = self.obs_buf[:, 0]
    pole_angle = self.obs_buf[:, 2]
    
    # Calculate custom reward
    reward = 1.0 - torch.abs(cart_pos) - 0.5 * torch.abs(pole_angle)
    return reward

# Override the compute_reward method in your task class
class MyCartpoleTask(CartpoleTask):
    def compute_reward(self):
        return custom_reward_function(self)

Getting Started

Install Isaac Sim following NVIDIA's instructions

Clone the OmniIsaacGymEnvs repository:

git clone https://github.com/NVIDIA-Omniverse/OmniIsaacGymEnvs.git

Install dependencies:
```
cd OmniIsaacGymEnvs
pip install -e .
```

Run an example:

python omniisaacgymenvs/scripts/rlgames_train.py task=Cartpole

Competitor Comparisons

IsaacGymEnvs

2,764

Isaac Gym Reinforcement Learning Environments

Pros of IsaacGymEnvs

Simpler setup and fewer dependencies
Faster simulation speed for certain environments
More established and widely used in research community

Cons of IsaacGymEnvs

Limited to PhysX backend, less flexible for complex simulations
Fewer advanced features compared to OmniIsaacGymEnvs
Less integration with other NVIDIA tools and frameworks

Code Comparison

IsaacGymEnvs:

from isaacgym import gymapi
from isaacgym import gymtorch

gym = gymapi.acquire_gym()
sim = gym.create_sim(0, 0, gymapi.SIM_PHYSX, sim_params)

OmniIsaacGymEnvs:

from omni.isaac.gym.vec_env import VecEnvBase
from omni.isaac.core import World

world = World(stage_units_in_meters=1.0)
env = VecEnvBase(headless=True, enable_livestream=False)

The code snippets show the different initialization approaches. IsaacGymEnvs uses the gymapi directly, while OmniIsaacGymEnvs leverages the Omniverse framework for more advanced simulation capabilities.

OmniIsaacGymEnvs offers a more comprehensive simulation environment with better integration into the NVIDIA ecosystem, but may have a steeper learning curve. IsaacGymEnvs is more straightforward and potentially faster for simpler tasks, but lacks some advanced features and flexibility.

gym

36,752

A toolkit for developing and comparing reinforcement learning algorithms.

Pros of Gym

Widely adopted and supported by the RL community
Simpler to set up and use, with a lower barrier to entry
Extensive documentation and tutorials available

Cons of Gym

Limited to simpler, 2D environments in most cases
Less realistic physics simulation compared to OmniIsaacGymEnvs
Fewer options for complex robotics tasks

Code Comparison

Gym:

import gym
env = gym.make('CartPole-v1')
observation, info = env.reset(seed=42)
for _ in range(1000):
    action = env.action_space.sample()
    observation, reward, terminated, truncated, info = env.step(action)

OmniIsaacGymEnvs:

from omniisaacgymenvs.utils.task_util import initialize_task
env = initialize_task(task_name="Cartpole", num_envs=1, seed=42)
obs = env.reset()
for _ in range(1000):
    action = env.action_space.sample()
    obs, reward, done, info = env.step(action)

Both repositories provide frameworks for reinforcement learning environments, but OmniIsaacGymEnvs offers more advanced simulation capabilities for robotics and 3D environments, while Gym focuses on simplicity and accessibility for a wide range of RL tasks.

stable-baselines3

12,002

PyTorch version of Stable Baselines, reliable implementations of reinforcement learning algorithms.

Pros of stable-baselines3

Broader range of reinforcement learning algorithms
Easier to use and integrate with custom environments
More extensive documentation and community support

Cons of stable-baselines3

Lacks advanced physics simulation capabilities
Not optimized for large-scale, parallel training

Code Comparison

OmniIsaacGymEnvs:

from omniisaacgymenvs.tasks.cartpole import CartpoleTask
from omniisaacgymenvs.utils.config_utils import load_config

cfg = load_config("cfg/task/Cartpole.yaml")
env = CartpoleTask(cfg=cfg)

stable-baselines3:

from stable_baselines3 import PPO
from gym import make

env = make("CartPole-v1")
model = PPO("MlpPolicy", env, verbose=1)
model.learn(total_timesteps=10000)

The code snippets demonstrate the difference in environment setup and training initialization. OmniIsaacGymEnvs focuses on physics-based simulations with YAML configurations, while stable-baselines3 offers a more straightforward approach to working with standard Gym environments and implementing RL algorithms.

ml-agents

18,831

Pros of ml-agents

Easier integration with Unity game engine, allowing for seamless development of AI-powered games and simulations
More extensive documentation and community support, making it accessible for beginners
Supports a wider range of learning algorithms and training methods

Cons of ml-agents

Limited to Unity environment, potentially restricting use in other domains or platforms
May have lower performance for large-scale simulations compared to OmniIsaacGymEnvs

Code Comparison

ml-agents:

from mlagents_envs.environment import UnityEnvironment
from mlagents_envs.side_channel.engine_configuration_channel import EngineConfigurationChannel

channel = EngineConfigurationChannel()
env = UnityEnvironment(file_name="MyEnvironment", side_channels=[channel])

OmniIsaacGymEnvs:

from omniisaacgymenvs.utils.task_util import initialize_task
from omniisaacgymenvs.tasks.cartpole import CartpoleTask

env = initialize_task(task_cfg=CartpoleTask.cfg(), sim_cfg=sim_cfg)

The code snippets show the initialization process for each environment. ml-agents uses a Unity-specific approach, while OmniIsaacGymEnvs utilizes a more generic task initialization method.

football

3,508

Check out the new game server:

Pros of Football

Focuses specifically on soccer/football simulation, providing a more specialized environment for this domain
Offers a lightweight, easy-to-setup environment without requiring powerful hardware
Provides a multi-agent environment out-of-the-box, suitable for team-based reinforcement learning

Cons of Football

Limited to 2D soccer simulation, lacking the visual fidelity and physical accuracy of 3D environments
Less versatile compared to OmniIsaacGymEnvs, which supports a wide range of robotics and physics-based tasks
May have fewer options for customization and extension of the simulation environment

Code Comparison

Football:

env = football_env.create_environment(
    env_name="academy_empty_goal_close",
    stacked=False,
    representation='simple115v2',
    rewards='scoring,checkpoints',
    write_goal_dumps=False,
    write_full_episode_dumps=False,
    render=False,
    number_of_left_players_agent_controls=1,
    number_of_right_players_agent_controls=0
)

OmniIsaacGymEnvs:

env = isaacgym.make(
    seed=0,
    task="Cartpole",
    num_envs=num_envs,
    sim_device="cuda:0",
    rl_device="cuda:0",
    graphics_device_id=0,
    headless=False,
    multi_gpu=False,
    virtual_screen_capture=False,
    force_render=False,
)

dm_control

4,313

Google DeepMind's software stack for physics-based simulation and Reinforcement Learning environments, using MuJoCo.

Pros of dm_control

More established and widely used in research communities
Offers a broader range of environments and tasks
Better documentation and community support

Cons of dm_control

Less realistic physics simulation compared to NVIDIA's PhysX
Limited integration with modern game engines and graphics pipelines
Potentially slower performance for large-scale simulations

Code Comparison

dm_control:

from dm_control import suite
env = suite.load(domain_name="cartpole", task_name="swingup")
timestep = env.reset()
action = env.action_spec().generate_value()
next_timestep = env.step(action)

OmniIsaacGymEnvs:

from omniisaacgymenvs.utils.task_util import initialize_task
env = initialize_task(task_name="Cartpole", num_envs=1)
obs = env.reset()
action = env.action_space.sample()
next_obs, reward, done, info = env.step(action)

Both repositories provide Python APIs for reinforcement learning environments, but OmniIsaacGymEnvs leverages NVIDIA's Isaac Sim platform for more realistic simulations and potential GPU acceleration. dm_control offers a wider variety of pre-built environments, while OmniIsaacGymEnvs focuses on high-fidelity physics and integration with modern rendering techniques.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Omniverse Isaac Gym Reinforcement Learning Environments for Isaac Sim

PLEASE NOTE: Version 4.0.0 will be the last release of OmniIsaacGymEnvs. Moving forward, OmniIsaacGymEnvs will be merging with IsaacLab (https://github.com/isaac-sim/IsaacLab). All future updates will be available as part of the IsaacLab repository.

For tutorials on migrating to IsaacLab, please visit: https://isaac-sim.github.io/IsaacLab/source/migration/migrating_from_omniisaacgymenvs.html.

About this repository

This repository contains Reinforcement Learning examples that can be run with the latest release of Isaac Sim. RL examples are trained using PPO from rl_games library and examples are built on top of Isaac Sim's omni.isaac.core and omni.isaac.gym frameworks.

Please see release notes for the latest updates.

System Requirements

It is recommended to have at least 32GB RAM and a GPU with at least 12GB VRAM. For detailed system requirements, please visit the Isaac Sim System Requirements page. Please refer to the Troubleshooting page for a detailed breakdown of memory consumption.

Installation

Follow the Isaac Sim documentation to install the latest Isaac Sim release.

Examples in this repository rely on features from the most recent Isaac Sim release. Please make sure to update any existing Isaac Sim build to the latest release version, 4.0.0, to ensure examples work as expected.

Once installed, this repository can be used as a python module, omniisaacgymenvs, with the python executable provided in Isaac Sim.

To install omniisaacgymenvs, first clone this repository:

git clone https://github.com/NVIDIA-Omniverse/OmniIsaacGymEnvs.git

Once cloned, locate the python executable in Isaac Sim. By default, this should be python.sh. We will refer to this path as PYTHON_PATH.

To set a PYTHON_PATH variable in the terminal that links to the python executable, we can run a command that resembles the following. Make sure to update the paths to your local path.

For Linux: alias PYTHON_PATH=~/.local/share/ov/pkg/isaac_sim-*/python.sh
For Windows: doskey PYTHON_PATH=C:\Users\user\AppData\Local\ov\pkg\isaac_sim-*\python.bat $*
For IsaacSim Docker: alias PYTHON_PATH=/isaac-sim/python.sh

Install omniisaacgymenvs as a python module for PYTHON_PATH:

PYTHON_PATH -m pip install -e .

The following error may appear during the initial installation. This error is harmless and can be ignored.

ERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.

Running the examples

Note: All commands should be executed from OmniIsaacGymEnvs/omniisaacgymenvs.

To train your first policy, run:

PYTHON_PATH scripts/rlgames_train.py task=Cartpole

An Isaac Sim app window should be launched. Once Isaac Sim initialization completes, the Cartpole scene will be constructed and simulation will start running automatically. The process will terminate once training finishes.

Note that by default, we show a Viewport window with rendering, which slows down training. You can choose to close the Viewport window during training for better performance. The Viewport window can be re-enabled by selecting Window > Viewport from the top menu bar.

To achieve maximum performance, launch training in headless mode as follows:

PYTHON_PATH scripts/rlgames_train.py task=Ant headless=True

A Note on the Startup Time of the Simulation

Some of the examples could take a few minutes to load because the startup time scales based on the number of environments. The startup time will continually be optimized in future releases.

Extension Workflow

The extension workflow provides a simple user interface for creating and launching RL tasks. To launch Isaac Sim for the extension workflow, run:

./<isaac_sim_root>/isaac-sim.gym.sh --ext-folder </parent/directory/to/OIGE>

Note: isaac_sim_root should be located in the same directory as python.sh.

The UI window can be activated from Isaac Examples > RL Examples by navigating the top menu bar. For more details on the extension workflow, please refer to the documentation.

If you are running into an issue where the Isaac Examples menu is missing, please modify OmniIsaacGymEnvs/omniisaacgymenvs/__init__.py as follow to expose the underlying error:

import traceback
try:
    from .extension import RLExtension, get_instance
except Exception:
    print(traceback.format_exc())

In the case of a ModuleNotFoundError for hydra, please check your C:\Users\user\AppData\Roaming\Python\Python310 directory and remove any site-packages directory that may contain the hydra package. Then, re-run the pip install -e . command for OmniIsaacGymEnvs.

Loading trained models // Checkpoints

Checkpoints are saved in the folder runs/EXPERIMENT_NAME/nn where EXPERIMENT_NAME defaults to the task name, but can also be overridden via the experiment argument.

To load a trained checkpoint and continue training, use the checkpoint argument:

PYTHON_PATH scripts/rlgames_train.py task=Ant checkpoint=runs/Ant/nn/Ant.pth

To load a trained checkpoint and only perform inference (no training), pass test=True as an argument, along with the checkpoint name. To avoid rendering overhead, you may also want to run with fewer environments using num_envs=64:

PYTHON_PATH scripts/rlgames_train.py task=Ant checkpoint=runs/Ant/nn/Ant.pth test=True num_envs=64

Note that if there are special characters such as [ or = in the checkpoint names, you will need to escape them and put quotes around the string. For example, checkpoint="runs/Ant/nn/last_Antep\=501rew\[5981.31\].pth"

We provide pre-trained checkpoints on the Nucleus server under Assets/Isaac/4.0/Isaac/Samples/OmniIsaacGymEnvs/Checkpoints. Run the following command to launch inference with pre-trained checkpoint:

Localhost (To set up localhost, please refer to the Isaac Sim installation guide):

PYTHON_PATH scripts/rlgames_train.py task=Ant checkpoint=omniverse://localhost/NVIDIA/Assets/Isaac/4.0/Isaac/Samples/OmniIsaacGymEnvs/Checkpoints/ant.pth test=True num_envs=64

Production server:

PYTHON_PATH scripts/rlgames_train.py task=Ant checkpoint=http://omniverse-content-production.s3-us-west-2.amazonaws.com/Assets/Isaac/4.0/Isaac/Samples/OmniIsaacGymEnvs/Checkpoints/ant.pth test=True num_envs=64

When running with a pre-trained checkpoint for the first time, we will automatically download the checkpoint file to omniisaacgymenvs/checkpoints. For subsequent runs, we will re-use the file that has already been downloaded, and will not overwrite existing checkpoints with the same name in the checkpoints folder.

Runing from Docker

Latest Isaac Sim Docker image can be found on NGC. A utility script is provided at docker/run_docker.sh to help initialize this repository and launch the Isaac Sim docker container. The script can be run with:

./docker/run_docker.sh

Then, training can be launched from the container with:

/isaac-sim/python.sh scripts/rlgames_train.py headless=True task=Ant

To run the Isaac Sim docker with UI, use the following script:

./docker/run_docker_viewer.sh

Then, training can be launched from the container with:

/isaac-sim/python.sh scripts/rlgames_train.py task=Ant

To avoid re-installing OIGE each time a container is launched, we also provide a dockerfile that can be used to build an image with OIGE installed. To build the image, run:

docker build -t isaac-sim-oige -f docker/dockerfile .

Then, start a container with the built image:

./docker/run_dockerfile.sh

Then, training can be launched from the container with:

/isaac-sim/python.sh scripts/rlgames_train.py task=Ant headless=True

Isaac Sim Automator

Cloud instances for AWS, Azure, or GCP can be setup using Isaac Automator.

Livestream

OmniIsaacGymEnvs supports livestream through the Omniverse Streaming Client. To enable this feature, add the commandline argument enable_livestream=True:

PYTHON_PATH scripts/rlgames_train.py task=Ant headless=True enable_livestream=True

Connect from the Omniverse Streaming Client once the SimulationApp has been created. Note that enabling livestream is equivalent to training with the viewer enabled, thus the speed of training/inferencing will decrease compared to running in headless mode.

Training Scripts

All scripts provided in omniisaacgymenvs/scripts can be launched directly with PYTHON_PATH.

To test out a task without RL in the loop, run the random policy script with:

PYTHON_PATH scripts/random_policy.py task=Cartpole

This script will sample random actions from the action space and apply these actions to your task without running any RL policies. Simulation should start automatically after launching the script, and will run indefinitely until terminated.

To run a simple form of PPO from rl_games, use the single-threaded training script:

PYTHON_PATH scripts/rlgames_train.py task=Cartpole

This script creates an instance of the PPO runner in rl_games and automatically launches training and simulation. Once training completes (the total number of iterations have been reached), the script will exit. If running inference with test=True checkpoint=<path/to/checkpoint>, the script will run indefinitely until terminated. Note that this script will have limitations on interaction with the UI.

Configuration and command line arguments

We use Hydra to manage the config.

Common arguments for the training scripts are:

task=TASK - Selects which task to use. Any of AllegroHand, Ant, Anymal, AnymalTerrain, BallBalance, Cartpole, CartpoleCamera, Crazyflie, FactoryTaskNutBoltPick, FactoryTaskNutBoltPlace, FactoryTaskNutBoltScrew, FrankaCabinet, FrankaDeformable, Humanoid, Ingenuity, Quadcopter, ShadowHand, ShadowHandOpenAI_FF, ShadowHandOpenAI_LSTM (these correspond to the config for each environment in the folder omniisaacgymenvs/cfg/task)
train=TRAIN - Selects which training config to use. Will automatically default to the correct config for the environment (ie. <TASK>PPO).
num_envs=NUM_ENVS - Selects the number of environments to use (overriding the default number of environments set in the task config).
seed=SEED - Sets a seed value for randomization, and overrides the default seed in the task config
pipeline=PIPELINE - Which API pipeline to use. Defaults to gpu, can also set to cpu. When using the gpu pipeline, all data stays on the GPU. When using the cpu pipeline, simulation can run on either CPU or GPU, depending on the sim_device setting, but a copy of the data is always made on the CPU at every step.
sim_device=SIM_DEVICE - Device used for physics simulation. Set to gpu (default) to use GPU and to cpu for CPU.
device_id=DEVICE_ID - Device ID for GPU to use for simulation and task. Defaults to 0. This parameter will only be used if simulation runs on GPU.
rl_device=RL_DEVICE - Which device / ID to use for the RL algorithm. Defaults to cuda:0, and follows PyTorch-like device syntax.
multi_gpu=MULTI_GPU - Whether to train using multiple GPUs. Defaults to False. Note that this option is only available with rlgames_train.py.
test=TEST- If set to True, only runs inference on the policy and does not do any training.
checkpoint=CHECKPOINT_PATH - Path to the checkpoint to load for training or testing.
headless=HEADLESS - Whether to run in headless mode.
enable_livestream=ENABLE_LIVESTREAM - Whether to enable Omniverse streaming.
experiment=EXPERIMENT - Sets the name of the experiment.
max_iterations=MAX_ITERATIONS - Sets how many iterations to run for. Reasonable defaults are provided for the provided environments.
warp=WARP - If set to True, launch the task implemented with Warp backend (Note: not all tasks have a Warp implementation).
kit_app=KIT_APP - Specifies the absolute path to the kit app file to be used.
enable_recording=ENABLE_RECORDING - Enables viewport recording while running a task
recording_interval=RECORDING_INTERVAL - Number of RL steps in between recording sequences. By default, recordings happen every 2000 RL steps.
recording_length=RECORDING_LENGTH - Number of RL steps to record for each clip. By default, recordings are 100 steps in length.
recording_fps=RECORDING_FPS - Output FPS of the recorded video. Defaults to 30.
recording_dir=RECORDING_DIR - Directory to save recordings in. Defaults to the experiment directory.

Hydra also allows setting variables inside config files directly as command line arguments. As an example, to set the minibatch size for a rl_games training run, you can use train.params.config.minibatch_size=64. Similarly, variables in task configs can also be set. For example, task.env.episodeLength=100.

Hydra Notes

Default values for each of these are found in the omniisaacgymenvs/cfg/config.yaml file.

The way that the task and train portions of the config works are through the use of config groups. You can learn more about how these work here The actual configs for task are in omniisaacgymenvs/cfg/task/<TASK>.yaml and for train in omniisaacgymenvs/cfg/train/<TASK>PPO.yaml.

In some places in the config you will find other variables referenced (for example, num_actors: ${....task.env.numEnvs}). Each . represents going one level up in the config hierarchy. This is documented fully here.

Tensorboard

Tensorboard can be launched during training via the following command:

PYTHON_PATH -m tensorboard.main --logdir runs/EXPERIMENT_NAME/summaries

WandB support

You can run (WandB)[https://wandb.ai/] with OmniIsaacGymEnvs by setting wandb_activate=True flag from the command line. You can set the group, name, entity, and project for the run by setting the wandb_group, wandb_name, wandb_entity and wandb_project arguments. Make sure you have WandB installed in the Isaac Sim Python executable with PYTHON_PATH -m pip install wandb before activating.

Training with Multiple GPUs

To train with multiple GPUs, use the following command, where --proc_per_node represents the number of available GPUs:

PYTHON_PATH -m torch.distributed.run --nnodes=1 --nproc_per_node=2 scripts/rlgames_train.py headless=True task=Ant multi_gpu=True

Multi-Node Training

To train across multiple nodes/machines, it is required to launch an individual process on each node. For the master node, use the following command, where --proc_per_node represents the number of available GPUs, and --nnodes represents the number of nodes:

PYTHON_PATH -m torch.distributed.run --nproc_per_node=2 --nnodes=2 --node_rank=0 --rdzv_id=123 --rdzv_backend=c10d --rdzv_endpoint=localhost:5555 scripts/rlgames_train.py headless=True task=Ant multi_gpu=True

Note that the port (5555) can be replaced with any other available port.

For non-master nodes, use the following command, replacing --node_rank with the index of each machine:

PYTHON_PATH -m torch.distributed.run --nproc_per_node=2 --nnodes=2 --node_rank=1 --rdzv_id=123 --rdzv_backend=c10d --rdzv_endpoint=ip_of_master_machine:5555 scripts/rlgames_train.py headless=True task=Ant multi_gpu=True

For more details on multi-node training with PyTorch, please visit here. As mentioned in the PyTorch documentation, "multinode training is bottlenecked by inter-node communication latencies". When this latency is high, it is possible multi-node training will perform worse than running on a single node instance.

Tasks

Source code for tasks can be found in omniisaacgymenvs/tasks.

Each task follows the frameworks provided in omni.isaac.core and omni.isaac.gym in Isaac Sim.

Refer to docs/framework/framework.md for how to create your own tasks.

Full details on each of the tasks available can be found in the RL examples documentation.

Demo

We provide an interactable demo based on the AnymalTerrain RL example. In this demo, you can click on any of the ANYmals in the scene to go into third-person mode and manually control the robot with your keyboard as follows:

Up Arrow: Forward linear velocity command
Down Arrow: Backward linear velocity command
Left Arrow: Leftward linear velocity command
Right Arrow: Rightward linear velocity command
Z: Counterclockwise yaw angular velocity command
X: Clockwise yaw angular velocity command
C: Toggles camera view between third-person and scene view while maintaining manual control
ESC: Unselect a selected ANYmal and yields manual control

Launch this demo with the following command. Note that this demo limits the maximum number of ANYmals in the scene to 128.

PYTHON_PATH scripts/rlgames_demo.py task=AnymalTerrain num_envs=64 checkpoint=omniverse://localhost/NVIDIA/Assets/Isaac/4.0/Isaac/Samples/OmniIsaacGymEnvs/Checkpoints/anymal_terrain.pth

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot