Train Robot in the Browser

Imagine you want to teach a robot arm to pick up a box.

You might not be into robotics, but you’ll be surprised how easy it has become to train robots today. NVIDIA provides two main tools to make this easy directly in the browser Isaac Lab and Isaac Sim

Let’s introduce a simple analogy to make the process easier to understand

Fitness Analogy for Isaac Sim + Isaac Lab

• You = the coach
  👉 You write the training plan (Python code in VS Code).

• Isaac Lab = the fitness program
  👉 Defines the exercises, rules, rewards, and penalties (reinforcement learning setup).

• Isaac Sim = the gym
  👉 Provides the equipment, the space, the physics, and the environment for training.

• Brev = the gym membership
  👉 Gives you access to the gym by providing cloud GPUs and infrastructure.

• The Robot (e.g., Franka Panda arm, TurtleBot) = the athlete
  👉 This is who you actually bring into the gym to train and improve.

🤔 Interesting?!

Then, a few details before we start

What is Isaac Sim?

• A 3D robotics simulator built on NVIDIA Omniverse.
• Provides realistic physics, environments, and robot models.
• Includes libraries of ready-made robots (e.g., Franka Panda, UR5, TurtleBot, drones).
• Supports importing your own robots and environments (URDF, USD, FBX, OBJ, CAD).

Think of it as the "gym" where robots live and interact.

What is Isaac Lab?

• A framework for reinforcement learning (RL) that runs on top of Isaac Sim.
• Provides tools to run training loops, collect data, and train policies.
• Automates large-scale robot training experiments.

Think of it as the "fitness program" that gives the robots tasks and tracks their learning.

How Brev fits in

• Brev provides cloud-based environments with GPUs ready to run Isaac Sim & Lab.

Here’s how it works using Isaac Sim + Isaac Lab + Brev

Step 1: Open your browser

You log into Brev.
You launch the Isaac Sim + Lab environment.
Two tabs open:

• VS Code Web → where you write Python code.
• Isaac Sim UI → where you see the 3D world.

Step 2: Load the robot and the world

In VS Code you write the code (APIs may change across releases).
Load a robot arm (e.g., Franka Panda) into the scene
Add a table and a box

In this step we build the environment. Once the training parameters are set, the system starts practicing inside this loop.

# Launch Isaac Lab simulation app
from omni.isaac.lab.app import AppLauncher

# headless=False → UI visible
app_launcher = AppLauncher(headless=False)
simulation_app = app_launcher.app

# Now we can import simulation APIs
from omni.isaac.core import World
from omni.isaac.franka import Franka
from pxr import UsdGeom, Sdf, Gf

# Create the world
world = World()

# 1) Add a robot (Franka Panda)
franka = world.scene.add(Franka(prim_path="/World/Franka", name="franka"))

# 2) Add a ground plane
world.scene.add_default_ground_plane()

# 3) Add a table (cube primitive)
stage = world.stage
table = UsdGeom.Cube.Define(stage, Sdf.Path("/World/Table"))
table.AddTranslateOp().Set(Gf.Vec3f(0.6, 0.0, 0.75))
table.AddScaleOp().Set(Gf.Vec3f(1.0, 0.8, 0.05))

# 4) Add a box on top of the table
box = UsdGeom.Cube.Define(stage, Sdf.Path("/World/Box"))
box.AddTranslateOp().Set(Gf.Vec3f(0.6, 0.0, 0.80))
box.AddScaleOp().Set(Gf.Vec3f(0.07, 0.07, 0.07))

# Reset and start sim
# Initializes the world → places all objects (robot, table, box) at their start positions, resets physics and sensors, and gets the simulation ready at time = 0.
world.reset()

# Keeps the app alive. Without it, the program would end immediately and the scene would disappear.
# Runs one simulation step:
#    •    physics update (forces, collisions, motions),
#    •    rendering update (draws the frame in the UI),
#    •    tasks/rewards update (if defined).
while simulation_app.is_running():
    world.step(render=True)

Now in the Isaac Sim UI tab, you see: A robot arm, a table, and a box.

Step 3: Train with Isaac Lab

Connecting Isaac Lab (RL framework)

👉 What it means
In your Python script, you don’t just build the scene in Isaac Sim —
you also set up a training pipeline in Isaac Lab.

Core parts of training

1. Define or load a Task

   • Describes the robot, the environment, the observations (what the robot “sees”), the actions it can take, and the reward rules.
   • Example: Pick-and-Place with Franka arm.

2. Attach a Trainer / Algorithm

   • The reinforcement learning engine (e.g., PPO, SAC).
   • Runs episodes, collects rewards, and updates the robot’s policy.

👉 In short: you link your simulation (Isaac Sim) with the training framework (Isaac Lab) by choosing/defining a Task and attaching it to a Trainer that drives the learning loop.

How training looks in practice

The robot arm runs thousands of episodes in simulation:

• Try to move toward the box.
• Fail, adjust.
• Try again.

Because this is simulation, it happens much faster than in real life.
You can train for hundreds of hours in just a few hours of GPU time.

Stop conditions

In practice, you also define when training should end:

• Stop after a fixed number of steps or episodes.
• Stop once the robot reaches a target success rate or reward.

Scenarios

You can either:

• Write your own training scenario → define the task, reward functions, and policy logic yourself.
• Use a standard scenario from Isaac Lab → many common robotics tasks (pick-and-place, navigation, locomotion) are already available as templates.

ℹ️ Think of Isaac Lab as an SDK/library for robot training:

• It provides reusable components.
• You can customize everything if you need to.

ℹ️ The initialization of training (defining tasks, rewards, policy setup) can happen before the simulation loop starts, right after building the scene in Step 2. The loop then continuously executes the training process.

How long does the loop run?

The simulation loop (while app.is_running():) is theoretically infinite —
it only stops when you close the app or explicitly end it.

That means you usually decide two things: 1. How long to train → for example, 10,000 steps or 3 hours. 2. When to stop → for example, when the robot reaches a certain performance (like it can pick up the box 90% of the time).

So: • The loop itself is endless. • Training ends when you set a limit.

Step 4: Observe results

In the Isaac Sim UI you see the robot improving:

• At first it misses the box.
• Later it learns to reach it.
• Eventually it lifts the box correctly.

You can observe results in two main places:

1. Isaac Sim UI (visual feedback)

   • Watch the robot in 3D: movements get smoother, failures become rarer, the arm eventually succeeds.

2. Training logs and metrics (numerical feedback)

   • Reward curves show how performance improves over time.
   • Success rates (% of episodes completed) increase.
   • Loss values from the learning algorithm decrease.

Together, this gives you both a visual impression (seeing the robot behave)
and quantitative evidence (metrics showing the learning progress).

Step 5: Save your work

You export the trained scene as a .usd file.
You save the trained model (policy weights).
Now you can re-load it any time or deploy it to a real robot.

Where does this happen?

1. Scene files (.usd)

   • Saved inside the Isaac Sim environment.
   • You can do this directly from the Isaac Sim UI (menu: File → Save),
     or via script (stage.Export("scene.usd")).

2. Training results (policy weights, logs)

   • Saved in your Brev workspace (the web-based VS Code environment).
   • Typically appears as files like policy.pt or checkpoints/.
   • You can commit them to GitHub/GitLab from the web IDE,
     or download them to your local machine.

⚠️ Important: If you don’t save to your Brev workspace (or sync with Git),
your changes can be lost when the cloud container shuts down.

Workflow

1. Open your browser and log into Brev.
2. Launch the preconfigured Isaac Sim + Lab environment.
3. Start two browser tabs:
   • VS Code Web → to write code.
   • Isaac Sim UI → to visualize the world.
4. Load a standard warehouse world in Isaac Sim.
5. Import a standard Franka Panda robot arm from the Isaac library.
6. Write a simple Python script in VS Code to control the arm.
7. Connect Isaac Lab to the simulation.
8. Define a training task: the arm must pick up a box from the shelf.
9. Set reward rules:
   • +1 when the robot moves closer to the box.
   • +10 when the box is successfully lifted.
   • -1 when the arm collides with the shelf.
10. Run thousands of training episodes in Isaac Lab.
11. Simulate robot behavior in Isaac Sim during each episode.
12. Use Brev’s GPU power in the cloud to accelerate physics and AI training.
13. Observe the learning curve: the robot improves over time.
14. Save the trained simulation as a .usd scene file.
15. Export the trained policy (model weights) for later use.
16. Reload the saved scene or policy whenever needed.

Account requirements

• You need a Brev account to run Isaac Sim in the cloud. Brev manages GPU resources and the launchable environment.
• Without Brev:
  • You can still run Isaac Sim locally (requires a powerful NVIDIA GPU + Omniverse Launcher).
  • But setup is more complex compared to the cloud option.

This README explains in simple terms how Isaac Sim and Isaac Lab work in the cloud using Brev.