Open-source project
dorianborian/sesame-robot avatar
dorianborian/sesame-robot

Sesame Robot: a $50 ESP32 quadruped you build, print and program yourself

An open and affordable mini quadruped robot based on ESP32.

5,074 stars696 forksCApache-2.0

At a glance

What is it?
Sesame is an open source, 3D printed quadruped based on the ESP32, aimed at makers who want to start working with walking robots. The repository ships CAD, firmware, a serial CLI and a JSON API, but no prebuilt binary and no kit.
Who is it for?
Sesame suits makers who already solder, own a 3D printer and want to learn walking-robot mechanics on hardware they can repair. It is the wrong choice for anyone who wants a robot out of the box, since there is no kit and no prebuilt binary: you print the STLs, wire 8 servos and flash the firmware from firmware/ in the Arduino IDE yourself.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 1 day ago.
What is it written in?
Mainly C, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • dorianborian/sesame-robot5,074 ★ · +586
Star history
Repository2026-09-232026-11-15
dorianborian/sesame-robot4.5k5.1k

586 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

What Sesame Robot actually is, and who it is built for

Sesame is a miniature quadruped robot whose controller is an ESP32. The README describes it as "an accessible Open-Source robotics project based on the ESP32 microcontroller system, with an emphasis on expression and movement", and it states the target audience plainly: makers and engineers of all skill levels who want a platform to start working with walking robots. The repository holds CAD design files, STL files, build and wiring guides, and both base and expanded firmware for the ESP32 controller, plus debugging firmware the README says may help get a robot running.

The stated barrier to entry is concrete rather than aspirational. According to the README, building one requires basic soldering skills, $50-60 in hardware components, access to a 3D printer, and a basic understanding of the Arduino IDE. That combination rules out anyone who wants to unbox a finished product, and it also rules out anyone without a printer or a soldering iron. Everything else in the project follows from that constraint: the frame is designed entirely for PLA with minimal supports, and the parts list is short enough that a first build does not require a machine shop.

The design itself is a quadruped with 8 servo motors, two per leg, giving roughly 8 total degrees of freedom. A 128x64 OLED screen acts as a reactive face that syncs with movement, which is where the expression half of the project's emphasis lives. The movement half is the gait: the repository ships pre-programmed emotes for walking, waving, dancing, pointing and resting.

How the ESP32 firmware, servos and OLED fit together

The architecture visible in the repository is a single ESP32 running the whole robot. The firmware directory contains the C++ code that drives the 8 servos and the OLED face; the firmware is the Arduino sketch `sesame-firmware-main.ino` and needs the Arduino IDE, and the Getting Started steps say to configure WiFi AP settings when flashing. That means the robot can run as its own access point, and network mode is what the companion app depends on.

Control reaches the robot through three surfaces. There is a Serial Command Line Interface, described as a way to control the robot and trigger animations, alongside a web UI. There is a JSON API, described as RESTful and intended for programmatic control from Python, JavaScript and other languages. And there is Sesame Studio, a desktop application maintained in its own repository, dorianborian/sesame-studio, that lets you pose the robot in a 3D viewport using the printed STL geometry, generate C++ code for servo angles automatically, and sequence frames into animations. The generated C++ is the bridge between the visual tool and the firmware, so a custom gait ends up as code you upload rather than as a file the robot reads at runtime.

Two satellite projects extend the same hardware. The Sesame Simulator, credited to Jay Li, is a Rust-based 3D environment with a web interface and URDF integration for testing movements and kinematics without hardware. The Sesame ML Tools, credited to Luke Hollis, provide a world model for online planning, policy evaluation and RL finetuning, with a robot description that includes CAD-derived MJCF, a validated URDF, camera, IMU and foot frames, contact geometry, masses and actuator limits, plus tasks for standing, recovery, commanded locomotion and goal or obstacle navigation. Both live outside this repository, which matters if you expect everything to be in one clone.

Building a Sesame robot: from BOM to first flash

The README gives a five-step path, and each step points at a directory rather than repeating its contents. Start with the Bill of Materials at hardware/bom/README.md. The README names the recommended controller as a Lolin S2 Mini for DIY builds, with a Sesame Distro Board V3 as the current pre-flashed option that supports a Bambu Lab battery, a V2 board described as legacy and USB-only, and an ESP32-DevKitC-32E with Distro Board V1 also listed as legacy. Actuators are 8x 180 degree MG90 servos, and power is a 5V 3A source, either USB-C PD for the S2 Mini and V2 Distro Board or a battery with a buck converter.

Printing comes next, following hardware/printing/README.md, with PLA and minimal supports. Assembly follows the build guide in docs/build-guide/README.md and the wiring guide in docs/wiring-guide/README.md. Firmware comes from firmware/README.md and needs the Arduino IDE.

A first useful session is the Serial CLI, since it exercises servos and animations without any network setup. The README does not print the command set, so read firmware/README.md for the exact verbs before you connect to the board. The README also does not state the baud rate, the serial device name or any API endpoint, so those come from the firmware directory and the companion app repository rather than from the README. The JSON API is the next step once the robot is on WiFi, and the README points at the Sesame Companion App repository as the reference implementation for building your own integrations rather than documenting endpoints itself.

For custom movement, get Sesame Studio from its own repository (dorianborian/sesame-studio), pose the robot, and let it generate the C++ servo angles, which the README describes as ready to paste into firmware.

Where Sesame runs into trouble

The most obvious limitation is that this is a hardware project with no kit. The repository has no published GitHub releases, and the README describes no prebuilt binary or flashing tool. You assemble the robot, and if a servo dies or a wire breaks you diagnose it yourself. The debugging firmware is there for that reason, and its existence is a signal about how much of the work is electrical rather than software.

Documentation depth varies by directory, and the README is a signpost rather than a manual. It links to the BOM, printing guide, build guide, wiring guide and firmware directory without reproducing their contents, so the quality of your build depends on files this README does not show. The JSON API is described as RESTful but no endpoint list appears in the README; the companion app is offered as the reference implementation instead. If you want to integrate Sesame into another system, plan on reading source rather than a specification.

There is also a version trap in the hardware list. The README marks Distro Board V2 and the V1 combination as legacy while calling V3 current, so a build guide written for one revision may not match the board you can buy. Anyone sourcing parts from a third-party listing should check the revision against hardware/bom/README.md before soldering.

Finally, the simulator and ML tooling are separate repositories by other authors. They are useful, but they are not covered by this project's Apache-2.0 licence, and their maintenance is not tied to this repository's. Treat them as adjacent work, not as part of the build.

Sesame compared with a ROS-based quadruped stack

The natural alternative for someone who wants a programmable walking robot is a ROS 2 stack on a hobby quadruped platform. The difference is in where the complexity sits. A ROS-based robot typically separates a microcontroller for servo or motor control from a companion computer running nodes, topics and a build system, and you write your behaviours against that middleware. Sesame puts the whole controller on one ESP32 and exposes the robot through a serial CLI, a web UI and a JSON API. There is no middleware layer and no build system beyond the Arduino IDE.

That trade favours Sesame for a first walking robot. You can flash it, drive servos from the serial monitor and get a gait moving without learning a message-passing model. It also means the ceiling is lower: the README describes roughly 8 degrees of freedom from 8 servos and a 128x64 OLED, so there is no sensor suite for localisation or autonomy, and the ML tooling that does address planning and policy evaluation lives in a separate repository. If your goal is to develop and evaluate locomotion policies, a platform with a companion computer and a simulation-first workflow is a better starting point, and you would use Sesame's simulator or ML tools as reference rather than as the main loop.

A cheaper comparison is a wheeled ESP32 robot. It avoids the gait problem entirely, which is exactly the problem Sesame exists to teach. If you want to learn inverse kinematics and balance, wheels will not get you there.

Licence, maintenance and upgrade cost

The repository is licensed Apache-2.0, and the README displays that licence in its badge row. Apache-2.0 is a permissive licence with an explicit patent grant and a requirement to preserve notices, which matters here because the repository mixes firmware source with CAD and STL files. If you redistribute a modified frame or a modified firmware, the licence terms travel with it. This is not legal advice; read the LICENSE file in the repository for the actual terms.

The repository is not archived, and the last push was on 2026-10-15. The README does not document a versioning scheme, a changelog or a migration path, and the repository has no published releases, so there is no upgrade procedure to follow. Upgrading means pulling the current firmware and reflashing through the Arduino IDE. If you have edited the firmware to add animations, those edits are yours to reapply, and Sesame Studio's generated C++ is the part most likely to need re-placing after a pull.

The ongoing cost is hardware. Eight MG90 servos under a printed frame wear, and the README's BOM is the place to check what a replacement set requires. There is no stated support window or compatibility promise between firmware versions and board revisions, which is worth knowing before you build a second robot around a legacy board.

Editorial conclusion

Sesame suits makers who already solder, own a 3D printer and want to learn walking-robot mechanics on hardware they can repair. It is the wrong choice for anyone who wants a robot out of the box, since there is no kit and no prebuilt binary: you print the STLs, wire 8 servos and flash the firmware from firmware/ in the Arduino IDE yourself. Before buying parts, open hardware/bom/README.md and confirm the servo model, the 5V 3A supply and which controller board revision you can actually source today.

Frequently asked questions

How much does the Sesame robot cost to build?

The README states that building a Sesame robot requires $50-60 in hardware components, plus basic soldering skills, access to a 3D printer and a basic understanding of the Arduino IDE. There is no kit or prebuilt option described.

What do I need before starting a Sesame robot build?

According to the README: basic soldering skills, $50-60 in components, a 3D printer and familiarity with the Arduino IDE. The parts list is in hardware/bom/README.md, and the frame is designed for PLA with minimal supports.

How many servos does the Sesame robot use?

The README lists 8x 180 degree MG90 servos, two per leg, giving roughly 8 total degrees of freedom. Power comes from a 5V 3A source.

Can I control the Sesame robot from Python or JavaScript?

The README describes a RESTful JSON API for programmatic control from Python, JavaScript and other languages, available when the robot is on your WiFi network. It also notes the Sesame Companion App as a reference implementation for building your own integrations.

Which board should I use for a Sesame robot build?

The README recommends a Lolin S2 Mini for DIY builds. It lists the Sesame Distro Board V3 as current and pre-flashed, and marks the V2 board and the ESP32-DevKitC-32E with Distro Board V1 as legacy.

Official sources

  1. dorianborian/sesame-robot on GitHub
  2. Issues
  3. License: Apache-2.0
  4. Project website
  5. README
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/dorianborian-sesame-robot.svg)](https://hysenlabs.com/projects/dorianborian-sesame-robot)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/dorianborian-sesame-robot.svg)](https://hysenlabs.com/projects/dorianborian-sesame-robot)

Was this useful?