Marvin Bot in 3-D

Start here · Meet the robot · ~20 min · No prerequisites: a good first page · Needs 3-D graphics (WebGL) in your browser · numbers from the repository as of 2026-11-02

The whole robot, part by part, in your browser. Turn it around, peel off the shells, see through the frame to the motors, computer and battery, put it together in the order it would be built, and play simple movements while every motor’s load is shown live.

You will learn

• What Marvin Bot is physically made of: which parts are machined aluminium, which are 3-D printed, which are bought, and where the 23 motors, 4 servos, computer and battery sit.
• How the robot comes apart into seven modules, and the order it would be assembled in.
• How the joints move together in everyday movements (standing, squatting, slow walking, stepping up a stair, waving), and which motors work hardest.

What you are looking at

This model is not a drawing someone made by hand. Marvin Bot’s design lives in code: one text file (description/robot.yaml) lists every joint and motor, Python programs generate every part’s shape (08 Structure and code-CAD), and a generator turns all of it into a robot model file that the simulators read (13 The robot description). This page loads that same generated model: 241 visual pieces on 28 rigid bodies (links) joined by 27 motorised joints. The meshes are simplified to load quickly, so small details look rounder than the real parts.

Three ways to use it, one per tab on the left: Layers (what is it made of?), Assembly (how is it built?) and Skills (how does it move?). A fourth tab, Joints, lets you pose every joint by hand.

Playground

LayersAssemblySkillsJoints

Views

Bare robotWith shells X-ray: motorsX-ray: electronics Made vs boughtOnly bought parts

Layers (tick to show, click a name to X-ray it)

X-ray strength

0 = everything solid. Higher values fade every layer except the ones whose names you clicked (highlighted in amber), so you can see inside.

ColoursFinish colours (as built)By layer (motors by model)By module (how it comes apart)

Exploded view

Pulls every joint apart along its own offset, so you can see which body each part rides on.

Show joint axes

Arrows at each joint: red = roll (tilting sideways), green = pitch (nodding forwards and back), blue = yaw (turning). The arrow is the axis the joint turns about.

Show centre of mass and feet outline

Assembly order

From the project's assembly notes (docs/design/assembly_wiring.md). Click a step; the new parts slide in, highlighted.

◀ BackNext ▶Replay step

Skills (scripted, not the trained policy)

❚❚

Speed

Colour the motors by Load, and glow while movingLoad onlyMovement onlyTheir real colours

Load: green below 70% of the motor's continuous (rated) torque, amber at 70–100%, red above it: more than it can hold for long without overheating, fine for a few seconds (the peak rating is about 3× higher). Movement: a motor glows brighter the faster it turns (fully bright from about 90° per second); a motor that is holding still is drawn dark. The table below gives each joint's speed. Everything else fades so the motors stand out.

Pose by hand (robot hung on a gantry)

Each slider spans the joint's real range from robot.yaml, in degrees. The pelvis is held still, as on the test gantry, so the loads shown are what each motor needs to hold its limb up against gravity.

StanceAll zeroArms forwardClap pose

Enforce the shoulder's coupled limit

Shoulder roll may only go below 0° when the arm is swung forward (see 13). Untick it to see why: drag shoulder roll to −20° with the arm hanging.

FrontSideBack3/4

Loading the 3-D model…

Parts shown

–

Centre of mass height

–

Balance (static)

–

Hardest-working motor

–

How to use the picture: drag to orbit, right-drag (or two fingers) to pan, scroll or pinch to zoom. Click any part to see what it is, what it is made of and what it weighs.

Try this

1. Layers: press X-ray: motors. Count the motors in one leg (five: three at the hip, the knee, and two for the ankle up on the shin). Why do you think the ankle motors sit high on the shin rather than at the ankle? (06 answers it.)
2. Layers: press Made vs bought, then click Battery packs and Jetson AGX Orin in the list and raise the X-ray. Notice how the heaviest bought items sit high in the chest, which is why the torso narrows to the waist (07).
3. Skills: play Step up 18 cm and watch the knee of the leg on the stair turn amber and then red as it lifts the whole body. In this script it peaks near 60 N·m, about 150% of the RS04’s continuous rating, just as the trailing foot pushes off and leaves the ground. The project’s own static stair check finds 47 N·m (118%) in its worst pose (docs/decisions.md, 2026-10-29): the difference is posture, as this script keeps the knee more bent at that moment. Try it yourself: the more upright and further forward the body is when the back foot leaves, the less the knee has to do. That one moment is why the knee is the joint the project worries about most (05).
4. Skills: play Slow walk and look at the table: the hip roll motors, which hold the body up sideways while one foot is in the air, work almost as hard as the knees. The project’s stair check finds the same: hip roll at 105% of rated.
5. Joints: press Arms forward, then slowly lower shoulder pitch while shoulder roll is below 0°. With the coupled limit on, roll is pushed back to 0° as the arm comes down; untick it and watch the upper arm sink into the chest.

The layers: what the robot is made of

Every visible piece belongs to one layer. The numbers beside each layer in the playground are the drawn parts’ masses from the code-CAD (description/cad_model.yaml) and the motor datasheets.

Layer	What it is	Why it is made that way
Machined aluminium	Flat plates, rings, hubs and straps, mostly in 7075 aluminium (6061 for the motor rings and spacers), drawn in build123d and cut on a desktop CNC mill. Every part on the load path is aluminium, checked with finite elements.	Metal carries the big loads: landing, falling, motor torque. Every machined part fits a mill of about 200 × 150 mm (08).
Cut by a service	Twelve flat parts too long for the desktop mill (shin side plates, foot base plates, pelvis and torso frames), cut by an online laser or water-jet service.	About $1,200 in the bill of materials (not yet quoted; 21).
Printed parts	White PETG for the head shell (a rounded box in five light panels and a dark visor band) and the camera frame; carbon-fibre-filled nylon (PA-CF) for the battery latch and guides; rubbery TPU for the soles and the harness edge clips.	Nothing printed carries the robot’s load; printing is kept for curved, lightly loaded parts.
Body shells	25 clip-on covers in white PETG (0.98 kg), with a faceted torso shell, that give the robot a finished body.	Optional: the bare robot is meant to look finished too, and the walking policies are trained without them.
Motors	23 RobStride actuators (RS04, RS03, RS10P, RS00) and 4 small Feetech servos (neck and wrist pitch).	About 20 kg, half the robot. Each model sits where its torque fits (04).
Electronics, sensors, computer, battery	The contactor, precharge, power boards, e-stop relay, three USB-CAN adapters, DC-DC converters, IMU, depth camera, the Jetson AGX Orin and the battery packs.	Drawn at typical outlines for their class until the real parts are chosen (09, 11).

Not drawn: about 0.4 kg of fasteners and 0.5 kg of limb wiring, which are still to be modelled (docs/roadmap.md). That is why the drawn parts weigh a little less than the robot’s 40.00 kg.

Modules and assembly order

Marvin Bot is designed to come apart into seven modules: the torso core, the pelvis, two legs, two arms and the head, plus the battery and the optional shells. Each limb’s first motor stays on its parent module (the hip roll motors on the pelvis, the shoulder pitch motors on the torso), so a whole leg or arm comes off by undoing one output flange and unplugging one power and one signal connector. That is requirement R63: any motor can be changed with only one limb off the robot.

The Assembly tab follows the six steps in docs/design/assembly_wiring.md. Each module is built and tested on its own before it joins the rest: three pelvis motors on a short CAN cable, each leg on a single-leg test jig, the torso core powered up without limbs. That way a wiring mistake costs one module, not the robot.

How the skills are animated, and what the loads mean

The movements in the Skills tab are scripted for this page, not played by Marvin Bot’s trained policies (those live in the simulators: 16, 17). Each skill sets the pelvis position and where each foot should be; a small inverse-kinematics solver then finds the six leg angles that put each foot there, respecting every joint’s range. The arms, waist and neck follow hand-written curves.

The load on each motor is a quasi-static estimate: the torque needed to hold the pose still against gravity, as if the movement were very slow. For every joint the page adds up the weight of everything beyond that joint (and the push of the floor, if a foot beyond it is on the ground) times its lever arm about the joint’s axis. When both feet are down, the weight is shared between them by how close the centre of mass is to each foot. This is the same idea as the 2-D leg on 05, done for the whole 3-D robot.

What this estimate leaves out

Accelerations, impacts and friction. Real walking needs more torque than this (the swinging leg must be accelerated, and each foot lands with a jolt), so treat green as “fine when slow”, not “fine”. The ankle’s limits shown are the two-motor linkage’s capacity at its worst pose (32 N·m pitch, 25 N·m roll continuous; 06). The trained flat-ground policy’s hottest joint, measured in simulation with all of these effects, is a knee at 68% of rated in the fast walk (sim/isaaclab/README.md).

How Marvin Bot does it

In the repo

• The model comes from description/urdf/marvin_bot_covers.urdf (the robot with its shells), generated by tools/build_urdf.py from description/robot.yaml, skeleton.yaml and the code-CAD’s cad_model.yaml. The meshes are the code-CAD’s output, simplified to about a quarter of their triangles for this page.
• Layers come from each part’s process in cad_model.yaml (cnc, service, print, cover, bought); the motors from the URDF’s actuator outlines; the computer and battery from the outline boxes in skeleton.yaml.
• The masses used for the loads are the bare robot’s (marvin_bot.urdf, 40.00 kg with the hands), as the policies are trained.
• The hand meshes are the AmazingHand’s (Pollen Robotics, CC-BY-4.0), simplified by the project.

Trade-offs and alternatives

• A modular robot costs a few connectors and bolted flanges (mass and failure points) but makes every motor replaceable without stripping the robot. The alternative, one continuous harness, is lighter but turns every motor swap into a rebuild.
• Shells as an add-on keep the training model simple and the robot serviceable, at the cost of designing a bare robot that still looks finished.
• Motors high, mass high: putting the ankle motors on the shin and the battery high in the chest keeps the legs light (easier to swing) but raises the centre of mass (harder to balance; 02).

Decisions you can make here

• Which joints deserve a stronger motor or a gear stage: play the skills you care about and see which motors go amber or red (more torque, but more mass and cost; 04).
• Where heavy parts should sit: X-ray the battery and computer and ask what moving them would do to the centre of mass and to the legs’ loads (07).
• Whether the shells are worth their 0.82 kg: they add fall protection and a finished look, but every kilogram loads the knees on stairs.

Your decision noteCopy

Built from your settings above. Paste it into an issue, a design discussion or an AI assistant session.

Further reading

• three.js documentation: the open-source 3-D library this page uses to draw the model in the browser.
• The URDF format (ROS wiki): the robot-model file format this page reads; 13 explains it from scratch.
• K. M. Lynch and F. C. Park, Modern Robotics, chapters 4–6 (forward kinematics, the Jacobian, inverse kinematics) and 8.1 (statics): the maths behind the solver and the load estimate.

Sources

1. Marvin Bot repository, as of 2026-11-02: description/urdf/marvin_bot_covers.urdf, marvin_bot.urdf, description/cad_model.yaml, skeleton.yaml, robot.yaml, actuators.yaml and the code-CAD meshes (cad/, CERN-OHL-S-2.0) — used for: the model, part categories, masses, joint ranges and motor ratings
2. Marvin Bot repository, docs/design/assembly_wiring.md — used for: the modules, the assembly order and the electronics layout
3. Pollen Robotics, AmazingHand (CC-BY-4.0) — used for: the hand meshes (simplified by the Marvin Bot project)
4. three.js (MIT licence) — used for: rendering the model in the browser; the version pinned in the site’s package-lock.json is served with the site
5. ROS wiki, URDF joint and link elements — used for: reading joint origins, axes and visuals
6. K. M. Lynch and F. C. Park, Modern Robotics: Mechanics, Planning, and Control, Cambridge University Press, 2017 — used for: the Jacobian-based inverse kinematics (damped least squares) and the static joint-torque estimate
7. Marvin Bot repository, sim/isaaclab/README.md — used for: the trained flat policy’s hottest joint (knee, 68% of rated in the fast walk)