Introduction to Isaac Sim and Isaac Lab: Docker Environment Setup + Running Official Samples | NEXTY Electronics, Electronic Components and Semiconductor Trading Company

Introduction

This is a technical column written by the development team at Nexty Electronics.
The development race for physical AI is accelerating worldwide towards its practical application. A key element of this is robot simulation technology, which allows robots to learn in a virtual environment. NVIDIA's Isaac Sim and Isaac Lab are currently among the most noteworthy development platforms in this field.
This guide will show you how to set up Isaac Sim/Isaac Lab using Docker and run a sample. The steps are: "First, view the scene" → "Learn with a quadruped" → "Replace the library" → "Increase the difficulty with a humanoid." The procedure and screens may vary depending on the software version. Please also check the specifications of the environment you are actually using.

What are Isaac Sim and Isaac Lab?

Since they can easily be confused, let's clarify their roles first.

	Isaac Sim	Isaac Lab
role	Physical simulation, rendering, USD scene	Parallel environment, task definition, execution framework for reinforcement learning and imitation learning.
Examples in this article	"A world with robots, floors, and physics"	"A device that learns by lining up thousands of models of that world."
First sample	Sample 1: Jetbot + Franka (no training)	Samples 2-4: Go2/G1 walking learning

Isaac Lab runs on top of Isaac Sim. When you run the Lab's training script, the Sim's physics engine and assets start running internally.

[ホストOSとNVIDIAドライバ]
    ↓
[Dockerコンテナ]
    ↓
[Isaac Sim]  物理・レンダリング・USD
    ↓
[Isaac Lab]  並列環境・タスク定義
    ↓
[RLライブラリ]  RSL-RL / SKRL など

What we will make in this article

We will clarify the roles of Isaac Sim and Isaac Lab, create an environment using Docker, and reproduce the following four things.

1. Sample 1: Controlling multiple robots (Jetbot + Franka) on Isaac Sim
2. Sample 2: Reinforcement learning for walking in a quadruped robot (Unitree Go2)
3. Sample 3: Switching RL libraries while keeping the same task
4. Sample 4: Reinforcement learning of a humanoid robot (Unitree G1) walking on uneven terrain.

The goal is for you to be able to do the next step when you finish reading.

Start the Isaac Lab container in Docker and enter it.
I can explain the difference between "running a scene" in Isaac Sim and "performing reinforcement learning in a parallel environment" in Isaac Lab.
It can learn and reproduce Go2's planar walking and G1's uneven terrain walking, giving you a perspective on choosing an RL library.

Intended audience

This article is intended for the following people:

People interested in robot learning and simulation
For those using Isaac Sim / Isaac Lab for the first time
People who want to run GPU simulations from Docker or Python
People who want to try learning how to walk with quadrupeds or humanoids using official samples.

No prior experience with Isaac is required. However, basic knowledge of Linux (Ubuntu-based), Docker, Python command execution, and Access to machines with NVIDIA GPUs is assumed.

Equipment used

The environment at the time of writing this article is as follows:

OS：Ubuntu 24.04.3 LTS
GPU：NVIDIA GeForce RTX 5090（VRAM 32GB）
NVIDIA driver: 580.126.09
CUDA：13.0
Software: Docker, NVIDIA Container Toolkit, Git, Python 3
GUI verification: Isaac Sim WebRTC Streaming Client

The Isaac Sim WebRTC Streaming Client is a dedicated application that streams the screen of a headless simulator to a host PC in real time for viewing. It does not display a window within the container, allowing only the video and controls to be managed externally. This article's verification will use this client.

We will not install the Isaac Sim binary to the host. Due to heavy dependencies, we will build it in a container. By default, 4096 robots will be controlled simultaneously during walking training. Please ensure you have sufficient VRAM.
Reference: Isaac Sim container installation

Environment Setup: Why Docker?

Reasons to choose Docker

Isaac Sim / Isaac Lab is not just a Python package. It integrates the Omniverse (Kit) core, CUDA, renderer, extensions, PhysX, and training libraries. Installing it directly on your host is likely to result in the following problems:

It conflicts with existing CUDA/PyTorch/drivers.
Unable to fix the version, the reproduction experiment breaks down.
It's difficult to distinguish between machines that "work" and machines that "don't work."

With Docker, there are official images and those included with Isaac Lab.docker/container.pyThe stack can be consolidated. The GPU is passed to the container via the NVIDIA Container Toolkit. Only the driver and Docker remain on the host side; the Python environment is confined within the container.
The container setup procedure is also included in the Isaac Sim installation guide.

1. Install Docker

curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker $USER

dockerAfter adding someone to a group, you will get a permission error unless you log out once.

2. Installing the NVIDIA Container Toolkit

Follow the installation instructions to install the NVIDIA Container Toolkit.

3. Cloning Isaac Lab and starting containers

git clone https://github.com/isaac-sim/IsaacLab.git
cd IsaacLab/
python3 docker/container.py start
python3 docker/container.py enter

startThe initial image acquisition and container creation will take some time. The working directory after startup is/workspace/isaaclabThat's it. All subsequent learning commands will be executed within the container unless otherwise specified.

Sample 1: Adding Multiple Robots (Jetbot + Franka)

This isn't Isaac Lab's reinforcement learning demonstration. It's a demo where we use the Isaac Sim's Python API to create a USD scene, and a Jetbot pushes a red cube and places a Franka arm next to it.
First, we'll confirm that the simulator starts up and the robot moves according to physics. The learning loop, rewards, and parallel environment are not yet introduced.

Place the script

Create the file in the following location within the host or container:

mkdir -p /workspace/isaaclab/scripts/nexty_sample

multi_robot_livestream_demo.pyThe main points are as follows:

SimulationAppThen, start Kit in headless mode and enable the livestream extension.
Place the Nucleus environment, Jetbot, and Franka USD onto the stage.
JetbotArticulationThe speed command is given as follows:
Each time the timeline is played, reset the counter so that the same press action can be repeated.

import argparse
from isaacsim import SimulationApp

parser = argparse.ArgumentParser()
parser.add_argument("--test", default=False, action="store_true")
args, _ = parser.parse_known_args()

CONFIG = {
    "width": 1280,
    "height": 720,
    "window_width": 1920,
    "window_height": 1080,
    "headless": True,
    "hide_ui": False,
    "renderer": "RaytracedLighting",
    "display_options": 3286,
}

kit = SimulationApp(launch_config=CONFIG)

from isaacsim.core.experimental.utils.app import enable_extension
kit.set_setting("/app/window/drawMouse", True)
enable_extension("omni.kit.livestream.app")

# --- シーン構築: 床、Jetbot、赤いキューブ、Franka ---
import isaacsim.core.experimental.utils.stage as stage_utils
import numpy as np
from isaacsim.core.experimental.materials import PreviewSurfaceMaterial
from isaacsim.core.experimental.objects import Cube
from isaacsim.core.experimental.prims import Articulation, GeomPrim, RigidPrim, XformPrim
from isaacsim.storage.native import get_assets_root_path
import omni.timeline

assets_root_path = get_assets_root_path()

stage_utils.add_reference_to_stage(
    usd_path=assets_root_path + "/Isaac/Environments/Grid/default_environment.usd",
    path="/World/ground",
)
stage_utils.add_reference_to_stage(
    usd_path=assets_root_path + "/Isaac/Robots/NVIDIA/Jetbot/jetbot.usd",
    path="/World/Jetbot",
)

visual_material = PreviewSurfaceMaterial("/World/Materials/red")
visual_material.set_input_values("diffuseColor", [1.0, 0.0, 0.0])
cube_shape = Cube(
    paths="/World/Cube",
    positions=np.array([[0.15, 0.0, 0.025]]),
    sizes=[1.0],
    scales=np.array([[0.05, 0.05, 0.05]]),
    reset_xform_op_properties=True,
)
GeomPrim(paths=cube_shape.paths, apply_collision_apis=True)
RigidPrim(paths=cube_shape.paths)
cube_shape.apply_visual_materials(visual_material)

stage_utils.add_reference_to_stage(
    usd_path=assets_root_path + "/Isaac/Robots/FrankaRobotics/FrankaPanda/franka.usd",
    path="/World/Franka",
)
XformPrim("/World/Franka").set_world_poses(positions=np.array([[0.8, -0.5, 0.0]]))

for _ in range(5):
    kit.update()

jetbot = Articulation("/World/Jetbot")
timeline = omni.timeline.get_timeline_interface()

# PLAY（Stop→Play、Reset→Playを含む）のたびに押し動作をやり直す
state = {"step_counter": 0}

def on_timeline_event(event):
    if event.type == int(omni.timeline.TimelineEventType.PLAY):
        state["step_counter"] = 0
        print("[INFO] PLAY detected. Jetbot will push the cube again.")

timeline_event_stream = timeline.get_timeline_event_stream()
timeline_sub = timeline_event_stream.create_subscription_to_pop(on_timeline_event)

timeline.play()

while kit._app.is_running() and not kit.is_exiting():
    kit.update()
    if timeline.is_playing():
        state["step_counter"] += 1
        if state["step_counter"] < 300:
            jetbot.set_dof_velocity_targets([[10.0, 10.0]])
        else:
            jetbot.set_dof_velocity_targets([[0.0, 0.0]])
    if args.test and state["step_counter"] >= 400:
        break
    
kit.close()

Execution and WebRTC connection

Inside the container, run the following command:

isaaclab -p /workspace/isaaclab/scripts/nexty_sample/multi_robot_livestream_demo.py

Install the Isaac Sim WebRTC Streaming Client on the host side.127.0.0.1Connect to it. Once connected, Jetbot will push the cube, and you will see Franka in the background. You can repeat the same action by clicking PLAY in the UI.

If it's working up to this point, the Docker, GPU, and livestream connections are established.

Reinforcement Learning and How to Choose a RL Library

Before moving on to Sample 2 (Go2 walking learning), let's organize the reinforcement learning concepts and the learning libraries that can be called from Isaac Lab.

What is reinforcement learning?

As explained by NVIDIA, reinforcement learning (RL) is a machine learning method in which robots learn behaviors through trial and error in a virtual environment. Desirable behaviors are given high rewards, while undesirable behaviors are given low rewards. Through this iterative process, the policy (control strategy) is gradually improved.

Traditional programming methods cannot fully capture actions like walking and grasping, but by simulating thousands of robots in parallel and collecting experience, learning can be achieved. Isaac Lab runs this physical simulation and reward calculation on a GPU. A comparison of libraries can be found in the Reinforcement Learning Library Comparison.

Item	RL-Games	RSL-RL	SKRL	Stable Baselines3
Main algorithms	PPO, SAC, A2C	PPO, Distillation	Various types (PPO, SAC, TD3, AMP, IPPO, MAPPO, etc.)	Multiple types (PPO, SAC, TD3, DQN, A2C, etc.)
Vectorization Learning	can be	can be	can be	none
Distributed learning	can be	can be	can be	none
ML platform	PyTorch	PyTorch	PyTorch / JAX	PyTorch
Multi-agent	PPO	PPO	PPO + Dedicated Algorithm	External project dependency
document	Small	Small	fulfillment	The most fulfilling
Example from Isaac Lab	many	many	many	few
direction	High throughput, multi-GPU	Legged locomotion	Research use, algorithm replacement	Comparison with Education and Standard Implementation

The following four libraries can be called from Isaac Lab. All of them perform the same role of "receiving observations from the environment, responding with actions, and updating policies with rewards," but they differ in speed, the tasks they can handle, and ease of use.

■ RSL-RL (ETH Zurich Robotic Systems Lab) is a lightweight PPO implementation for legged robots. It trains quickly in official benchmarks and is frequently used in papers and Unitree-based sim-to-real-world examples. Samples 2 and 4 will use this implementation.
■ SKRL is highly modular and supports algorithms other than PPO, as well as JAX. It is suitable for trying out the same Go2 task with different implementations. We will use it in Sample 3.
■ RL-Games is fast, but requires dedicated settings for each task.Isaac-Velocity-Flat-Unitree-Go2-v0The setting was not found, and the execution could not be performed.
■ While Stable Baselines 3 has extensive documentation, it lacks vectorization and distribution, making it difficult to benefit from Isaac Lab's large-scale parallelism.

Installation is only required the first time. We will be using RSL-RL and SKRL this time.

isaaclab -i rsl_rl
isaaclab -i skrl

From now on, Go2 plane walking will only use RSL-RL and SKRL.

Sample 2: Quadruped robot walking learning (RSL-RL)

The task isIsaac-Velocity-Flat-Unitree-Go2-v0The Go2 robots on a plane learn using PPO to follow speed commands (forward/backward and rotation). By default, it controls 4096 robots simultaneously.

study

isaaclab -p scripts/reinforcement_learning/rsl_rl/train.py \
  --task Isaac-Velocity-Flat-Unitree-Go2-v0 \
  --headless \
  --max_iterations 50

For a quick check--max_iterations 50For comparison purposes1000If you want them to walk properly, extend it even further. During learning, iteration, steps per second, each reward item, falls (base_contact) and other similar songs will be played.
If you want to view the learning progress using the GUI:--livestream 2Attach it and connect from the WebRTC client.

What is iteration?

--max_iterationsOne instance of this process is a set of steps where "experience for a certain number of steps is collected from all robots operating simultaneously, and the policy is updated once." In the RSL-RL setting of Go2/G1, there are 24 steps per robot.num_steps_per_env = 24)is.
The total number of steps is given by the following formula:

総ステップ数 = 同時に動かすロボットの数 × 1体あたりのステップ数 × イテレーション数
             = 4096 × 24 × イテレーション数

for example--max_iterations 50Then,4096 × 24 × 50 = 4,915,200This is the number of steps. 1000 iterations is approximately 98.3 million steps, and 7500 iterations is approximately 737 million steps. This conversion will also be included in the execution results from here on.

Playback (video output)

isaaclab -p scripts/reinforcement_learning/rsl_rl/play.py \
  --task Isaac-Velocity-Flat-Unitree-Go2-v0 \
  --num_envs 32 \
  --headless \
  --video \
  --video_length 200

When viewing a specific checkpoint--load_run <run名>Add this. The video is located under each run.videos/It will be saved during playback.--num_envsThis is the number of individuals to display.

Execution result

This is the result of playing the same task, but with only the iteration number changed.

■ Iteration 50 (approximately 4.91 million steps)
Walking has not yet begun. The baby remains standing still and has not fallen.

■ Iterations: 1000 (approximately 98.3 million steps)
They will be able to move on a flat surface. Depending on the command direction, each individual will move in a different direction.

32 units (the commands for movement direction differ for each unit)

・ Only 1 unit available

■ Iterations: 7500 (approximately 737 million steps)
You can walk more steadily. However, as described below, it can also cause energy to be released.

32 units (the commands for movement direction differ for each unit)

・ Only 1 unit available

Note: Values may diverge in RSL-RL.

With the Isaac Lab + RSL-RL combination, the loss and reward diverge after training progresses. As a result, the policy breaks down. Check the value loss, the sharp rise in reward, and the presence of NaNs in TensorBoard.
This helps us decide whether to revert to a previous checkpoint or change libraries. Therefore, we will run the same task with SKRL in the next chapter.
This divergence is a known issue (bug) that can occur when combining Isaac Lab and RSL-RL.

Sample 3: Performing the same quadrupedal task with SKRL

To maintain a consistent comparison framework, we will not change the tasks.Isaac-Velocity-Flat-Unitree-Go2-v0We'll just change the directory of the learning script.

scripts/reinforcement_learning/rsl_rl/train.py
scripts/reinforcement_learning/skrl/train.py

1000 iterations in SKRL

isaaclab -p scripts/reinforcement_learning/skrl/train.py \
  --task Isaac-Velocity-Flat-Unitree-Go2-v0 \
  --headless \
  --max_iterations 1000

Playback is the same as in sample 2.play.pyYes. The pathskrlChange it and execute.

Execution results (comparison after 1000 runs)

	RSL-RL	SKRL
Official settings for this task	can be	can be
Walking after 1000 steps	movable	movable
The situation	When you want to prioritize speed with a leg-powered system	When you want to reinterpret or replace the implementation
This time's notice	Longer study sessions can sometimes lead to divergent thinking.	Warnings were issued, but finishing the race was consistent.

■ RSL-RL (1000 iterations, approximately 98.3 million steps)

■ SKRL (1000 iterations, equivalent to approximately 98.3 million steps)

*RL-Games and SB3 were not used in this task.

Sample 4: Humanoid walking (Unitree G1)

After confirming the path using all fours, it proceeds to uneven terrain using two legs. The task isIsaac-Velocity-Rough-G1-v0This is a speed tracking feature for uneven terrain, designed for [Unitree G1].
The reasons why it's more difficult than quadrupedal are as follows:

■ Few supporting legs. Episodes are likely to end with a fall (body contact).
■ The terrain is rough. Unlike the flat Go2, you need to cross elevation changes.
■ Reward constraints increase. For bipedal animals, the same rewards as for quadrupedal animals are insufficient; penalties for falling and suppression of arm and torso movement are added. Because the number of conditions to be met increases, learning becomes more difficult to converge.

This is an example of overriding on the G1 side (key points of the official task settings).

Heavy penalties for falling (termination_penalty）
Reward for staying airborne for bipedal feet (feet_air_time_positive_biped）
Penalizes deviations from the default posture of the waist, arms, and torso, as well as the limits of the ankle joint.
Lower the success threshold for yaw tracking compared to the four-legged stance.
Base link istorso_linkYes. For bipedal setups, randomization of base mass is disabled.

The range of speed commands is also narrower than that of a four-legged vehicle.0.0〜1.0It is limited to moving forward only; it does not walk sideways. Only turning left and right (yaw) in place is permitted. The design prioritizes walking forward first.

Learning and Reproduction

isaaclab -p scripts/reinforcement_learning/rsl_rl/train.py \
  --task Isaac-Velocity-Rough-G1-v0 \
  --max_iterations 50 \
  --headless

For verification purposes, we will run it 50 times, and then increase the number of runs to several hundred to 2000 times during the actual training. Playback is the same as in Sample 2.--taskofIsaac-Velocity-Rough-G1-v0I will change it to this.

Execution result

Bipedal locomotion training progresses through stages as it iteratives: "flapping → standing → shifting weight → taking a step → smoother gait." (Reference article: G1 RL locomotion training)
1000 steps on all fours to "be able to walk" is different from 1000 steps on two legs on uneven ground. G1 only started to show a proper gait around 2000 steps. It's best not to judge based on short iterations.

■ Iteration 50 (approximately 4.91 million steps)
They collapse without even being able to stand.

■ Iteration 200 (approximately 19.7 million steps)
They are barely able to stand, but it's hard to say they are walking.

■ Iteration 500 (approximately 49.15 million steps)
We can see signs of movement starting from iteration 200.

■ Iterations: 1000 (approximately 98.3 million steps)
You will be able to overcome obstacles and steps.

■ Iterations: 2000 (approximately 197 million steps)
This will result in a form of walking.

■ Iterations: 5000 (approximately 492 million steps)
From the 2000-step mark onwards, the time spent with feet off the ground has increased, and the person is lifting their legs higher when walking.

Conclusion

This article describes how to set up Isaac Lab using Docker, from checking Isaac Sim scenes to learning quadrupedal and humanoid walking.

For the initial installation, Docker + NVIDIA Container Toolkit is the most practical option, as it doesn't clutter the host. Isaac Sim handles the scene and physics, while Isaac Lab focuses on parallel learning on top of that. The API switches between Sample 1 and Sample 2 onwards. For legged robots, RSL-RL is often the first choice. However, make sure the task has an agent setting and that it doesn't diverge during long-term training. Humanoid off-road walking requires more iterations and samples than quadruped robots. Officially, there's also Isaac Lab Mimic, which learns and mimics human movements remotely. This is suitable for arm pick-and-place and humanoid operation demonstrations. The process involves creating a "walkable/grasping" policy using reinforcement learning, and then using human operations as data. The procedure and dataset handling will be covered in a separate article. The official entry point is Teleoperation and Imitation Learning.

If you are interested in robot simulations and reinforcement learning using Isaac Sim or Isaac Lab, please feel free Inquiry.

Introduction to Isaac Sim and Isaac Lab: Setting up a Docker environment and running official samples

Introduction

What are Isaac Sim and Isaac Lab?

What we will make in this article

Intended audience

Equipment used

Environment Setup: Why Docker?

Reasons to choose Docker

1. Install Docker

2. Installing the NVIDIA Container Toolkit

3. Cloning Isaac Lab and starting containers

Sample 1: Adding Multiple Robots (Jetbot + Franka)

Place the script

Execution and WebRTC connection

Reinforcement Learning and How to Choose a RL Library

What is reinforcement learning?

Sample 2: Quadruped robot walking learning (RSL-RL)

study

What is iteration?

Playback (video output)

Execution result

Note: Values may diverge in RSL-RL.

Sample 3: Performing the same quadrupedal task with SKRL

1000 iterations in SKRL

Execution results (comparison after 1000 runs)

Sample 4: Humanoid walking (Unitree G1)

Learning and Reproduction

Execution result

Conclusion

Reference

Inquiry

Link to Related Technical Columns

Related Product Information