Structure and code-CAD

Stage 2 · Mechanics · ~35 min · Before this: 05 Leg loads and stairs, 07 Mass budget and proportions · numbers from the repository as of 2026-11-02

A humanoid’s frame has to carry landing loads several times its weight, fit between motors, be made on a desktop mill or printer, and weigh as little as possible. Marvin Bot draws every part in Python code, computes each part’s mass straight into the robot model, and checks every load-carrying part with a hand calculation. This page explains how, and lets you size a plate and sweep a joint yourself.

You will learn

• What code-CAD is and why a robot that changes every week benefits from parts written as code.
• When to machine aluminium and when to print plastic, and how a desktop mill limits part size.
• How to follow a load path, why joints need a far-side bearing, and how to check a part with σ = M·c / I and a safety factor.
• Why a pocketed plate is stronger than a drilled plate of the same mass.
• How sweeping a joint through its range against the body finds collisions, and how a coupled joint limit arises.

The idea in one picture

The structure is the robot’s skeleton: the metal and plastic parts that hold the motors in place and carry the robot’s weight from the feet up to the pelvis. A humanoid needs it to be strong enough not to bend or snap when it lands or falls, yet as light as possible, because every gram of frame is a gram the motors must carry (07 Mass budget). Code-CAD is how Marvin Bot draws those parts: instead of clicking shapes together in a drawing program, each part is written as a short Python program.

When Marvin Bot lands from a step, the ground pushes up on the foot with up to about three times the robot’s weight. That force has to travel through the foot plate, the ankle, the shin, the knee, the thigh, the hip and into the pelvis: that chain of parts is the load path. Wherever the force’s line does not pass straight through a part, it bends it, and bending is what breaks thin plates.

Try it with a plastic ruler: lying flat, it bends easily under a finger; stood on its edge, you can hardly bend it at all. A plate bent across its thickness is weak; the same plate bent across its width is strong. The trick of structural design is to arrange material so that every load bends parts the strong way, and to remove material where the stress is low. The first playground lets you see how much difference thickness, pockets and material make.

Playground 1: plate and beam strength

The words in the readouts, in plain terms (the maths follows in From first principles):

• Bending moment M: how hard the load tries to bend the plate at the checked point; force × lever arm, in N·m.
• Second moment I: how well the plate’s cross-section resists bending, in mm⁴. It depends on shape only, not material; thicker is much better.
• Peak stress σ: the force per unit area inside the metal at its worst point, in MPa (newtons per square millimetre).
• Safety factor: the material’s yield strength (the stress at which it starts to bend permanently) divided by the peak stress. Below 1 the part is permanently bent; Marvin Bot wants at least 2 (green). Amber or red means too weak.
• Deflection: how far the loaded end moves, in mm. Smaller is stiffer.

A plate is clamped at one end (the station where we check it) and a load acts at a lever arm L from that station, like the thigh plate in a sideways fall onto the knee. Choose the cross-section, material and load; the readouts give the bending stress, safety factor, tip deflection and mass.

Presets

Marvin Bot thigh plate today Same, 8 mm stock Old 6 mm drilled plate 7075, solid 6 mm Printed PA-CF, same shape

Section

Cross-section Solid rectangleDrilled (a hole through the cut)Pocketed to a floor (channel / I-like)

Width b

How wide the plate is, side to side.

Thickness t

Stock thickness; the desktop mill takes up to 60 mm.

Pocket floor

Thickness left at the bottom of each milled-out pocket.

Full-depth ribs (total width)

The rim and ribs left at full thickness between pockets.

Hole diameter

Material

Load

Load, multiple of body weight

Repo cases: landing 3 × up (with 0.5 fore-aft, 0.3 side), side fall 1 ×, hand catch 0.5 ×.

Body mass

Lever arm L

Distance from the checked station to the load's line.

Bending direction Out of plane (across the thickness: weak)In plane (across the width: strong)

Stress concentration factor Kt

1 = plain hand calculation (what cad/strength.py does). Holes and sharp corners concentrate stress locally, like a tear starting at a nick in paper: 2-3 × higher.

Bending moment M

–

Second moment I

–

Peak stress σ

–

Safety factor (target 2)

–

Deflection at load

–

Mass per 100 mm

–

Try this

1. Start from Marvin Bot thigh plate today: SF about 2.2, close to the repo’s 2.2-2.3. Click Same, 8 mm stock: SF 1.8, the repo’s figure for 8 mm. One millimetre of stock is worth 25% of strength, because I grows roughly with thickness cubed.
2. Click Old 6 mm drilled plate. The preset applies K_t = 2.5 and shows SF about 0.5, which is what a finite-element analysis (FEA: a computer stress simulation that splits the part into thousands of tiny pieces) found. Drag K_t to 1, the plain hand calculation: SF about 1.2. The stress concentration at the holes explains most of the gap. That is why the repo targets SF 2 on a hand calculation that leaves concentrations out.
3. Switch any preset to In plane bending. The same plate is many times stronger the other way: designers arrange plates so the big loads bend them in plane.
4. Click Printed PA-CF, same shape, then try the weak-direction (between layers) entry in the material list. Printed parts need far more thickness, which is why the leg’s load path is aluminium.

From first principles

Code-CAD: parts as programs

Most mechanical design is done in graphical CAD (computer-aided design) programs: you sketch and extrude with a mouse, and the model lives in a binary file. Code-CAD writes the same solids as a program: a plate is box(...), a motor seat is cyl(...), and a part is the union or difference of such shapes. Marvin Bot draws its machined parts in build123d, Python on the OpenCascade kernel, with exact outlines and curved surfaces and export to STEP, the standard file format machine shops accept.^[2] The shells, covers and quick checks use manifold3d, a fast, robust library for boolean operations (join, subtract, intersect) on triangle meshes (surfaces made of many small triangles).^[1] Alternatives in the same spirit: CadQuery (also on OpenCascade)^[3] and OpenSCAD (its own language, mesh-based).^[4]

Why code for a robot in its simulation phase:

• Parametric by construction. The parts read their sizes from description/robot.yaml and skeleton.yaml. When the legs grew 50 mm on 2026-10-29, the thigh and shin regenerated; nobody redrew them.
• Diffable. A change is a few lines in a pull request (a proposed change to the code, reviewed before it is accepted) (thigh_t = 9.0), reviewable like any code, not an opaque binary.
• One source of truth for mass. cad/build.py computes each part’s mass, centre of mass and inertia and writes them into description/cad_model.yaml; the URDF (the robot model file the simulators read) and the mass budget take them from there (13 The robot description). The simulator therefore trains on the masses of the parts that will be machined.
• Checks run on every change. Size against the mill and printer, strength, packaging and shell collisions are all scripts.

The cost: fine detail (fillets, fasteners) is slower to write than to click, and styled surfaces are hard to get right in code: today’s shells are generated as an offset hull round each link’s parts, so the frame sets their shape. They are to be redrawn in build123d as designed, lofted panels (docs/decisions.md, 2026-10-31). Fasteners are a budget item until a fastener pass.

# cad/leg.py, the thigh plate (simplified excerpt, build123d)
tplate = rounded(hull(rect(-32, 32, -60, fl_bot), disc(124, xz(knee))))  # outline, rounded inside corners
k_clip = clip_spot(tplate, xz(knee), [stator_holes("RS04", knee, "y")], min_r=64)  # harness clip
tplate = cut(tplate, stator_holes("RS04", knee, "y"),       # the motor's bolt circle
             lighten(tplate, keep=[ring_band("RS04", knee, "y"), disc(CLIP_PAD, k_clip)]),  # pockets
             disc(CLIP_HOLE, k_clip))                       # the push-in clip's hole
out.append(made("left_thigh_plate", "left_thigh_link", "al7075", plate(tplate, "y", y, tt)))

Machined aluminium, printed plastic

Material	Yield / strength (MPa)	Density (g/cm³)	Stiffness E (GPa)	Used for in Marvin Bot
6061-T6 aluminium	276 typical[5] (repo design value 240)	2.70	68.9	motor rings and hubs, spacers (37 of 237 CAD parts)
7075-T6 aluminium	503 typical[6] (repo 480)	2.81	71.7	most of the frame: plates, brackets, flanges, cranks, straps (125 parts)
PA6-CF, printed (carbon-fibre nylon)	82 in layer, 64 across layers[7] (repo 25 across layers)	1.17 (repo 1.10)	5.7 / 4.7	battery latch and guides, jigs (the body shells and head panels are white PETG)
PETG, printed	≈ 47-50[8]	1.27	≈ 2	not used for structure: softens near warm motors
TPU, printed	flexible	≈ 1.15	—	3 mm foot soles, harness edge clips

How to read the table: yield is the stress at which the material starts to bend permanently (higher is stronger), density is mass per volume (lower is lighter), and stiffness E is how much it resists stretching (higher bends less). “T6” names a heat treatment that hardens the aluminium. PA6-CF is nylon filled with chopped carbon fibre; PETG and TPU are common 3D-printing plastics (TPU is rubbery).

Aluminium is about 2.3 times as dense as PA-CF but 3 to 10 times as strong and 12 to 15 times as stiff, so for parts that carry the robot’s weight it wins per gram. Printed parts win on shape (hollow shells, curves, internal cable runs) and cost, but nothing printed carries load any more: since 2026-10-30 the arms carry their load in 7075 straps and every load-carrying part is aluminium, and printing is kept for the shells and head panels (white PETG) and small fittings.

Printed parts are weakest between layers, much as plywood splits along its layers: a part printed standing up and bent so the layers peel apart may hold only 25-40 MPa, which is the value cad/fea.py uses.

The workshop sets the shapes. Every machined plate is flat (2.5D: an outline and pockets from one face), so the mill cuts it with 2D toolpaths. Machined parts must fit the desktop mill with its tool changer fitted: 190 × 210 or 240 × 160 mm, depending on which side the changer sits, and 60 mm stock (MILL_MM in cad/build.py). Printed parts must fit a 250 mm printer. Flat parts too large for the mill (the 230 mm foot plates, the 265 mm torso side frames) go to an online laser or water-jet service. This is why the thigh grew 25 mm above the hip yaw motor rather than below it on 2026-10-29: the thigh plate still fits the mill.

Load paths and far-side bearings

Each joint on a quasi-direct-drive robot (see 04 Actuators) hangs the next link on the motor’s output. If the link is held on one side only, a sideways load bends the plate out of its plane and puts a moment on the motor’s output bearing. Think of a shelf held by one bracket versus a shelf held at both ends.

Marvin Bot’s first-pass leg did exactly that, and the strength check failed five parts at landing load: the foot base plate (SF 0.3), hip yoke back plate (0.3), hip roll front plate (0.6), shin knee flange (0.8) and hip yoke side plate (1.4) (docs/decisions.md, 2026-10-26).

The second pass added a far-side bearing at the knee and hip roll: the link becomes a yoke held on both sides, the load splits between two plates and the bending in each falls several-fold. The worst safety factor went to 2.4. Later, with finite elements (below), thin crossed-roller bearings went into rings at the hip yaw, the waist and the front of each hip roll motor, so those joints’ tilting loads reach the frame without passing through the motors’ own output bearings (2026-10-30).

Beam bending: σ = M·c / I

Cut a plate at a station. A force F acting a distance L away makes a bending moment M = F · L (N·mm if L is in mm). The moment stretches one face and squeezes the other; the stress grows linearly from zero at the neutral axis (through the section’s centroid) to its peak at the face furthest away, a distance c (the centroid is the section’s balance point; for a plain rectangle, its middle):^[9]

σ = M · c / I

σ is stress in MPa (N/mm²). I is the section’s second moment of area (mm⁴): each bit of area times the square of its distance from the neutral axis, summed. For a solid rectangle of width b bent across its thickness t,

I = b · t³ / 12, c = t / 2

so stress falls with thickness squared: double the thickness and the stress drops to a quarter. Bend the same plate across its width and t and b swap places: a 59 × 9 mm plate is about 43 times stiffer and 6.6 times stronger in plane than out of plane.

Pocketing. Material near the neutral axis does little, because it is multiplied by a small distance squared. Milling pockets from one face down to a thin floor removes that material but leaves full-depth ribs and rims, a section like a channel or an I-beam. Drilling holes right through removes the outer fibres too, which are the ones doing the work. The playground shows the difference: at the same mass, a pocketed plate has a much larger I than a thinner drilled one.

Safety factor. SF = yield strength / peak stress. SF 1 means the part just starts to bend permanently. Marvin Bot targets SF 2 on yield because the hand calculation leaves out torsion and stress concentrations at holes and corners, which typically raise local stress by 2-3 times^[10], and because the load cases are estimates until falls are measured.

Playground 2: joint sweep and collisions

A joint’s range is set by the first angle at which something hits. This matters because the robot’s controller must never command an angle that drives an arm into its own chest: the limits found here go into the robot model that the simulator and the trained controller use. This toy has the upper arm (a box) with the shoulder yaw motor (a cylinder) near its top, hanging from the shoulder roll axis beside a rounded torso and a head. Pick the shoulder pitch (arm forward) and sweep the shoulder roll inwards: the toy finds the first contact, and the chart repeats it for every pitch angle. It is a simplified version of what python -m cad.covers --check and tools/check_packaging.py do with the real meshes.

Presets

Marvin Bot-like Slim chest Shoulder further out Bigger motor on the arm

Pose

Shoulder pitch (arm forward)

Shoulder roll

+ = arm away from the body; − = towards the midline.

Geometry

Roll axis outboard of torso side

Chest corner radius

A rounder chest leaves room for the arm to come forward and in.

Motor radius on the arm

The shoulder yaw RS10P is Ø57 mm; its ring and the front plate's legs reach Ø92 mm.

Clearance gap

The body shells sit 4 mm off the parts (cad/covers.py).

This pose

–

First contact, sweeping roll inward

–

Limit, arm hanging (repo 0°)

–

Limit, arm forward 90° (repo −20°)

–

How to read this picture: the top panel shows the arm and torso from the front and from above, with anything touching marked red. The chart below has shoulder pitch (how far the arm is raised forward) along the bottom and the lowest shoulder roll reached before contact up the side; below the curve the arm would hit the body.

toy: lowest roll before contactrepo coupled limit (robot.yaml)contact

Try this

1. With the arm hanging (pitch 0°), drag the roll negative. The arm touches the torso within a few degrees: this is why Marvin Bot’s shoulder roll stops at 0° with the arm hanging.
2. Set pitch to 90° and sweep roll again. The arm now swings in front of the chest and gets to about −20° before the motor meets the chest’s corner. The blue curve is that limit at every pitch: a coupled limit, a joint’s range that depends on another joint’s angle. Compare it with the orange repo curve. The toy’s torso is the same front and back, so it also allows negative roll with the arm swung back; the repo keeps 0° there (only the forward cases were needed and checked).
3. Make the chest square (corner radius 10 mm): the forward allowance mostly disappears. Click Bigger motor on the arm: every limit tightens. Packaging is a negotiation between body shape and motor size.

How Marvin Bot does it

In the repo

• Parts: cad/leg.py, cad/torso.py, cad/arm.py, cad/head.py, cad/electrical.py, cad/covers.py build the parts around the RobStride motors at their STEP-model sizes. The machined ones are drawn in build123d (cad/b3d.py) as flat plates from 2D outlines, with inside corners rounded for a 6 mm cutter and isogrid pockets, and exported as STEP files; printed shells, covers and bought parts use manifold3d. The “mill” throughout is a desktop CNC (computer-controlled) milling machine that cuts parts from aluminium blocks. cad/build.py writes meshes and description/cad_model.yaml (mass, centre of mass, inertia, size per part) and lists any part too big for the mill or printer.
• Motors on front rings. RobStride’s drawings show the RS03 (and the RS06 it once used) are tapped only in ears at their output end, so each hangs from a flat ring on those ears (the RS10P on its front face, which is tapped); and the part it drives stands on a hub on the output, past the ring (front_ring and hub in cad/mounts.py); flat strips round the motor join the ring to structure behind it (cage). The RS04 bolts through a plate on either face, and the shoulder yaw RS10P also bolts up by its rear face, which lets its cage strips go (2026-11-02). Nine joints have a stop pin in the ring running in an arc groove (hard stops at the range plus 3°) and a hole for a zeroing dowel (2026-10-30).
• Harness clip points. Each service loop is tied either side of its joint: a push-in cable-tie mount in a hole on a solid pad (clip_spot in cad/b3d.py), a printed TPU clip over the edge of a thicker plate (cad/clips.py), or a P-clip under a screw (2026-10-31).
• Strength: cad/fea.py meshes each link’s metal parts as one bonded solid and checks them under a landing at the ankle (3 × body weight up, 0.5 × fore-aft, 0.3 × sideways), a hand catch (0.5 × up, 0.25 ×, 0.15 ×), a sideways fall onto the knee (1 × body weight), a head drop and each joint’s peak torque. Target SF 2.2 (2 plus the mesh’s under-read). It replaced a beam check that left out torsion, which is what failed the first-pass hip, shoulder and pelvis plates; the results and the redesign are in docs/decisions.md (2026-10-30).
• Shells are an add-on. cad/covers.py grows a 1.0 mm skin 4 mm outside each link’s parts (the torso’s as a faceted hull), trims it where it could reach the next link, cuts room for the harness loops and grilles over the arm motors, and splits it to fit the printer. Shells carry no load and stay out of the default URDF (the policies train on the bare robot); their 0.98 kg (white PETG) counts towards the 42 kg limit (40.97 kg with them).
• Collision sweeps: python -m cad.covers --check moves every joint through its range, every point of the coupled limit and combined poses, and fails on any shell contact. tools/check_packaging.py does the same for motor envelopes and collision boxes, separating packaging errors (within a limb) from ordinary self-collision (between limbs). These set the knee at 130°, hip pitch at −30° and the shoulder roll’s coupled limit (2026-10-29).

Trade-offs and alternatives

Choice	Taken	Alternatives considered (repo)
Structure	all-aluminium flat plates on the load path (mostly 7075, pocketed), printed shells as an add-on	printed structural shells on the arms and chest (retired 2026-10-30); fully printed (load must still go through metal; heat near the motors softens PETG-class plastics) (2026-10-25)
Joint support	far-side bearings at the knee; crossed-roller bearings at the hip yaw, waist and hip roll; hip pitch as a closed box	single-sided joints, which need the RS04 output bearing’s moment rating (not taken, 2026-10-28); the hip roll’s rear bearing (about 300 g, replaced by the front carrier)
Thigh plate	9 mm pocketed to 2 mm floor (+61 g a side)	8 mm (SF 1.8); a topology-optimised outline could take back about 35 g
CAD	build123d for machined parts (exact outlines, STEP files), manifold3d for shells and covers today; shells to move to build123d lofted panels	CadQuery, OpenSCAD, graphical CAD; Blender or implicit modelling for the shells
Big flat parts	online laser or water-jet service; about 12 parts to online machining (~$1,200, not yet quoted)	a larger mill; splitting parts into pinned segments
Strength check	finite elements for every load-carrying part (cad/fea.py), SF 2.2	hand calculation on CAD sections (missed torsion; retired 2026-10-30)

Where sources and the repo disagree

• Aluminium yield. Datasheets give typical yields of 276 MPa (6061-T6) and 503 MPa (7075-T6)^[5][6] and say typical values are not for design. The repo uses 240 and 480 MPa: lower, design-style values. The playground offers both.
• PA-CF. The PA6-CF datasheet gives 64 MPa across layers and 1.17 g/cm³;^[7] the repo assumes 25 MPa (published tests 25-40, conservative) and 1.10 g/cm³ (cad/lib.py). The density difference makes printed parts about 6% lighter in the repo than the datasheet suggests.

Decisions you can make here

• Plate thickness, pockets and material, given the worst load case and the SF 2.2 target. Trade: each millimetre of plate adds strength and mass; python -m cad.fea --link <link> --where shows where a part’s peak is.
• Machined, printed or sent to a service. Trade: printed is cheaper, lighter and freer in shape but far weaker (especially between layers); machined is strong but limited to the mill’s area; a service handles bigger flat parts at extra cost and lead time.
• Where a joint needs a far-side bearing. Trade: an extra bearing, plate and a little mass, in exchange for several-fold less bending in each plate and no sideways load on the motor’s own bearing.
• Joint range versus body shape. Trade: a rounder chest or a slimmer motor gives the arm more room; otherwise accept a coupled limit that the controller must respect.

Your decision noteCopy

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

Next: 09 Power and battery starts the electrical stage, beginning with the battery, the single heaviest item in the mass budget that is not a motor or frame.

Further reading

• manifold3d on GitHub: the library behind Marvin Bot’s shells and mesh checks; its README explains why its booleans never produce broken meshes.
• build123d documentation: the best starting point if you want exact geometry and STEP files from Python.
• MIT OCW 2.001 Mechanics and Materials I: free lectures on stress, bending and beams.
• M. F. Ashby, Materials Selection in Mechanical Design: how to choose a material for strength or stiffness per kilogram.
• Pilkey et al., Peterson’s Stress Concentration Factors: the reference for K_t at holes, notches and fillets.

Sources

1. E. Lalish et al., Manifold: geometry library for topological robustness — used for: what manifold3d is (mesh booleans, Python bindings)
2. build123d documentation — used for: the machined parts’ code-CAD (Python B-rep on OpenCascade)
3. CadQuery documentation — used for: Python CAD alternative with STEP export
4. OpenSCAD — used for: script-based CAD alternative
5. Aerospace Metals, Aluminum 6061-T6 / T651 datasheet (ASM / Aluminum Association data) — used for: 6061-T6 yield 276 MPa, density 2.70, E 68.9 GPa
6. Quickparts, Aluminum 7075 datasheet (ASM data) — used for: 7075-T6 yield 503 MPa, density 2.81, E 71.7 GPa
7. Polymaker, PolyMide PA6-CF technical data sheet V4.1 — used for: printed PA6-CF tensile strength (XY 82, Z 64 MPa conditioned), modulus, density 1.17
8. Prusa Polymers, Prusament PETG technical data sheet — used for: PETG printed yield 47-50 MPa, density 1.27
9. MIT OpenCourseWare, 2.001 Mechanics and Materials I — used for: beam bending σ = M c / I, second moment of area, cantilever deflection
10. W. D. Pilkey, D. F. Pilkey, Z. Bi, Peterson’s Stress Concentration Factors, 4th ed., Wiley 2020 — used for: typical stress concentration factors of 2-3 at holes and notches
11. M. F. Ashby, Materials Selection in Mechanical Design, 4th ed., 2011 — used for: strength and stiffness per mass comparison