compareeHub

ONE CAMERA, ONE BRAIN — AND THIS ROBOT DOG TAUGHT ITSELF PARKOUR

A robot dog that jumps gaps twice its body length and lands a handstand — trained entirely in simulation, deployed with one front depth camera.

by Xuanxin Chen, Deepak Pathak lab (CMU)

FULL CAD BOM FIRMWARE DOCS

RoboticsAI

difficulty
●●●●●
time
weeks
license
BSD-3-Clause
repo
repo ACTIVE1,142 stars

WHAT YOU’LL NEED

  • Dev board / microcontroller — runs the project firmware
  • Soldering kit + basic tools — one-time buy, serves every future build

Partner

Run your scrapers in the cloud — This build needs data collection that runs 24/7. Apify's free plan includes $5 in credits every month — no card needed.Try Apify free
1

COMPAREE VERDICT

Extreme Parkour is a research reproduction from Carnegie Mellon's Deepak Pathak lab that trains a quadruped to navigate obstacle courses using only a single front-facing depth camera. The policy is trained entirely in Isaac Gym simulation and then deployed to a real Unitree A1 or Go1. The results are dramatic — the robot clears gaps twice its body length, leaps onto tall boxes, and even lands a handstand — but this is not a weekend kit. You need to already own a Unitree quadruped (dollars 10 dollarsk–20 dollarsk used, depending on model and condition), have access to a GPU cluster for training (or accept multi-day runs on a workstation), and be fluent in Isaac Gym, ROS, and the Unitree SDK. The repository provides the training loop, the deployment stack, and a pre-trained checkpoint, but no hardware guide, no troubleshooting for real-world edge cases, and no hand-holding. The single biggest trap is underestimating the iteration required to tune sim-to-real parameters for your specific environment — the paper's results came after months of iteration, and your floor surface, lighting, and obstacle set will differ. If you have the robot, the compute, and the experience, this is one of the most exciting open legged-locomotion projects available. If you are starting from scratch, you will spend more time learning the toolchain than running parkour.

NOT IN THE REPO

  • —Isaac Gym training code, deployment code for Unitree A1 and Go1, and the trained policy checkpoint are in the repository.
  • —No CAD, no assembly instructions, no bill of materials. You are expected to already own the robot.
  • —The paper (ICRA 2024) is linked. The README walks through training in simulation and deploying to hardware.
  • —BSD-3-Clause licence permits commercial use.
  • —This is a research reproduction codebase, not a kit. You need GPU compute, a Unitree quadruped, and weeks of learning curve.
  • —The repository assumes familiarity with Isaac Gym, ROS, and quadruped control. There is no beginner path.

Can I build this?

Printnothing required
BuyUnitree A1 or Go1 quadruped, GPU for training (or cloud compute credits), depth camera if your robot does not ship with one
ToolsIsaac Gym (free, requires NVIDIA GPU), ROS Noetic, Unitree SDK, Python environment with PyTorch
Skillsexpert — requires fluency in reinforcement learning frameworks, ROS, quadruped kinematics, and sim-to-real transfer
Timeweeks — training a policy from scratch takes days of compute, deploying and tuning for real hardware takes additional weeks
Cost$$$, dominated entirely by the cost of the quadruped robot
SafetyQuadruped robots are heavy, fast, and can injure if they fall or collide. Test in a clear space away from bystanders. Lithium battery hazards apply.

Build at your own risk. Projects involve tools, electronics and sometimes mains voltage — follow the creator’s safety notes.

A desktop 3D printer that prints in full colorPartner · Kickstarter
A desktop 3D printer that prints in full color

HeyGears G1: 10M+ colors and transparent parts in one print, plus UV printing on flat objects. Figures, parts and labels — no painting.

See how it prints

Gallery

https://i.ytimg.com/vi/p3tWHgtSsTg/maxresdefault.jpg
https://i.ytimg.com/vi/cuboZYHGiMc/maxresdefault.jpg
local://covparkour0721.jpg

Start here

Navigation into the creator’s own docs — we don’t rewrite the guide, we route you to the source.

  1. 1.Read the ICRA 2024 paper (linked in the README) to understand the training pipeline and sim-to-real transfer strategy.(The paper explains the curriculum design, domain randomization, and deployment process in detail.)
  2. 2.Install Isaac Gym and verify you can run the provided training script on your GPU. (Isaac Gym is free but requires an NVIDIA GPU. Follow the Isaac Gym setup guide first.)
  3. 3.Clone the repository and walk through the training README to train a policy in simulation. (Training from scratch takes days of compute. A pre-trained checkpoint is provided if you want to skip straight to deployment.)
  4. 4.Set up the Unitree SDK and ROS environment on your deployment machine, then follow the deployment instructions to load the policy onto the robot. (Deployment requires the Unitree SDK and a working ROS Noetic installation. Start with the robot in a safe, open space.)

KNOWN ISSUES

  • The single biggest trap is not owning a Unitree quadruped before you start. This project assumes you already have the robot — it is not a guide to building one.
  • Sim-to-real transfer is fragile. The trained policy works in the lab environments shown in the paper, but your floor surface, lighting, obstacle dimensions, and camera calibration will differ. Expect to spend significant time tuning.
  • Isaac Gym training requires an NVIDIA GPU with sufficient VRAM. A single consumer GPU will take days per training run. Budget for cloud compute if you plan to iterate quickly.
  • The repository provides deployment code for Unitree A1 and Go1, but the hardware interface assumes you are familiar with the Unitree SDK. There is no step-by-step hardware setup guide.
  • The pre-trained checkpoint is provided, but it was trained on the authors' specific obstacle set and environment. It may not generalize directly to your space without retraining or fine-tuning.
  • This is a research codebase. Error messages are sparse, debugging is manual, and there is no support channel. If you are not comfortable reading research code and iterating independently, this will be frustrating.

Can I run this on a different quadruped, like a Spot or a custom build?

The deployment code is written specifically for Unitree A1 and Go1. Porting to another platform would require rewriting the hardware interface layer and likely retraining the policy with that robot's kinematics.

Do I need to train the policy myself, or can I use the provided checkpoint?

A pre-trained checkpoint is included. You can deploy it directly to test the system, but the policy was trained on the authors' specific environment. For best results in your own space, you will likely need to retrain or fine-tune.

How long does training take?

Training from scratch takes days of GPU compute, depending on your hardware. The paper reports training on a cluster. On a single high-end consumer GPU, expect multi-day runs.

What happens if the robot falls?

Unitree quadrupeds have a self-righting routine, but repeated hard falls can damage the motors or frame. Test in a padded space and be ready to catch or stop the robot manually during early deployment.

Community builds

No community builds yet — be the first, we feature the best ones.

Discussion1

FROM THE COMPAREE TEAM

The whole policy was trained in simulation — no real-world data at all — and it still lands the handstand. Have you tried sim-to-real transfer on a legged robot, and what broke first?

CompareeTEAM1mo agoedited

Practical notes from our verification: the repository is active and provides both training and deployment code, but this is a research reproduction, not a maker kit. The single biggest gap is that there is no hardware setup guide — the README assumes you already have a working Unitree quadruped and are fluent in its SDK. The pre-trained checkpoint is included, which lets you skip straight to deployment if you just want to see it run, but the policy was trained on the authors' specific obstacle course and environment. Your floor, lighting, and obstacle dimensions will differ, and sim-to-real transfer is fragile — expect to iterate. No CAD, no BOM, no beginner path. If you have the robot and the GPU budget, this is one of the most exciting open legged-locomotion projects available. If you are starting from zero, the learning curve is measured in months, not weekends.

Xuanxin Chen, Deepak Pathak lab (CMU)

Developed at Carnegie Mellon University in Deepak Pathak's lab and presented at ICRA 2024. The project demonstrates that vision-only parkour policies trained entirely in simulation can transfer directly to real quadruped hardware without any real-world training data.

GitHub

Star the project on GitHub

DISCLAIMER

  • Comparee is not the author of the projects featured here. All rights to each project belong to its creator — every page links to the original source, and we never host creators’ files.
  • Information is provided without warranty and may become outdated as projects evolve. Prices are indicative bands only — always check the creator’s parts list for current costs.
  • Building and operating any project is at your own responsibility. Protective equipment, safe workshop practice and compliance with local regulations are the builder’s responsibility.
GitHub repo