Merge pull request #2981 from madeline-underwood/robots

Robots_reviewed

Author: pareenaverma

content/learning-paths/laptops-and-desktops/dgx_spark_isaac_robotics/1_introduction_isaac.md

@@ -8,7 +8,7 @@ layout: learningpathall
 
 ## Overview
 
-In this Learning Path, you will build, configure, and run robotic simulation and [reinforcement learning (RL)](https://en.wikipedia.org/wiki/Reinforcement_learning) workflows using NVIDIA Isaac Sim and Isaac Lab on an Arm-based DGX Spark system. The NVIDIA DGX Spark is a personal AI supercomputer powered by the GB10 [Grace Blackwell](https://learn.arm.com/learning-paths/laptops-and-desktops/dgx_spark_llamacpp/1_gb10_introduction/) Superchip. The system couples an Arm CPU cluster with a Blackwell GPU and a unified memory architecture to accelerate simulation orchestration, sensor preprocessing, physics, rendering, and RL training.
+In this Learning Path, you'll build, configure, and run robotic simulation and [reinforcement learning (RL)](https://en.wikipedia.org/wiki/Reinforcement_learning) workflows using NVIDIA Isaac Sim and Isaac Lab on an Arm-based DGX Spark system. The NVIDIA DGX Spark is a personal AI supercomputer powered by the GB10 [Grace Blackwell](https://learn.arm.com/learning-paths/laptops-and-desktops/dgx_spark_llamacpp/1_gb10_introduction/) Superchip. The system couples an Arm CPU cluster with a Blackwell GPU and a unified memory architecture to accelerate simulation orchestration, sensor preprocessing, physics, rendering, and RL training.
 
 NVIDIA's Isaac Sim and Isaac Lab tools together provide an end-to-end robotics development workflow:
   1. Simulate robots in physically realistic environments.
@@ -106,13 +106,22 @@ You can also filter environments by keyword. For example, to list locomotion env
 
 For the complete list of environments, see the [Isaac Lab Available Environments](https://isaac-sim.github.io/IsaacLab/main/source/overview/environments.html) documentation.
 
-## What you will accomplish in this Learning Path
+## What you'll build
 
-In this Learning Path you will:
+In this Learning Path, you'll:
 
-1. **Set up Isaac Sim and Isaac Lab** on your DGX Spark by building both tools from source
-2. **Run a basic robot simulation** in Isaac Sim and interact with it through Python
-3. **Train a reinforcement learning policy** for the Unitree H1 humanoid robot on rough terrain using RSL-RL
-4. **Explore additional RL environments** to understand how the workflow generalizes to other robots and tasks.
+1. Set up Isaac Sim and Isaac Lab on your DGX Spark by building both tools from source
+2. Run a basic robot simulation in Isaac Sim and interact with it through Python
+3. Train a reinforcement learning policy for the Unitree H1 humanoid robot on rough terrain using RSL-RL
+4. Explore additional RL environments to understand how the workflow generalizes to other robots and tasks
 
-By the end of the Learning Path, you will have a working Isaac Sim and Isaac Lab development environment on DGX Spark and practical experience running a complete robotics reinforcement learning pipeline.
+By the end, you'll have a working Isaac Sim and Isaac Lab development environment on DGX Spark and practical experience running a complete robotics reinforcement learning pipeline.
+
+## What you've learned and what's next
+
+In this section:
+- You learned what Isaac Sim and Isaac Lab are and how they work together for robotics development
+- You discovered why DGX Spark's unified memory architecture is ideal for simulation and RL training
+- You explored the available environment categories for different robotics tasks
+
+In the next section, you'll set up your development environment and install Isaac Sim and Isaac Lab on your DGX Spark system.

content/learning-paths/laptops-and-desktops/dgx_spark_isaac_robotics/2_isaac_installation.md

@@ -8,17 +8,17 @@ layout: learningpathall
 
 ## Set up your development environment
 
-Before running robotic simulations and reinforcement learning workloads, you need to prepare your DGX Spark development environment and install the dependencies required for Isaac Sim and Isaac Lab.
+Before you run robotic simulations and reinforcement learning workloads, you need to prepare your DGX Spark development environment and install the dependencies required for Isaac Sim and Isaac Lab.
 
-In this section you will:
+In this section you'll:
   * Verify the DGX Spark system configuration
   * Install required build dependencies
   * Build and configure Isaac Sim
   * Set up Isaac Lab on top of the Isaac Sim environment
 
 The full setup typically takes 15–20 minutes on a DGX Spark system and requires approximately 50 GB of available disk space.
 
-## Step 1: Verify your system
+## Step 1: Verify your DGX Spark system
 
 Begin by confirming that the DGX Spark system has the expected hardware and software configuration.
 
@@ -37,7 +37,7 @@ Architecture:             aarch64
 CPU(s):                   20
   On-line CPU(s) list:    0-19
 ```
-The Architecture field should report aarch64, indicating that the system is running on Arm.
+The Architecture field should report `aarch64`, indicating that the system is running on Arm.
 
 Check that the Blackwell GPU is detected by the NVIDIA driver:
 
@@ -70,9 +70,7 @@ The expected output includes:
 Cuda compilation tools, release 13.0, V13.0.88
 ```
 
-{{% notice Note %}}
-Isaac Sim requires GCC/G++ 11, Git LFS, and CUDA 13.0 or later. If any of these checks fail, resolve the issue before proceeding.
-{{% /notice %}}
+{{% notice Note %}}Isaac Sim requires GCC/G++ 11, Git LFS, and CUDA 13.0 or later. If any of these checks fail, resolve the issue before you proceed.{{% /notice %}}
 
 ## Step 2: Install GCC 11 and Git LFS
 
@@ -82,7 +80,8 @@ Update the package index and install the GCC 11 toolchain:
 ```bash
 sudo apt update && sudo apt install -y gcc-11 g++-11
 ```
-Register GCC 11 as the default compiler using update-alternatives. This allows multiple compiler versions to coexist while prioritizing GCC 11 for builds:
+
+Register GCC 11 as the default compiler using `update-alternatives`. This allows multiple compiler versions to coexist while prioritizing GCC 11 for builds. The priority value of 200 ensures GCC 11 takes precedence over other installed versions:
 ```bash
 sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-11 200
 sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-11 200
@@ -120,9 +119,7 @@ git lfs install
 git lfs pull
 ```
 
-{{% notice Note %}}
-The Git LFS download retrieves several gigabytes of simulation assets. Ensure you have a stable internet connection and sufficient disk space before running this step.
-{{% /notice %}}
+{{% notice Note %}}The Git LFS download retrieves several gigabytes of simulation assets. Ensure you have a stable internet connection and sufficient disk space before you run this step.{{% /notice %}}
 
 Once the repository and assets are downloaded, build Isaac Sim using the provided build script:
 
@@ -166,7 +163,7 @@ After this step, the variables will be available automatically whenever you open
 
 {{% /notice %}}
 
-## Step 5: Validate the Isaac Sim build
+## Step 5: Validate your Isaac Sim build
 
 Launch Isaac Sim to verify the build was successful. On some aarch64 systems, Isaac Sim may require preloading the GNU OpenMP runtime (libgomp) to avoid library compatibility issues. Setting the LD_PRELOAD environment variable ensures the correct library is loaded before Isaac Sim starts.
 
@@ -244,11 +241,11 @@ Isaac-Reach-Franka-v0
 
 If the environment list displays without errors, both Isaac Sim and Isaac Lab are correctly installed and ready for use.
 
-You are now ready to run and train RL tasks using Isaac Lab environments.
+You're now ready to run and train RL tasks using Isaac Lab environments.
 
-## What you have accomplished
+## What you've learned and what's next
 
-In this section you have:
+In this section you've:
 
 - Verified your DGX Spark system has the required Grace CPU, Blackwell GPU, and CUDA 13 environment
 - Installed GCC 11 and Git LFS as build prerequisites
@@ -257,4 +254,4 @@ In this section you have:
 - Cloned and installed Isaac Lab with all RL library dependencies
 - Validated both installations by launching Isaac Sim and listing available environments
 
-Your development environment is now fully configured for robot simulation and RL workflows. In the next section, you will run your first robot simulation and begin interacting with Isaac Sim through Python scripts.
+Your development environment is now fully configured for robot simulation and RL workflows. In the next section, you'll run your first robot simulation and begin interacting with Isaac Sim through Python scripts.

content/learning-paths/laptops-and-desktops/dgx_spark_isaac_robotics/3_isaac_small_project.md

@@ -8,7 +8,7 @@ layout: learningpathall
 
 ## Deploy a basic robot simulation
 
-With Isaac Sim and Isaac Lab installed, you can now run your first robot simulation. In this section you will launch a pre-built simulation scene, interact with it programmatically, and explore the key concepts behind Isaac Sim's simulation loop.
+With Isaac Sim and Isaac Lab installed, you can now run your first robot simulation. In this section you'll launch a pre-built simulation scene, interact with it programmatically, and explore the key concepts behind Isaac Sim's simulation loop.
 
 The example environment used here is Cartpole, a classic control benchmark in which a cart must balance an upright pole by applying horizontal forces. Although simple, this environment demonstrates the core mechanics of simulation environments used in robotics and reinforcement learning.
 
@@ -30,9 +30,8 @@ Press `Ctrl+C` to exit the simulation.
 
 ## Step 2: Spawn and simulate a robot
 
-Next, run a tutorial that loads an articulated robot into the simulation and advances the physics engine.
-This example demonstrates how Isaac Sim handles multi-body dynamics, including loading robot assets, configuring actuators, and stepping the physics simulation.
-Run the following command:
+Next, run a tutorial that loads an articulated robot into the simulation and advances the physics engine. This example demonstrates how Isaac Sim handles multi-body dynamics, including loading robot assets, configuring actuators, and stepping the physics simulation.
+
 ```bash
 ./isaaclab.sh -p scripts/tutorials/01_assets/run_articulation.py
 ```
@@ -43,7 +42,7 @@ This script loads a robot model, advances the physics simulation, and prints joi
 - Configuring joint actuators and control modes
 - Stepping the physics simulation and reading back joint positions and velocities
 
-![img1 alt-text#center](run_articulation.gif "Figure 1: run_articulation.py")
+![img1 alt-text#center](run_articulation.gif "run_articulation.py")
 
 ## Step 3: Run the Cartpole environment
 
@@ -56,17 +55,18 @@ Run the following command:
 ./isaaclab.sh -p scripts/tutorials/03_envs/create_cartpole_base_env.py --num_envs 32
 ```
 
-This command launches 32 parallel Cartpole environments on the Blackwell GPU. Each environment runs its own independent simulation with random joint efforts applied to the cart. You will see the pole joint angle printed to the terminal for each step.
+This command launches 32 parallel Cartpole environments on the Blackwell GPU. Each environment runs its own independent simulation with random joint efforts applied to the cart. You'll see the pole joint angle printed to the terminal for each step.
 
-![img2 alt-text#center](32_cartpole.gif "Figure 2: 32 parallel Cartpole")
+![img2 alt-text#center](32_cartpole.gif "32 parallel Cartpole")
 
 {{% notice Note %}}
 This tutorial script uses a hardcoded `CartpoleEnvCfg` configuration. It does not accept a `--task` argument. The `--num_envs` flag controls how many parallel environments are spawned on the GPU.
 {{% /notice %}}
 
 ## Step 4: Run the Cartpole RL environment
 
-The previous tutorial created a base simulation environment that advances physics and applies actions but does not include reinforcement learning components such as rewards or episode termination.
+The previous tutorial created a base simulation environment that advances physics and applies actions but doesn't include reinforcement learning components such as rewards or episode termination.
+
 To run the full reinforcement learning version of the environment, execute the following command:
 
 ```bash
@@ -206,7 +206,7 @@ Each call to `env.step(action)` performs these operations on the GPU:
 
 All computations happen in parallel across all environments using PyTorch tensors on the GPU. This is what makes Isaac Lab efficient: thousands of environments run in parallel without Python loop overhead.
 
-## Step 6: Run with headless mode
+## Step 6: Run in headless mode
 
 For reinforcement learning workflows, it is common to run Isaac Sim without rendering. Disabling the viewer allows more GPU resources to be used for physics simulation and neural network computation.
 
@@ -221,9 +221,9 @@ In headless mode, all GPU resources are dedicated to physics simulation and tens
 When running headless on DGX Spark, the Blackwell GPU handles both the physics simulation and neural network computation. The unified memory architecture means there is no performance penalty for sharing GPU memory between these workloads.
 {{% /notice %}}
 
-## What you have accomplished
+## What you've learned and what's next
 
-In this section you have:
+In this section you've:
 
 - Launched your first Isaac Sim scene on DGX Spark and verified the rendering and physics engines work correctly
 - Spawned articulated robots and observed multi-body physics simulation
@@ -232,4 +232,5 @@ In this section you have:
 - Tested headless mode for maximum training performance
 
 You now understand the core components of an Isaac Lab simulation environment, including scene creation, robot articulation, observation and action structures, and simulation loop execution.
-In the next section, you will use these concepts to train a reinforcement learning policy for a humanoid robot.
+
+In the next section, you'll use these concepts to train a reinforcement learning policy for a humanoid robot.

content/learning-paths/laptops-and-desktops/dgx_spark_isaac_robotics/4_isaac_rfl.md

@@ -8,7 +8,7 @@ layout: learningpathall
 
 ## Train a reinforcement learning policy using Isaac Lab and RSL-RL
 
-In this section you will train a reinforcement learning (RL) policy for the [Unitree] (https://www.unitree.com/) H1 humanoid robot to walk over rough terrain. The training workflow uses Isaac Lab’s integration with the RSL-RL library, which implements the Proximal Policy Optimization (PPO) algorithm. This integration connects Isaac Sim’s physics simulation with an efficient RL training pipeline. By the end of this section you will understand the key stages of the RL training pipeline, including:
+In this section you'll train a reinforcement learning (RL) policy for the [Unitree](https://www.unitree.com/) H1 humanoid robot to walk over rough terrain. The training workflow uses Isaac Lab’s integration with the RSL-RL library, which implements the Proximal Policy Optimization (PPO) algorithm. This integration connects Isaac Sim’s physics simulation with an efficient RL training pipeline. By the end of this section you'll understand the key stages of the RL training pipeline, including:
   * Task configuration and environment selection
   * PPO training parameters and rollout collection
   * Monitoring training progress
@@ -26,7 +26,8 @@ RSL-RL (Robotic Systems Lab Reinforcement Learning) is a lightweight RL library
 Isaac Lab includes ready-to-use training scripts for RSL-RL under `scripts/reinforcement_learning/rsl_rl/`.
 
 ## Step 1: Understand the training task
-In this section you will train the **Isaac-Velocity-Rough-H1-v0** environment. This is a locomotion task where the [Unitree H1](https://www.unitree.com/h1/) humanoid robot must track a velocity command while navigating rough terrain.
+
+In this section you'll train the **Isaac-Velocity-Rough-H1-v0** environment. This is a locomotion task where the [Unitree H1](https://www.unitree.com/h1/) humanoid robot must track a velocity command while navigating rough terrain.
 
 The task details are:
 
@@ -58,6 +59,7 @@ export LD_PRELOAD="$LD_PRELOAD:/lib/aarch64-linux-gnu/libgomp.so.1"
 ```
 
 Once training begins, the terminal displays iteration progress, reward statistics, and performance metrics.
+
 Example output:
 ```output
                        Learning iteration 15/3000                       
@@ -118,8 +120,10 @@ This error occurs because the NVRTC runtime compiler inside PyTorch does not yet
 Support for Blackwell GPUs is expected to improve in upcoming PyTorch and Isaac Sim releases.
 {{% /notice %}}
 
-### Adjusting training parameters
-You can also override default parameters from the command line:
+### Adjust training parameters
+
+You can also override default parameters from the command line.
+
 For example:
 ```bash
 ./isaaclab.sh -p scripts/reinforcement_learning/rsl_rl/train.py \
@@ -186,8 +190,8 @@ PPO (Proximal Policy Optimization) is the RL algorithm used by RSL-RL. Understan
 | `save_interval` | `50` | Save a model checkpoint every N iterations. Useful for resuming training or evaluating intermediate policies |
 
 ### How the hyperparameters interact
-During training, each iteration collects experience from all parallel environments.
-The total batch size per iteration is:
+
+During training, each iteration collects experience from all parallel environments. The total batch size per iteration is:
 ```
 batch_size = num_envs × num_steps_per_env
 ```
@@ -273,25 +277,25 @@ This progression—from falling to stable walking—demonstrates how PPO gradual
 
 The following visualizations compare two training stages using `num_envs=512`, showcasing the benefit of large-scale parallel training on DGX Spark.
 
-*** Iteration 50 (Early Stage, num_envs=512) ***
+**Iteration 50 (Early Stage, num_envs=512)**
 
 At iteration 50, the policy is still in its exploration phase. Most robots exhibit noisy joint actions, lack coordination, and frequently fall. There is no observable response to the velocity command, and no stable gait has emerged.
 
-![img3 alt-text#center](isaaclab_h1_512_0050.gif "Figure 3: Early Stage")
+![img3 alt-text#center](isaaclab_h1_512_0050.gif "Early Stage")
 
-*** Iteration 1350 (Late Stage, num_envs=512) ***
+**Iteration 1350 (Late Stage, num_envs=512)**
 
 By iteration 1350, the policy has matured. Most robots demonstrate coordinated walking behavior, balance maintenance, and accurate velocity tracking, even on rough terrain. The improvement in foot placement and heading stability is clearly visible.
 
-![img4 alt-text#center](isaaclab_h1_512_1350.gif "Figure 4: Late Stage")
+![img4 alt-text#center](isaaclab_h1_512_1350.gif "Late Stage")
 
-## What you have accomplished
+## What you've learned
 
-In this module, you have:
+In this section, you've:
 
 - Trained a reinforcement learning policy for the Unitree H1 humanoid robot using RSL-RL and the PPO algorithm
 - Understood key hyperparameters in the training pipeline, including policy architecture, rollout strategy, and PPO optimization settings
 - Monitored training progress using reward curves, episode statistics, and performance metrics
 - Evaluated the trained policy through interactive visualization and behavior analysis
 
-You have now completed the end-to-end workflow of training and validating a reinforcement learning policy for humanoid locomotion on DGX Spark.
+You've now completed the end-to-end workflow of training and validating a reinforcement learning policy for humanoid locomotion on DGX Spark.

content/learning-paths/laptops-and-desktops/dgx_spark_isaac_robotics/_index.md

@@ -4,10 +4,10 @@ title: Build Robot Simulation and Reinforcement Learning Workflows with Isaac Si
 draft: true
 cascade:
     draft: true
-    
+
 minutes_to_complete: 90
 
-who_is_this_for: This learning path is intended for robotics developers, simulation engineers, and AI researchers who want to run high-fidelity robotic simulations and reinforcement learning (RL) pipelines using NVIDIA Isaac Sim and Isaac Lab on Arm-based NVIDIA DGX Spark system powered by the Grace–Blackwell (GB10) architecture.
+who_is_this_for: This is an advanced topic for robotics developers, simulation engineers, and AI researchers who want to run high-fidelity robotic simulations and reinforcement learning (RL) pipelines using NVIDIA Isaac Sim and Isaac Lab on Arm-based NVIDIA DGX Spark system powered by the Grace–Blackwell (GB10) architecture.
 
 learning_objectives:
     - Describe the roles of Isaac Sim and Isaac Lab within a robotics simulation and RL pipeline