forgecad 0.1.0

package/examples/liquid-soap-dispenser.forge.js

@@ -0,0 +1,159 @@
+// Liquid Soap Dispenser — staged dispense animation without fluid simulation.
+// Move "Dispense Progress" from 0 → 100 to preview one pump cycle.
+
+const bodyH = param("Bottle Height", 130, { min: 90, max: 180, unit: "mm" });
+const bodyR = param("Bottle Radius", 34, { min: 24, max: 45, unit: "mm" });
+const wall = param("Wall Thickness", 2.8, { min: 1.5, max: 5, unit: "mm" });
+const pumpStroke = param("Pump Stroke", 10, { min: 4, max: 18, unit: "mm" });
+const progressPct = param("Dispense Progress", 0, { min: 0, max: 100, unit: "%" });
+
+const progress = progressPct / 100;
+const clamp01 = (v) => Math.max(0, Math.min(1, v));
+
+// Press down (0..0.6), then spring release (0.6..1.0).
+const pressIn = clamp01(progress / 0.6);
+const release = clamp01((progress - 0.6) / 0.4);
+const press = progress <= 0.6 ? pressIn : 1 - release;
+
+// Add a center slice so internals are inspectable.
+cutPlane("Middle Slice", [0, -1, 0], 0);
+
+const neckH = 16;
+const neckR = bodyR * 0.36;
+const chamberH = 48;
+const chamberR = neckR * 0.9;
+const chamberWall = 2.4;
+const chamberInnerR = chamberR - chamberWall;
+const chamberBottomZ = bodyH + 4;
+const chamberTopZ = chamberBottomZ + chamberH;
+
+const headW = 54;
+const headD = 22;
+const headH = 14;
+const headRestZ = chamberTopZ + 14;
+const headZ = headRestZ - press * pumpStroke;
+
+const nozzleL = 34;
+const nozzleR = 3.6;
+const nozzleRootX = headW * 0.22;
+const nozzleCenterX = nozzleRootX + nozzleL * 0.5;
+const nozzleTipX = nozzleRootX + nozzleL;
+const nozzleZ = headZ + 1;
+
+// Bottle shell + neck.
+const bottleOuter = cylinder(bodyH, bodyR, bodyR, undefined, true)
+  .translate(0, 0, bodyH * 0.5);
+const bottleInner = cylinder(bodyH - wall * 1.4, bodyR - wall, bodyR - wall, undefined, true)
+  .translate(0, 0, wall + (bodyH - wall * 1.4) * 0.5);
+const bottleShell = bottleOuter.subtract(bottleInner);
+
+const neckOuter = cylinder(neckH, neckR, neckR, undefined, true).translate(0, 0, bodyH + neckH * 0.5 - 2);
+const neckHole = cylinder(neckH + 6, chamberR - 2.5, chamberR - 2.5, undefined, true)
+  .translate(0, 0, bodyH + neckH * 0.5 - 2);
+const bottle = union(bottleShell, neckOuter).subtract(neckHole);
+
+// Pump chamber.
+const chamberOuter = cylinder(chamberH, chamberR, chamberR, undefined, true)
+  .translate(0, 0, chamberBottomZ + chamberH * 0.5);
+const chamberInner = cylinder(chamberH - 4, chamberInnerR, chamberInnerR, undefined, true)
+  .translate(0, 0, chamberBottomZ + chamberH * 0.5 + 1.2);
+const chamberShell = chamberOuter.subtract(chamberInner);
+
+// Pump head + nozzle.
+const head = box(headW, headD, headH, true).translate(0, 0, headZ);
+const nozzleOuter = cylinder(nozzleL, nozzleR, nozzleR * 0.92, undefined, true)
+  .pointAlong([1, 0, 0])
+  .translate(nozzleCenterX, 0, nozzleZ);
+const nozzleInner = cylinder(nozzleL + 2, 1.5, 1.35, undefined, true)
+  .pointAlong([1, 0, 0])
+  .translate(nozzleCenterX, 0, nozzleZ);
+const nozzle = nozzleOuter.subtract(nozzleInner);
+
+// Stem + piston (moves with the head).
+const pistonH = 7;
+const pistonZ = chamberTopZ - 8 - press * pumpStroke * 0.9;
+const piston = cylinder(pistonH, chamberR - 3.1, chamberR - 3.1, undefined, true).translate(0, 0, pistonZ);
+
+const stemTopZ = headZ - headH * 0.5;
+const stemBottomZ = pistonZ + pistonH * 0.5;
+const stemLen = Math.max(8, stemTopZ - stemBottomZ);
+const stem = cylinder(stemLen, 2.2, 2.2, undefined, true).translate(0, 0, (stemTopZ + stemBottomZ) * 0.5);
+
+// Return spring shown as compressed ring stack.
+const springBottomZ = chamberBottomZ + 8;
+const springTopZ = pistonZ - pistonH * 0.7;
+const springSpan = Math.max(6, springTopZ - springBottomZ);
+const springTurns = 7;
+const springRings = [];
+for (let i = 0; i < springTurns; i++) {
+  const t = i / Math.max(1, springTurns - 1);
+  const z = springBottomZ + t * springSpan;
+  const ringOuter = cylinder(1.2, chamberR - 4.2, chamberR - 4.2, undefined, true).translate(0, 0, z);
+  const ringInner = cylinder(2.4, chamberR - 5.3, chamberR - 5.3, undefined, true).translate(0, 0, z);
+  springRings.push(ringOuter.subtract(ringInner));
+}
+const spring = union(...springRings);
+
+// Dip tube.
+const tubeBottomZ = 8;
+const tubeTopZ = chamberBottomZ + 6;
+const tubeLen = tubeTopZ - tubeBottomZ;
+const tubeOuter = cylinder(tubeLen, 2.5, 2.5, undefined, true).translate(0, 0, (tubeBottomZ + tubeTopZ) * 0.5);
+const tubeInner = cylinder(tubeLen + 2, 1.2, 1.2, undefined, true).translate(0, 0, (tubeBottomZ + tubeTopZ) * 0.5);
+const dipTube = tubeOuter.subtract(tubeInner);
+
+// Check valves: inlet opens during release, outlet opens during press.
+const inletSeatZ = chamberBottomZ + 3;
+const outletSeatZ = chamberTopZ - 7;
+const inletValve = sphere(2.7).translate(0, 0, inletSeatZ + release * 2.4);
+const outletValveR = 2.2;
+const outletSeatClearance = 0.35;
+const outletSeatX = chamberInnerR - outletValveR - outletSeatClearance;
+const outletValve = sphere(outletValveR).translate(outletSeatX - press * 0.9, 0, outletSeatZ + 0.6 + press * 0.9);
+
+// Stylized liquid storyboarding (no simulation).
+const drawPhase = clamp01(progress / 0.55);
+const pushPhase = clamp01((progress - 0.42) / 0.34);
+
+const reservoirLevel = bodyH * 0.62;
+const reservoir = cylinder(reservoirLevel, bodyR - wall - 1, bodyR - wall - 1)
+  .translate(0, 0, 4 + reservoirLevel * 0.5);
+
+const tubeSlugH = 6 + drawPhase * (tubeLen - 10);
+const tubeLiquid = cylinder(tubeSlugH, 1.1, 1.1, undefined, true)
+  .translate(0, 0, tubeBottomZ + tubeSlugH * 0.5);
+
+const chamberLiquidH = Math.max(2, 9 + drawPhase * 17 - pushPhase * 16);
+const chamberLiquid = cylinder(chamberLiquidH, chamberR - 4.8, chamberR - 4.8, undefined, true)
+  .translate(0, 0, chamberBottomZ + 4 + chamberLiquidH * 0.5);
+
+const flowIn = clamp01((progress - 0.45) / 0.2);
+const flowOut = 1 - clamp01((progress - 0.8) / 0.15);
+const nozzleFlow = clamp01(flowIn * flowOut);
+const nozzleLiquidLen = Math.max(1, 1 + nozzleFlow * (nozzleL - 3));
+const nozzleLiquid = cylinder(nozzleLiquidLen, 1.05, 0.95, undefined, true)
+  .pointAlong([1, 0, 0])
+  .translate(nozzleRootX + nozzleLiquidLen * 0.5, 0, nozzleZ);
+
+const dropPhase = clamp01((progress - 0.68) / 0.32);
+const dropR = dropPhase * 2.1;
+const dropFall = clamp01((dropPhase - 0.45) / 0.55);
+const droplet = dropR > 0.12
+  ? sphere(dropR).translate(nozzleTipX + 1.5, 0, nozzleZ - 2 - dropFall * 16)
+  : null;
+
+const liquidParts = [reservoir, tubeLiquid, chamberLiquid, nozzleLiquid];
+if (droplet) liquidParts.push(droplet);
+const liquid = union(...liquidParts);
+
+const pumpMetal = union(chamberShell, dipTube, stem, piston, spring, nozzle);
+const pumpHead = head;
+
+return [
+  { name: "Bottle", shape: bottle, color: "#f4f1ea" },
+  { name: "Pump Head", shape: pumpHead, color: "#303840" },
+  { name: "Pump Mechanics", shape: pumpMetal, color: "#a9b2bb" },
+  { name: "Inlet Valve", shape: inletValve, color: "#6f7a85" },
+  { name: "Outlet Valve", shape: outletValve, color: "#6f7a85" },
+  { name: "Liquid (Stylized)", shape: liquid, color: "#4fa6d8" },
+];

package/examples/modern-tv.forge.js

@@ -0,0 +1,86 @@
+// Modern Flat-Screen TV
+// Ultra-thin panel with bottom electronics bulge, narrow bezels,
+// V-shaped stand legs, and cable management hole
+
+const screenW = param("Screen Width", 1100, { min: 800, max: 1600, unit: "mm" });
+const aspect = param("Aspect Ratio", 1.78, { min: 1.33, max: 2.35, step: 0.01 });
+const bezel = param("Bezel", 6, { min: 3, max: 20, unit: "mm" });
+const thinD = param("Thin Section", 8, { min: 5, max: 20, unit: "mm" });
+const bulgeD = param("Bulge Depth", 35, { min: 20, max: 60, unit: "mm" });
+const bulgeH = param("Bulge Height", 120, { min: 60, max: 200, unit: "mm" });
+const standSpread = param("Stand Spread", 500, { min: 200, max: 800, unit: "mm" });
+const standD = param("Stand Depth", 220, { min: 120, max: 350, unit: "mm" });
+const standH = param("Stand Height", 40, { min: 15, max: 80, unit: "mm" });
+const legW = param("Leg Width", 30, { min: 15, max: 60, unit: "mm" });
+
+// Derived
+const screenH = screenW / aspect;
+const totalW = screenW + bezel * 2;
+const totalH = screenH + bezel * 2;
+const panelZ = standH; // panel bottom sits on stand
+
+// --- Thin panel (upper portion) ---
+const thinPanel = box(totalW, thinD, totalH, true)
+  .translate(0, 0, panelZ + totalH / 2);
+
+// --- Electronics bulge (bottom-back of panel) ---
+const bulge = box(totalW * 0.7, bulgeD, bulgeH, true)
+  .translate(0, -(bulgeD - thinD) / 2, panelZ + bulgeH / 2);
+
+const panelBody = union(thinPanel, bulge);
+
+// --- Screen (dark inset on front face) ---
+const screenDepth = 1;
+const screen = box(screenW, screenDepth + 1, screenH, true)
+  .translate(0, thinD / 2, panelZ + totalH / 2);
+
+const panel = panelBody.subtract(screen);
+
+// --- Stand: two V-shaped legs ---
+// Each leg is a flat slab angled outward from center
+const legThick = 8;
+const halfSpread = standSpread / 2;
+
+const makeLeg = (side) => {
+  // Leg runs from center-bottom of panel outward to the foot
+  const footX = side * halfSpread;
+  const legLen = Math.sqrt(halfSpread * halfSpread + standD * standD / 4);
+
+  // Simple approach: a box rotated to angle from center to foot
+  const angle = Math.atan2(halfSpread, standD / 2) * 180 / Math.PI;
+
+  return box(legW, legLen, legThick, true)
+    .rotate(0, 0, side * angle)
+    .translate(side * halfSpread / 2, 0, standH / 2);
+};
+
+const leftLeg = makeLeg(-1);
+const rightLeg = makeLeg(1);
+
+// Foot pads (flat rectangles at leg ends)
+const footW = legW + 10;
+const footD = 40;
+const footH = 4;
+const leftFoot = box(footW, footD, footH, true)
+  .translate(-halfSpread, 0, footH / 2);
+const rightFoot = box(footW, footD, footH, true)
+  .translate(halfSpread, 0, footH / 2);
+
+// Center bridge connecting legs to panel
+const bridge = box(legW * 2, legThick, standH, true)
+  .translate(0, 0, standH / 2);
+
+const stand = union(leftLeg, rightLeg, leftFoot, rightFoot, bridge);
+
+// --- Cable hole (through the bridge) ---
+const cableHole = cylinder(legThick + 2, 10)
+  .rotate(90, 0, 0)
+  .translate(0, 0, standH / 2);
+
+const standFinal = stand.subtract(cableHole);
+
+return [
+  { name: "Panel", shape: panel, color: "#1a1a1a" },
+  { name: "Screen", shape: screen, color: "#050515" },
+  { name: "Stand", shape: standFinal, color: "#2a2a2a" },
+];

package/examples/picture-frame.forge.js

@@ -0,0 +1,34 @@
+// Picture Frame — parametric wall frame with optional mat border
+
+const frameW = param("Frame Width", 120, { min: 60, max: 250, unit: "mm" });
+const frameH = param("Frame Height", 160, { min: 80, max: 300, unit: "mm" });
+const border = param("Border Width", 12, { min: 5, max: 30, unit: "mm" });
+const depth = param("Frame Depth", 8, { min: 3, max: 20, unit: "mm" });
+const mat = param("Mat Width", 8, { min: 0, max: 20, unit: "mm" });
+const matDepth = param("Mat Depth", 2, { min: 1, max: 5, unit: "mm" });
+
+// Outer frame
+const outer = box(frameW, frameH, depth);
+const opening = box(frameW - 2 * border, frameH - 2 * border, depth + 2)
+  .translate(border, border, -1);
+const frame = outer.subtract(opening);
+
+// Mat insert (thinner, slightly smaller opening)
+const parts = [{ name: "Frame", shape: frame, color: "#5c3a1e" }];
+
+if (mat > 0) {
+  const matOuter = box(frameW - 2 * border, frameH - 2 * border, matDepth)
+    .translate(border, border, 0);
+  const matHole = box(
+    frameW - 2 * border - 2 * mat,
+    frameH - 2 * border - 2 * mat,
+    matDepth + 2
+  ).translate(border + mat, border + mat, -1);
+  parts.push({ name: "Mat", shape: matOuter.subtract(matHole), color: "#f5f0e8" });
+}
+
+// Back panel
+const back = box(frameW - 2, frameH - 2, 1).translate(1, 1, -1);
+parts.push({ name: "Back", shape: back, color: "#3a3a3a" });
+
+return parts;

package/examples/robot_hand.forge.js

@@ -0,0 +1,393 @@
+// Parametric Robot Hand
+// Design goals:
+// 1) Home-buildable with FDM printing + metal pins + cord tendon
+// 2) Clear mechanics: clevis joints, hinge pins, tendon guides, soft pads
+// 3) Mount included: base, mast, wrist clevis
+// 4) Iterative construction: build primitives -> segments -> fingers -> full assembly
+
+const grip = param("Grip", 55, { min: 0, max: 100, unit: "%" });
+const fingerSpread = param("Finger Spread", 18, { min: 0, max: 35, unit: "°" });
+const thumbOpposition = param("Thumb Opposition", 42, { min: 20, max: 70, unit: "°" });
+const wristPitch = param("Wrist Pitch", 8, { min: -35, max: 45, unit: "°" });
+const explode = param("Explode", 0, { min: 0, max: 26, unit: "mm" });
+
+const scale = param("Scale", 1.0, { min: 0.75, max: 1.25, step: 0.01 });
+const pinD = param("Pin Diameter", 3.2, { min: 2.0, max: 5.0, step: 0.1, unit: "mm" }) * scale;
+const jointClearance = param("Joint Clearance", 0.32, { min: 0.2, max: 0.7, step: 0.02, unit: "mm" }) * scale;
+const wall = param("Min Wall", 2.4, { min: 1.6, max: 4.0, step: 0.1, unit: "mm" }) * scale;
+
+// Core hand dimensions
+const palmW = 84 * scale;
+const palmD = 76 * scale;
+const palmT = 18 * scale;
+
+const fingerCount = 4;
+const fingerWidths = [15, 16, 15, 14].map(v => v * scale);
+const fingerLengths = [
+  [36, 25, 19],
+  [39, 28, 21],
+  [37, 27, 20],
+  [31, 23, 18],
+].map(row => row.map(v => v * scale));
+
+const thumbWidth = 16 * scale;
+const thumbLengths = [31, 25, 20].map(v => v * scale);
+
+const lugGap = pinD + 2.3 * jointClearance;
+const lugWidth = Math.max(wall * 1.4, (thumbWidth - lugGap) * 0.45);
+const lugDepth = Math.max(9 * scale, pinD * 2.7);
+const segmentThick = 14 * scale;
+const pinR = pinD * 0.5;
+
+function clamp(v, lo, hi) {
+  return Math.max(lo, Math.min(hi, v));
+}
+
+function rad(deg) {
+  return deg * Math.PI / 180;
+}
+
+function rotateZ2D(x, y, deg) {
+  const a = rad(deg);
+  const c = Math.cos(a);
+  const s = Math.sin(a);
+  return [x * c - y * s, x * s + y * c];
+}
+
+function localToWorld(localPt, basePt, yawDeg) {
+  const [rx, ry] = rotateZ2D(localPt[0], localPt[1], yawDeg);
+  return [basePt[0] + rx, basePt[1] + ry, basePt[2] + localPt[2]];
+}
+
+// Clevis mount with pin bore centered at origin
+function makeClevis(width, height, depth, gap, lugW, boreR) {
+  const left = box(lugW, depth, height, true).translate(-(gap * 0.5 + lugW * 0.5), -depth * 0.5, 0);
+  const right = box(lugW, depth, height, true).translate(gap * 0.5 + lugW * 0.5, -depth * 0.5, 0);
+  const bridge = box(width, depth * 0.55, height * 0.55, true).translate(0, -depth * 0.78, 0);
+  const raw = union(left, right, bridge);
+  const bore = cylinder(width + 2, boreR).pointAlong([1, 0, 0]);
+  return raw.subtract(bore);
+}
+
+// Single-lug hinge ear centered at origin, extending +Y
+function makeHingeEar(width, height, depth, boreR) {
+  const ear = union(
+    cylinder(width * 0.62, height * 0.45).pointAlong([1, 0, 0]).translate(0, 0, 0),
+    box(width * 0.62, depth * 0.9, height * 0.85, true).translate(0, depth * 0.45, 0)
+  );
+  const bore = cylinder(width + 2, boreR).pointAlong([1, 0, 0]);
+  return ear.subtract(bore);
+}
+
+// Printable phalanx: base ear + body + optional front clevis + tendon channel
+function makePhalanxPart(length, width, thick, hasFrontClevis, frontScale = 1.0) {
+  const body = roundedRect(width * 0.72, length, Math.max(2.0 * scale, width * 0.12), true)
+    .extrude(thick * 0.82, { center: true })
+    .translate(0, length * 0.5, 0);
+
+  const baseEar = makeHingeEar(width, thick, lugDepth, pinR + jointClearance * 0.6)
+    .translate(0, 0, 0);
+
+  const topRib = box(width * 0.36, length * 0.72, thick * 0.22, true).translate(0, length * 0.52, thick * 0.28);
+  const bottomRib = box(width * 0.36, length * 0.72, thick * 0.18, true).translate(0, length * 0.52, -thick * 0.28);
+
+  let part = union(body, baseEar, topRib, bottomRib);
+
+  if (hasFrontClevis) {
+    const frontW = width * frontScale;
+    const frontClevis = makeClevis(frontW, thick * 0.9, lugDepth * 0.95, lugGap, lugWidth, pinR + jointClearance * 0.7)
+      .translate(0, length, 0);
+    part = union(part, frontClevis);
+  } else {
+    const tipCap = sphere(width * 0.28).scale([1.0, 1.35, 0.75]).translate(0, length + width * 0.15, 0);
+    part = union(part, tipCap);
+  }
+
+  const tendonChannel = cylinder(length + lugDepth * 0.8, Math.max(1.3 * scale, pinR * 0.55))
+    .pointAlong([0, 1, 0])
+    .translate(0, length * 0.55, thick * 0.1);
+
+  return part.subtract(tendonChannel);
+}
+
+function jointAnglesFromGrip(gripPercent, isThumb) {
+  const g = clamp(gripPercent / 100, 0, 1);
+  if (isThumb) {
+    return [
+      8 + g * 40,
+      10 + g * 55,
+      8 + g * 62,
+    ];
+  }
+  return [
+    6 + g * 46,
+    10 + g * 64,
+    6 + g * 58,
+  ];
+}
+
+function makeFingerAssembly(opts) {
+  const {
+    name,
+    basePivot,
+    yawDeg,
+    widths,
+    lengths,
+    angles,
+    color,
+    isThumb,
+    showCable,
+  } = opts;
+
+  const parts = [];
+  const pivots = [];
+  const localTipPts = [];
+
+  let accum = 0;
+  let py = 0;
+  let pz = 0;
+
+  for (let i = 0; i < lengths.length; i += 1) {
+    const segLen = lengths[i];
+    const segW = widths[i];
+    const hasFront = i < lengths.length - 1;
+    const a = angles[i] || 0;
+    accum += a;
+    const localPart = makePhalanxPart(segLen, segW, segmentThick * (isThumb ? 0.9 : 1.0), hasFront, 0.94);
+
+    const worldBase = localToWorld([0, py, pz], basePivot, yawDeg);
+    const part = localPart
+      .rotate(accum, 0, 0)
+      .rotate(0, 0, yawDeg)
+      .translate(worldBase[0], worldBase[1], worldBase[2])
+      .translate(0, 0, explode * i * 0.08);
+
+    parts.push({
+      name: `${name} Segment ${i + 1}`,
+      shape: part.color(color),
+    });
+
+    const pinLen = segW + wall * 2.4;
+    const pin = cylinder(pinLen, pinR * 0.92)
+      .pointAlong([1, 0, 0])
+      .rotate(0, 0, yawDeg)
+      .translate(worldBase[0], worldBase[1], worldBase[2])
+      .translate(0, 0, explode * i * 0.08)
+      .color('#B0B7C3');
+
+    parts.push({
+      name: `${name} Pin ${i + 1}`,
+      shape: pin,
+    });
+
+    pivots.push(worldBase);
+
+    py += segLen * Math.cos(rad(accum));
+    pz += segLen * Math.sin(rad(accum));
+    localTipPts.push(localToWorld([0, py, pz], basePivot, yawDeg));
+  }
+
+  const pad = sphere(widths[widths.length - 1] * 0.34)
+    .scale([1, 1.25, 0.7])
+    .translate(localTipPts[localTipPts.length - 1][0], localTipPts[localTipPts.length - 1][1], localTipPts[localTipPts.length - 1][2])
+    .translate(0, 0, -widths[widths.length - 1] * 0.08)
+    .color('#2E2E2E');
+
+  parts.push({ name: `${name} Soft Pad`, shape: pad });
+
+  if (showCable) {
+    let cable = null;
+    const cableR = Math.max(0.6 * scale, pinR * 0.3);
+    for (let i = 0; i < pivots.length - 1; i += 1) {
+      const a = pivots[i];
+      const b = pivots[i + 1];
+      const dx = b[0] - a[0];
+      const dy = b[1] - a[1];
+      const dz = b[2] - a[2];
+      const len = Math.sqrt(dx * dx + dy * dy + dz * dz);
+      const seg = cylinder(len, cableR)
+        .pointAlong([dx, dy, dz])
+        .translate(a[0], a[1], a[2] + segmentThick * 0.28);
+      cable = cable ? union(cable, seg) : seg;
+    }
+    if (cable) {
+      parts.push({ name: `${name} Tendon`, shape: cable.color('#D77C2D') });
+    }
+  }
+
+  return parts;
+}
+
+// Build palm with integrated finger clevises and wrist lug
+function makePalm() {
+  const palmCore = roundedRect(palmW, palmD, 10 * scale, true).extrude(palmT, { center: true })
+    .translate(0, palmD * 0.5, 0);
+
+  const palmHoles = union(
+    slot(palmW * 0.32, palmD * 0.16).translate(0, palmD * 0.5).extrude(palmT + 2, { center: true }),
+    circle2d(palmW * 0.11).translate(-palmW * 0.23, palmD * 0.56).extrude(palmT + 2, { center: true }),
+    circle2d(palmW * 0.10).translate(palmW * 0.24, palmD * 0.42).extrude(palmT + 2, { center: true })
+  );
+
+  let palm = palmCore.subtract(palmHoles);
+
+  const spacing = palmW / (fingerCount + 1);
+  for (let i = 0; i < fingerCount; i += 1) {
+    const x = -palmW * 0.5 + spacing * (i + 1);
+    const clevis = makeClevis(
+      fingerWidths[i] * 0.98,
+      segmentThick * 0.88,
+      lugDepth,
+      lugGap,
+      lugWidth,
+      pinR + jointClearance
+    ).translate(x, palmD, segmentThick * 0.08);
+    palm = union(palm, clevis);
+  }
+
+  const thumbClevis = makeClevis(thumbWidth, segmentThick * 0.86, lugDepth, lugGap, lugWidth, pinR + jointClearance)
+    .rotate(0, 0, -thumbOpposition)
+    .translate(palmW * 0.45, palmD * 0.24, 0);
+
+  const wristEar = makeHingeEar(palmW * 0.45, segmentThick, lugDepth * 1.05, pinR + jointClearance)
+    .rotate(0, 180, 0)
+    .translate(0, 0, 0);
+
+  palm = union(palm, thumbClevis, wristEar);
+
+  return palm.color('#D9D6CF');
+}
+
+// Build mount: printable base + mast + wrist clevis
+function makeMount() {
+  const baseW = 126 * scale;
+  const baseD = 108 * scale;
+  const baseT = 9 * scale;
+  const mastW = 28 * scale;
+  const mastD = 34 * scale;
+  const mastH = 86 * scale;
+
+  let base = roundedRect(baseW, baseD, 8 * scale, true).extrude(baseT, { center: true }).translate(0, -36 * scale, -mastH * 0.52);
+
+  const slotSketchA = slot(20 * scale, 7 * scale).translate(-baseW * 0.28, -36 * scale);
+  const slotSketchB = slot(20 * scale, 7 * scale).translate(baseW * 0.28, -36 * scale);
+  const slotSketchC = slot(20 * scale, 7 * scale).translate(0, -36 * scale - baseD * 0.22);
+  const slotSketchD = slot(20 * scale, 7 * scale).translate(0, -36 * scale + baseD * 0.22);
+  const slots = union(
+    slotSketchA.extrude(baseT + 2, { center: true }).translate(0, 0, -mastH * 0.52),
+    slotSketchB.extrude(baseT + 2, { center: true }).translate(0, 0, -mastH * 0.52),
+    slotSketchC.extrude(baseT + 2, { center: true }).translate(0, 0, -mastH * 0.52),
+    slotSketchD.extrude(baseT + 2, { center: true }).translate(0, 0, -mastH * 0.52)
+  );
+  base = base.subtract(slots);
+
+  const mast = box(mastW, mastD, mastH, true).translate(0, -8 * scale, -mastH * 0.02);
+  const gussetL = polygon([[0, 0], [26 * scale, 0], [0, 28 * scale]])
+    .extrude(6 * scale, { center: true })
+    .rotate(90, 0, 90)
+    .translate(-mastW * 0.5 - 3 * scale, -18 * scale, -mastH * 0.28);
+  const gussetR = gussetL.mirror([1, 0, 0]);
+
+  const wristClevis = makeClevis(palmW * 0.54, segmentThick * 0.98, lugDepth * 1.05, lugGap, lugWidth * 1.1, pinR + jointClearance)
+    .translate(0, 0, 0);
+
+  const wristPin = cylinder(palmW * 0.65, pinR * 0.96)
+    .pointAlong([1, 0, 0])
+    .translate(0, 0, 0)
+    .color('#B0B7C3');
+
+  return {
+    base: base.color('#646B73'),
+    mast: union(mast, gussetL, gussetR).color('#7A828A'),
+    wristClevis: wristClevis.color('#838B92'),
+    wristPin,
+  };
+}
+
+// 1) Mount (fixed reference)
+const mount = makeMount();
+
+// 2) Palm (mechanical hub)
+const palm = makePalm();
+
+// 3) Fingers (iterative generation)
+const handParts = [];
+
+const spacing = palmW / (fingerCount + 1);
+for (let i = 0; i < fingerCount; i += 1) {
+  const x = -palmW * 0.5 + spacing * (i + 1);
+  const side = (i - (fingerCount - 1) * 0.5) / ((fingerCount - 1) * 0.5);
+  const yaw = -side * (fingerSpread * 0.5);
+  const baseAngles = jointAnglesFromGrip(grip, false);
+
+  const finger = makeFingerAssembly({
+    name: `Finger ${i + 1}`,
+    basePivot: [x, palmD, segmentThick * 0.08],
+    yawDeg: yaw,
+    widths: [fingerWidths[i], fingerWidths[i] * 0.92, fingerWidths[i] * 0.86],
+    lengths: fingerLengths[i],
+    angles: baseAngles,
+    color: ['#AAB7C6', '#B8C5D3', '#C4D1DB', '#9FB0C0'][i],
+    isThumb: false,
+    showCable: i === 1 || i === 2,
+  });
+
+  for (const p of finger) {
+    handParts.push(p);
+  }
+}
+
+// 4) Thumb (separate kinematic chain)
+const thumbAngles = jointAnglesFromGrip(grip * 0.95 + 5, true);
+const thumb = makeFingerAssembly({
+  name: "Thumb",
+  basePivot: [palmW * 0.45, palmD * 0.24, 0],
+  yawDeg: -thumbOpposition,
+  widths: [thumbWidth, thumbWidth * 0.92, thumbWidth * 0.86],
+  lengths: thumbLengths,
+  angles: thumbAngles,
+  color: '#B7B9C9',
+  isThumb: true,
+  showCable: true,
+});
+
+for (const p of thumb) {
+  handParts.push(p);
+}
+
+// 5) Wrist articulation: rotate all hand components around wrist pin axis
+const wristRotated = [];
+
+wristRotated.push({ name: "Palm", shape: palm.rotateAround([1, 0, 0], wristPitch, [0, 0, 0]) });
+
+for (const p of handParts) {
+  wristRotated.push({
+    name: p.name,
+    shape: p.shape.rotateAround([1, 0, 0], wristPitch, [0, 0, 0]),
+  });
+}
+
+// 6) Return full inspectable assembly (colors preserved by separate objects)
+return [
+  { name: "Mount Base", shape: mount.base },
+  { name: "Mount Mast", shape: mount.mast },
+  { name: "Wrist Clevis", shape: mount.wristClevis },
+  { name: "Wrist Pin", shape: mount.wristPin },
+  ...wristRotated,
+];
+
+
+/**
+ * 
+* Make a fully functional robot hand. Should be easy to build, maybe even at home with some good tools. Show all the mechanics. Should be able to hold arbitrary shape
+objects. Don't be a perfectionist, but be an artist and an engineer.
+Make sure each component can be manufactured.
+It should be mounted somewhere.
+Make it controllable through params.
+As this is a complex task, break it down to simpler ones, solve them, combine, iterate.
+Read docs/permanent/API/model-building/README.md and examples/api/* to learn about ForgeCAD.
+Call it examples/robot_hand.forge.js
+Don't read any other files in the project, no other examples. It's an isolated experiment.
+Make it reliable, easy to 3D print, robust.
+Use iterative logic in the code.
+ */