A humanoid robot is one that resembles the human body in structure — an upright torso, two legs for locomotion, two arms, and a head. Unlike wheeled robots, a bipedal humanoid must actively manage its own balance while walking, which is what makes it one of the most challenging and rewarding projects in amateur robotics.

The goal of this guide is a tabletop-scale prototype — standing roughly 35–45 cm tall, capable of standing upright, shifting its weight, and taking slow deliberate steps. This is what roboticists call a "quasi-static" walker: it moves one limb at a time while keeping its center of mass over its support foot. It won't sprint or do gymnastics — but it will walk, and that is a genuine engineering achievement for a first build.

This scale is ideal for beginners to humanoid robotics: small servos are cheap, the 3D-printed frame is affordable, and if the robot falls over (which it will, at first) nothing expensive breaks.

A "degree of freedom" (DoF) is one axis of rotation at a joint. More DoF means more natural movement but also more complexity, cost, and code. For a small walking prototype, the minimum viable configuration is 6 DoF per leg (12 total), with optional arms and head adding more.

This guide targets a 18 DoF configuration: 12 for legs, 4 for arms, 2 for the neck — a solid balance between capability and manageable complexity for a first humanoid build.

Every part below is available in our store. Click any card to go to its product page. For convenience, everything is also bundled in our Humanoid Robot Starter Kit.

The structural frame is what connects all your servo joints into a coherent body. At this scale, 3D-printed PLA+ is the ideal material — it's light, strong enough for the loads involved, easy to redesign, and cheap to reprint if something breaks.

You have two options for frame design. The fastest is to use a proven open-source design. Poppy Humanoid and Lynxmotion SES-V2 both have freely downloadable STL files optimised for MG996R-class servos. Download, slice in Cura or PrusaSlicer, and print at 30–40% infill with 3 perimeter walls for joint sections and 20% for the torso shell.

If you want a fully custom design, use Fusion 360 (free for personal use) or FreeCAD. The key constraint is that each joint housing must seat the servo body firmly with the output shaft centred on the rotation axis. Design the servo pocket first, then build the link around it.

Critical printed parts: foot platforms (flat, wide — stability is everything at first), shin and thigh segments, hip block, torso shell with internal mounting rails, and head housing. Use the aluminium U-brackets for knee and hip connections rather than printing those — printed bracket hinge points wear out quickly under load.

The power system is the most critical part of a humanoid build to get right. Two separate power rails are essential: one for the servos (6V, high-current) and one for the logic boards (5V, clean). Mixing them causes voltage drops and resets when servos fire.

Connect the 3S LiPo (11.1V) to two BEC regulators in parallel. BEC 1 outputs 6V and feeds all 18 servo signal boards via the two PCA9685 driver boards. BEC 2 outputs 5V and feeds the Raspberry Pi 5 via its USB-C port and the Arduino Mega via its barrel jack. GND rails must be common between both BECs and all boards.

The two PCA9685 boards share an I²C bus with the Raspberry Pi. Set one board to address 0x40 (default) and the other to 0x41 by bridging the A0 solder jumper. The Raspberry Pi sends high-level joint angle commands over I²C to the PCA9685 boards, which output the PWM signals that the servos respond to. For time-critical balance corrections, the Arduino Mega can take over servo control directly via its own PWM pins, communicating with the Pi over UART.

Mount the MPU-6050 IMU at the torso, as close to the robot's center of mass as possible. Connect it via I²C (SDA/SCL) to the Arduino Mega which handles the balance feedback loop at high frequency.

Assemble from the ground up — feet first, then legs, then torso. This lets you test each leg independently before combining them.

The MPU-6050 gives you raw accelerometer and gyroscope data on 6 axes. Raw data is noisy. For balance control you need the robot's actual tilt angle, which requires combining both sensors through a complementary filter or a Kalman filter.

The complementary filter is the right starting point: it takes the gyroscope's short-term precision and the accelerometer's long-term accuracy, blends them with a simple formula, and outputs a stable tilt angle. A typical coefficient is 0.98 for the gyroscope and 0.02 for the accelerometer, updated at 100Hz or faster on the Arduino.

Once you have a reliable tilt angle, use it as the feedback signal for a PID controller that adjusts the ankle roll servos in real time. When the robot tilts left, the ankle rolls right to compensate, keeping the foot flat. This is the foundation of all bipedal balance, from this prototype all the way up to Boston Dynamics Atlas.

A gait is the sequence of joint angle positions that moves the robot forward. For a quasi-static walker, the gait is broken into discrete phases that execute one at a time. The simplest walking gait has four phases per step cycle:

Encode each phase as a Python dictionary of servo channel → angle pairs on the Raspberry Pi. Interpolate smoothly between positions using linear or cubic interpolation over 300–500ms per phase. Our free starter code package includes a working gait engine, PCA9685 driver, IMU reader, and balance PID controller — all in Python, ready to run on the Raspberry Pi 5.

Robot falls immediately when power-on: One or more servos is fighting against its mounting bracket due to incorrect centring. Go back to Step 2 — re-centre every servo individually before reinstalling.

Servos buzz loudly at rest: This is the servo hunting around its set point due to a loose mechanical connection or excessive load. Check that the servo horn is firmly locked on the output shaft. If the servo is overloaded (e.g. the knee holding the full robot weight), consider adding a physical support or using a higher-torque servo for that joint.

One leg's servos don't respond: Most likely a bad I²C connection to that PCA9685 board, or a wrong I²C address. Run an I²C scanner sketch on the Arduino to confirm both boards at 0x40 and 0x41 are visible on the bus.

Robot walks but tips sideways: The IMU-to-ankle feedback loop isn't acting fast enough, or the ankle roll servo has too little torque for the speed of the tip. Increase the PID proportional gain carefully (small increments), or slow down the gait phases to give the balance controller more time to react.

Raspberry Pi resets during movement: Power supply noise from the servos is spiking into the Pi's supply. Add a 470µF capacitor across the Pi's 5V input and make sure the servo and logic GND rails are only connected at one common point (star grounding).

Once your robot walks reliably, the next milestones open up a genuinely exciting range of projects. Add a Raspberry Pi Camera v3 to the head and run a face-tracking algorithm — the neck servos will keep it centred automatically. Add FSR (force-sensitive resistor) foot sensors for precise ground contact detection, enabling dynamic rather than quasi-static walking.

For higher performance, replace the MG996R servos in the knees and hips with Dynamixel AX-12A smart servos, which provide position feedback, temperature monitoring, and load sensing over a daisy-chained serial bus — dramatically simplifying the wiring and giving your code real-time joint state data.

Longer term, the same mechanical platform can host a voice interface (ReSpeaker mic array), an onboard LLM for conversational AI, or vision-based object grasping with a printable two-finger gripper on each arm. Every part you'll need is in our store.