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 Xuxin Cheng, Kexin Shi, Ananye Agarwal, Deepak Pathak (CMU)

FULL CAD BOM FIRMWARE DOCS

RoboticsAI

difficulty
●●●●●
time
weeks
license
CC-BY-NC-4.0
repo
repo INACTIVE1,181 stars

WHAT YOU’LL NEED

1
Jump to section

COMPAREE VERDICT

Extreme Parkour is the CMU research code behind a quadruped that long-jumps gaps twice its length, climbs obstacles twice its height and does a handstand, using a single front depth camera and a policy trained entirely in simulation. It is not a build: you need a Unitree quadruped (the paper used an A1) and an NVIDIA GPU for training (about 13-20 hours per run on an RTX 3090). The repository provides the simulation training loop, a viewer and a model-export script, but not the real-robot deployment stack, a pre-trained checkpoint or a hardware guide, so getting the exported policy onto a real robot is your job. It is licensed CC BY-NC 4.0 (no commercial use) and has not been updated since November 2023. Great for RL researchers who already own a robot; not a maker project.

GOOD TO KNOW

  • —Isaac Gym parkour training code for the Unitree A1 model, a policy viewer, and a script to export trained models; the real-robot deployment stack is not 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 installing, training and playing back the policies in simulation and exporting them; it does not cover hardware deployment.
  • —Licensed CC BY-NC 4.0 — free for research and personal use, but not for 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, PyTorch reinforcement learning and quadruped control. There is no beginner path.

Parts to buy

3 items

From our check of the build. Exact quantities and part numbers are in the creator’s BOM.

  • Unitree A1 or Go1 quadrupedFind
  • GPU for training (or cloud compute credits)Find
  • Depth camera if your robot does not ship with oneFind

BUILDS OF THE WEEK

Five open-source builds worth your weekend, every week.

Checked like this one: what’s really in the repo, what it costs, how hard it is. One email, unsubscribe anytime.

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 an NVIDIA GPU), Python 3.8 with PyTorch, plus whatever control stack your own robot needs for deployment
Skillsexpert — requires fluency in reinforcement learning frameworks, ROS, quadruped kinematics, and sim-to-real transfer
Timeweeks - one training run takes roughly 13-20 hours on an RTX 3090, and deploying and tuning on 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.

More builds like this

All projects
You can 3D print this pocket robot that blinks, talks and follows your faceRoboticsOpenArm: A Research-Grade Force-Feedback Robot ArmRoboticsThis robot watches your hand move and puts a sweet in it — code is publicAI

Gallery

i.ytimg.com
i.ytimg.com
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. (Train the base policy first (8-10 hours on an RTX 3090), then the camera distillation policy (another 5-10 hours). No pre-trained checkpoint is included.)
  4. 4.Export the trained policy with save_jit.py and integrate it with your robot's control stack yourself. (The repository stops at the exported model; real-robot deployment code is not included. Start any hardware tests in a safe, open space.)

Resources

Documentation, files and community threads for this build — we link straight to the original sources and never rehost the creator’s files.

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 needs an NVIDIA GPU with enough VRAM; on an RTX 3090 one full run (base + distillation) takes roughly 13-20 hours, so each iteration costs you a day.
  • The repository stops at exporting the trained policy (save_jit.py). There is no real-robot deployment code and no hardware setup guide, so wiring the exported model into your quadruped's control stack is entirely up to you.
  • There is no pre-trained checkpoint in the repository, so you must train the policy yourself, and a policy trained on the paper's simulated obstacle set may still need retuning for your real floor, lighting and obstacles.
  • 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?

Not out of the box. The parkour training config targets the Unitree A1 and there is no real-robot deployment code at all. Another quadruped would need its own robot model and config, retraining, and your own hardware interface.

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

You train it yourself - the repo has no pre-trained checkpoint. The good news: the README puts a full run at roughly 13-20 hours on a single RTX 3090.

How long does training take?

Less than a day on one high-end GPU: the README quotes 8-10 hours for the base policy and 5-10 hours for the camera distillation policy on an RTX 3090.

What happens if the robot falls?

The repository does not cover fall handling. Repeated hard falls can damage a quadruped's motors or frame, so test in a padded space and be ready to stop the robot manually during early trials.

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?

CompareeTEAM2mo agoedited

Practical notes from our verification: this is a research codebase, not a maker kit, and it covers the simulation side only. The README walks you through training a base policy, training the camera-based distillation policy, playing both back in Isaac Gym and exporting the models with save_jit; there are no pre-trained checkpoints in the repo and no hardware deployment guide, so getting a real robot to run the exported policy is up to you. The robot configs target the Unitree A1. Budget GPU time: the README quotes roughly 8-10 hours on an RTX 3090 for the base policy plus another 5-10 hours for distillation. The code has not been updated since late 2023 and it is licensed CC BY-NC 4.0, so commercial use is not allowed. If you already have a quadruped and RL experience, this is one of the most impressive open legged-locomotion projects available. If you are starting from zero, the learning curve is measured in months, not weekends. Correction (4 October 2026): we re-checked this page line by line against the project's own repository, documentation and videos, and fixed errors in earlier versions.

Xuxin Cheng, Kexin Shi, Ananye Agarwal, Deepak Pathak (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