“The Cake Is a Lie”

"The Cake Is a Lie": A LeRobot Tutorial for a Birthday‑Cake Robot (SO‑101)

Train a small robotic arm to place a candle, light it with a USB arc lighter, (optionally) blow it out, and present the cake — safely — trained using imitation learning with LeRobot.

🎂 This Robot Arms Itself... With Birthday Candles!

Ever wanted a robot to handle the most dangerous part of birthday celebrations? Or have somebody light your birthday cake when you are lone.

We built one — and you can rebuild it on your own.

Meet HappyBirthdayRobot - a comprehensive tutorial for training a hacked SO-101 robotic arm to autonomously place, light, and manage birthday candles.

Using LeRobot's learning framework combined with vision control, and a USB-controlled fire lighter, this project teaches real-world robotics through the surprisingly complex task of automating birthday celebrations.

The Challenge

Placing a candle might seem simple, but automating it requires solving multiple hard problems simultaneously:

precise manipulation, real-time perception, hardware control, and safety supervision.

This tutorial walks you through training a robot using imitation learning - teaching it candle placement by demonstration - then adding vision feedback, async supervision, and (most importantly) the ability to safely play with fire.

What Makes This Special?

🤖 LeRobot Integration - Built on HuggingFace's LeRobot framework for imitation learning. Train your robot by demonstration using ACT (Action Chunking Transformer), Gr00t, or SmolVLA models. The repository includes justfiles for each approach (modules/act/justfile, modules/gr00t/justfile, modules/smolvla/justfile) showing how we tried our training.

collect data and train policies.

🔥 USB-Controlled Lighter - We didn't just mount a lighter; we completely hacked it. A plasma arc lighter was hotwired to bypass the switch, connecting battery power directly to the plasma element through a relay. The relay mounts on an Arduino, giving us serial control over fire itself. Flick a command over USB at 9600 baud, and you've got flame.

👁️ AI Vision Supervision - This isn't blind automation. After every action, the robot captures images from its cameras and queries a generative vision model. The AI analyzes the scene, detects objects, verifies candle placement, and confirms when flames are actually lit.

The supervisor makes decisions based on what the robot actually sees, not what it hopes happened.

⚡ Asynchronous Override Architecture - Here's where it gets interesting: the robot runs its hardware models as background tasks while a supervisor monitors everything in parallel.

Using Python's asyncio, we achieve true concurrent operation - the robot can be mid-lighting while the supervisor simultaneously checks sensors, processes vision feedback, and listens for keyboard input. Press any key and the supervisor instantly cancels the hardware task.

📸 Triple Camera Perception System - We're using three different cameras for complete workspace awareness:

• An FPV camera mounted directly on the robot arm provides close-up gripper views
• A webcam positioned high and angled gives overhead workspace context
• An Orbbec Gemini 2 depth camera adds medium-height side perspective where we only use the video data, no depth for now.

The environment is optimized for vision: white printer paper and poster boards create high contrast, minimizing background noise. Everything mounts to an metal breadboard to give us a good workspace.

The Hardware Hacks

Custom 3D-Printed Mounts

We designed custom mounts that serve triple duty: holding the FPV camera, providing attachment points for optional mirrors (for multi-angle single-camera viewing), and securing the USB lighter.

The mirror technique is clever in theory - use multiple mirrors to give one camera three viewing angles, approximating depth perception. In practice, the FPV camera's narrow field of view made this less effective than we hoped. But with a fisheye lens? That's the next iteration.

The Lighter Assembly

Two different lighter implementations made it into the final build:

• Plasma arc version: Hotwired to bypass the switch entirely, giving direct relay control over the plasma element
• Butane version: A servo motor attached to an elliptical disk that depresses the striker mechanism when rotated, creating a mechanical click trigger

Both connect through Arduino relays with 9600 baud serial control. Fire on demand, via USB. What could go wrong?

Modified Gripper

The soft gripper fingers got a redesign for better candle handling - the modified .3mf file is in docs/cad/soft_gripper_finger_modified.3mf, ready to print, based on the work by VectorWangel.

The Learning Pipeline

The goal of the Hackathon was to get experience on the Jetson Thor, and that is what got. To improve our success chances we trained multiple models, but set on ACT in the end, because that is the only one we got to run on Thor. (There seem to be 1 year of engineering missing on the Jetson :P).

This project demonstrates multiple approaches to robot learning:

Imitation Learning with LeRobot - Collect demonstration data by manually controlling the robot through candle

placement tasks, then train vision-language-action models (Gr00t, SmolVLA) or behavior cloning policies (ACT) to replicate the behavior.

Vision-Guided Execution - The supervisor orchestrates multi-step tasks:

• Place the candle - Learned policy executes, supervisor waits
• Verify placement - Capture image, query vision model, parse JSON response
• Light the candle - Hardware model runs in background printing progress every 0.1s while the supervisor
• concurrently monitors for flame detection OR keyboard override
• Retract safely - Final cleanup movements

Real-Time Vision Feedback

After each major action, the supervisor captures an image and sends it to a vision model with context about the current state. The model returns structured JSON with:

- Detected objects and their states

- Current robot state verification

- Recommended next state

- Natural language instructions

This feedback loop turns blind automation into informed supervision. The robot knows if it actually succeeded.

Try It Yourself

Everything you need is in the repo, but this is a Hackathon project, so don't expect things to work, but perhaps you can build on the automatic lighter CAD or use some of our training command lines.

📁 CAD Files: docs/cad/ contains camera mounts and modified gripper fingers and the cads for the lighters.

⚙️ Setup Commands: justfiles throughout the repository (env/justfile, modules/gr00t/justfile, modules/smolvla/justfile, modules/act/justfile) document exactly what to run for each learning approach.

Check out the full build: https://github.com/OliverAHitchcock/HappyBirthdayRobot

What We Learned

- LeRobot makes imitation learning accessible for real hardware projects

- Always print extra backup parts

- For now, don't touch Camera placements or backgrounds.

- Taking more and diverse data helps to achieve more robust robots.

- Robots playing with fire are a little bit scary.

- Justfiles are underused for documenting complex projects

Built for Seeed Home and cooking embodied AI Hackathon. Because sometimes the best way to learn async robotics control and imitation learning is to teach a robot to play with fire. 🔥🤖