Sesame Robot: An Open-Source ESP32 Quadruped You Can Build and 3D Print for $50-60

What Sesame Is and Who Should Build It

Sesame is a mini quadruped robot created by Dorian Todd. The README describes it as 'an accessible Open-Source robotics project based on the ESP32 microcontroller system, with an emphasis on expression and movement.' The design philosophy sets it apart from purely locomotion-focused open source quadrupeds: Sesame includes a 128x64 OLED screen that acts as a reactive face, syncing expressions with movement.

The README states the project is 'designed for makers and engineers of all skill levels' and requires basic soldering skills, $50-60 in hardware, access to a 3D printer, and a basic understanding of the Arduino IDE. These requirements make it accessible to anyone who has done small electronics projects before, not just experienced roboticists.

The repository contains everything needed: CAD design files, STL files for printing, build and wiring guides, and the firmware for the ESP32-based controller. A debugging firmware is also included to help diagnose assembly problems.

Hardware Components: Servos, Microcontroller, and Power Options

Sesame uses 8 MG90 180-degree servos, two per leg, giving the robot approximately 8 degrees of freedom. The README lists three microcontroller options. The Lolin S2 Mini is recommended for DIY builds. The Sesame Distro Board V3 is the current option: it comes pre-flashed and supports the Bambu Lab 14500 7.4V 800mAh Li-ion battery. The Distro Board V2 is a legacy USB-only option, and the Distro Board V1 works with an ESP32-DevKitC-32E (also legacy).

Power delivery depends on the controller choice. The S2 Mini and V2 Distro Board use USB-C PD at 5V 3A. The Distro Board V3 supports battery operation via a battery plus buck converter, using the Bambu Lab 14500 cell.

All structural parts are designed for 3D printing in PLA with minimal supports required. The README's Bill of Materials is in the hardware/bom/ directory and lists all required electronics and hardware. The Printing Guide in hardware/printing/ describes the print settings for the STL files.

Building and Flashing: Four Steps from Parts to Walking

The README outlines the build process in four numbered steps. First, gather the parts using the Bill of Materials. Second, download the STL files and print the parts following the Printing Guide. Third, assemble the frame and connect the electronics using the Build Guide in docs/build-guide/ and the Wiring Guide in docs/wiring-guide/. Fourth, upload the firmware from the firmware/ directory using Arduino IDE.

Firmware configuration requires setting WiFi access point credentials. Once flashed, the firmware exposes a web UI accessible from a phone on the same WiFi network. The README describes this as allowing you to control the robot from your phone via the built-in Access Point.

The firmware file is sesame-firmware-main.ino. It handles kinematics, the OLED face display, and the WiFi control interface. The README also documents a Serial Command Line Interface (Serial CLI) for controlling the robot and triggering animations via a serial connection.

Sesame Studio: Visual Animation Composer and C++ Code Generator

Sesame Studio is a standalone desktop application included in software/sesame-studio/. It provides a visual interface for designing poses and animation sequences for the robot. The README describes its capabilities: you can visually pose the robot using a schematic interface, generate C++ code for servo angles automatically, and sequence frames into complex animations.

The workflow is to design a pose in the Studio, generate the C++ code, and embed that code in the firmware. This removes the need to calculate servo angles by hand. Pre-programmed emotes in the firmware include Walking, Waving, Dancing, Pointing, Resting, and others.

For voice assistant integration and advanced interactions, the Sesame Companion App is a separate Python application (at github.com/dorianborian/sesame-companion-app). It uses the JSON RESTful API and network mode to provide voice control, remote control over the local network, dynamic face control, and reference implementations for building custom integrations. The Companion App requires robots running the latest firmware with network mode enabled.

The Broader Sesame Ecosystem: Simulator and ML Tools

The Sesame project has grown beyond the core robot to include a simulator and machine learning tools, both contributed by community members.

The Sesame Simulator was created by Jay Li and is a Rust-based 3D simulation environment for testing Sesame's movements and kinematics without hardware. It runs in the browser, uses a physics-based simulation engine, and integrates the URDF description of Sesame's physical properties. This is useful for iterating on walking algorithms before deploying to the physical robot.

The Sesame ML Tools were created by Luke Hollis and reside in a separate repository (github.com/lukehollis/sesame-ml). They provide a self-contained printable STL set, a CAD-derived MJCF description, a validated URDF with camera, IMU, and foot frames, tasks (stand, recovery, locomotion, navigation), and a policy evaluation framework that outputs JSON/CSV reports, MP4 and GIF visualizations, and tracks metrics including task success, energy, and latency. These tools make Sesame a viable platform for reinforcement learning research on a physical robot.

Limitations: Physical Build, Servo Torque, and Skill Prerequisites

Sesame is a physical robot project. Unlike software libraries, you cannot evaluate it without buying components, printing parts, and assembling them. The README is candid about the required skills: basic soldering, access to a 3D printer, and Arduino IDE familiarity. A developer who has never soldered or printed before will need to acquire those skills first.

The MG90 servo motors used throughout the design are small, low-torque hobby servos. They are suitable for a 3D-printed PLA frame of this size but will not scale to larger or heavier designs. The 8-servo configuration gives approximately 8 degrees of freedom, which is enough for walking gaits but does not support the high-DOF motions of more specialized quadrupeds.

The firmware is maintained by Dorian Todd. Custom faces require adding bitmaps manually; the README links to a guide in the firmware docs but this is not a drag-and-drop process. The web UI is built into the firmware, which means changes to the control interface require reflashing.

The repository has no GitHub releases. Firmware and CAD files are updated by pushing directly to the main branch, so there is no versioned reference for a specific hardware configuration.

Alternative: SpotMicro

SpotMicro is another open-source quadruped robot project modeled on Boston Dynamics' Spot robot. Like Sesame, it is 3D-printed and uses hobby servo motors. Unlike Sesame, SpotMicro is generally driven by a Raspberry Pi rather than a microcontroller, which gives it more processing power for locomotion algorithms at the cost of higher power consumption and complexity.

The difference in design philosophy is clear. Sesame is built for expression and accessibility: it emphasizes the OLED face, emotive animations, and a low entry cost. SpotMicro is built to replicate the locomotion of a more complex robot and is a platform for more advanced gait research.

For makers who want a walking robot they can build in a weekend and control from a phone with voice commands, Sesame's simpler architecture and lower cost are advantages. For developers who want to run ROS-based locomotion algorithms on a Raspberry Pi with more DOF, SpotMicro is the more appropriate starting point.

Editorial conclusion

The Sesame Robot project is the right starting point for makers who want to build a walking quadruped with a network-connected, programmable personality. The $50-60 hardware cost and fully 3D-printed design make the physical build accessible. The firmware is uploaded via Arduino IDE, which requires no specialized embedded development knowledge. It is not appropriate for production robotics or high-precision locomotion research: the MG90 servo-based design has limited payload and torque. Before building, confirm you have a 3D printer capable of printing PLA and a USB-C PD power source at 5V 3A (for the Lolin S2 Mini or V2 Distro Board).

Frequently asked questions

Official sources

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