g1-dribble-newton

KO | EN

gitlite — search

#large-language-models #codex #generative-ai #computer-vision #ruby #claude #tailwindcss #cli #android #markdown

g1-dribble-newton

(★ 9)

Teaching a Unitree G1 humanoid to dribble a soccer ball with reinforcement learning on NVIDIA Isaac Lab + Newton.

File Explorer

ZIP Download

- g1_dribble_model_900.pt
- - __init__.py
  - rsl_rl_ppo_cfg.py
- - __init__.py
  - dribble.py
- __init__.py
- dribble_env_cfg.py
- training_curve.png
- play.py
- train.py
.gitignore
LICENSE
pyproject.toml
README.md
setup.sh

# Use via CDN

jsDelivr

jsDelivr serves any public GitHub repository as a CDN with zero setup. Pick a version and a file to get a ready-to-paste link and snippet.

Version

File

Link

Example

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

A reinforcement-learning task for **Isaac Lab** where a **Unitree G1 humanoid** learns to walk and
**dribble a soccer ball** — trained end-to-end on the **NVIDIA Newton** physics engine
(MuJoCo-Warp), no motion capture and no scripted footwork. Just a reward function and a GPU.

![Training curve — G1 learning to dribble](https://raw.githubusercontent.com/NMadhub/g1-dribble-newton/main/media/training_curve.png)

> From a 100% fall rate to staying upright ~93% of the episode, while ball control climbs from
> ~0.00 to ~0.40 — in about 30 minutes on a single laptop GPU.

## The idea

This is a [DribbleBot](https://gmargo11.github.io/dribblebot/)-style setup adapted to a biped. It is
built on Isaac Lab's stock `G1FlatEnvCfg`, so it **keeps G1's full locomotion reward** (walk +
balance, including its `-200` fall penalty) and only **adds the ball**:

- the locomotion `base_velocity` command is reused as a *desired ball velocity* (robot/base frame),
- the robot is rewarded for keeping the ball moving at that velocity (`track_ball_vel`) and for
  staying near it (`robot_ball_distance`),
- since the same command drives the robot's own walking, the ball travels with the robot →
  **emergent forward dribbling**.

Piggybacking on the proven walking task makes this far more learnable than rewarding ball-control
alone — a biped has to solve balance first.

## What the curve shows

| Phase | Iterations | What happens |
|---|---|---|
| Faceplant | 0–200 | Falls almost every episode while learning to move |
| Learns to balance | 200–400 | Steep climb — episode length jumps from ~130 to ~930 steps |
| Stays up + dribbles | 400+ | Upright ~93%, ball control plateaus around 0.40 |

The `-200` termination penalty (inherited from G1's locomotion reward) is what keeps "staying
upright" strongly worth it and prevents the policy from learning to fall early to dodge penalties.

## Requirements

- **Isaac Lab `v3.0.0-beta`** paired with **Isaac Sim `6.0`** (developed against `6.0.0-rc`).
- An NVIDIA RTX GPU (developed on an RTX 3500 Ada Laptop, 12 GB).
- The **Newton** backend (selected with the Hydra preset `presets=newton`).

The Unitree G1 asset streams from the Isaac asset server — nothing proprietary is bundled.

## Setup

```bash
export ISAACLAB_PATH=/path/to/IsaacLab          # your Isaac Lab v3.0.0-beta checkout
git clone https://github.com/NMadhub/g1-dribble-newton.git
cd g1-dribble-newton
ISAACLAB_PATH=$ISAACLAB_PATH bash setup.sh       # pins the Newton solver stack + installs the package
```

`setup.sh` pins the tested solver versions (`newton==1.0.0  mujoco==3.5.0  mujoco-warp==3.5.0.2`)
and `pip install -e .` so the Gym tasks register. On **Windows**, use `isaaclab.bat -p` in place of
`./isaaclab.sh -p`.

## Train

```bash
cd "$ISAACLAB_PATH"
./isaaclab.sh -p <repo>/scripts/train.py \
    --task Isaac-Dribble-G1-v0 \
    --headless --num_envs 2048 --max_iterations 1500 presets=newton
```

`presets=newton` is required. Monitor with TensorBoard:
`tensorboard --logdir logs/rsl_rl/g1_dribble` → http://localhost:6006.

## Play / visualize (Newton viewer)

```bash
./isaaclab.sh -p <repo>/scripts/play.py \
    --task Isaac-Dribble-G1-Play-v0 \
    --num_envs 16 presets=newton --viz newton \
    --checkpoint <repo>/checkpoints/g1_dribble_model_900.pt
```

`--viz newton` opens Newton's built-in OpenGL viewer — no RTX/Kit renderer needed. A trained
demo checkpoint (`checkpoints/g1_dribble_model_900.pt`, ~900 iterations) is included so you can
watch it immediately; omit `--checkpoint` to load your own latest run.

## Honest notes

- **The gait is under-trained.** This checkpoint is ~900 iterations / ~30 minutes — enough to
  *balance and dribble*, not enough for a natural gait (clean humanoid gaits usually take several
  thousand iterations). For a crisper result: train a clean walker first
  (`Isaac-Velocity-Flat-G1-v0`), then `--resume` from it and fine-tune with the ball; lower
  `track_ball_vel` weight (1.0 → ~0.5) and bump `feet_air_time`; train 3000+ iterations.
- **Sim 6.0-rc compatibility:** on the release candidate, the PhysX backend and the RTX/Kit
  viewport had issues, which is why this uses Newton + the Newton viewer throughout. If you hit a
  top-level `import fcntl` error on Windows or an `omni.physics.tensors.impl.api` import error,
  those are known Sim-6.0-rc quirks in the Isaac Lab source (guard the `fcntl` import; the tensors
  API lives at `omni.physics.tensors.api`).

## Layout

```
g1-dribble-newton/
├── g1_dribble/
│   ├── dribble_env_cfg.py        # G1DribbleEnvCfg (+ _PLAY), ball scene, rewards, reset
│   ├── mdp/dribble.py            # ball obs, ball-velocity-tracking reward, ball reset
│   ├── agents/rsl_rl_ppo_cfg.py  # PPO runner config (rsl_rl)
│   └── __init__.py               # Gym registration
├── scripts/{train,play}.py       # thin wrappers around Isaac Lab's rsl_rl scripts
├── checkpoints/                  # included demo policy (model_900)
├── media/training_curve.png
└── setup.sh
```

## Credits

Built on [NVIDIA Isaac Lab](https://github.com/isaac-sim/IsaacLab) and the
[Newton](https://developer.nvidia.com/newton-physics) physics engine
(NVIDIA × Google DeepMind × Disney Research), with the Unitree G1 asset. Task design inspired by
MIT's DribbleBot. RL via [rsl_rl](https://github.com/leggedrobotics/rsl_rl).

## License

MIT — see [LICENSE](LICENSE).

g1-dribble-newton

File Explorer

# Use via CDN

Was this content helpful?

Recent Feedback

Download README