> Canonical HTML: https://kerfscript.mylasertools.com/models/stride/

# Stride walking linkage

Stride: Theo Jansen's walking linkage on a standing board. Seven flat links turn on brass bushes in front of the board; turn the crank and the foot traces the scored path, lifting and stepping like a Strandbeest leg.

This design has 56 parts on 4 sheets. Customize it in the [playground](https://kerfscript.mylasertools.com/playground/?model=stride).

## Downloads

- [KerfScript source](https://kerfscript.mylasertools.com/models/stride/stride.kerf)
- [stride-sheet-1.svg](https://kerfscript.mylasertools.com/models/stride/stride-sheet-1.svg)
- [stride-sheet-1.dxf](https://kerfscript.mylasertools.com/models/stride/stride-sheet-1.dxf)
- [stride-sheet-2.svg](https://kerfscript.mylasertools.com/models/stride/stride-sheet-2.svg)
- [stride-sheet-2.dxf](https://kerfscript.mylasertools.com/models/stride/stride-sheet-2.dxf)
- [stride-sheet-3.svg](https://kerfscript.mylasertools.com/models/stride/stride-sheet-3.svg)
- [stride-sheet-3.dxf](https://kerfscript.mylasertools.com/models/stride/stride-sheet-3.dxf)
- [stride-sheet-4.svg](https://kerfscript.mylasertools.com/models/stride/stride-sheet-4.svg)
- [stride-sheet-4.dxf](https://kerfscript.mylasertools.com/models/stride/stride-sheet-4.dxf)

## Parts

| Part | Quantity | Size |
| --- | ---: | --- |
| C crank | 1 | 46 × 16 mm |
| A upper link | 1 | 114 × 14 mm |
| B lower link | 1 | 137.8 × 14 mm |
| R rocker | 1 | 115.6 × 92.1 mm |
| D anchor link | 1 | 92.6 × 14 mm |
| E coupler | 1 | 92.8 × 14 mm |
| F foot | 1 | 78.6 × 141.4 mm |
| Backboard | 3 | 360 × 340 mm |
| Stand foot | 4 | 130 × 35 mm |
| Spacer Z, C to A | 1 | 12 × 12 mm |
| Spacer Z, A to B | 7 | 12 × 12 mm |
| Spacer X, A to R | 1 | 12 × 12 mm |
| Spacer W, D to B | 1 | 12 × 12 mm |
| Spacer W, B to F | 4 | 12 × 12 mm |
| Spacer U, E to F | 1 | 12 × 12 mm |
| Spacer V, R to E | 7 | 12 × 12 mm |
| Spacer Y, R to D | 1 | 12 × 12 mm |
| Spacer Y, board to R | 8 | 12 × 12 mm |
| Handle grip | 6 | 18 × 18 mm |
| Rear crank | 2 | 60 × 20 mm |
| Hex socket | 2 | 18 × 18 mm |
| Fit test | 1 | 130 × 50 mm |

## Settings

| Name | Default | Range or choices |
| --- | --- | --- |
| `unit_scale` | `2` | 1.6 to 2.2 |
| `crank_radius` | `15` | 14 to 15 |
| `link_width` | `10` | 8 to 12 |
| `pivot_clearance` | `0.3` | 0.2 to 0.4 |
| `crank_angle` | `0` | 0 to 360 |
| `output` | `"all"` | All parts, Links, Backboard, Stand feet, Spacers and handle, Fit test |
| `$thickness` | `3` | 2.8 to 3.2 |
| `$kerf` | `0.15` | 0 to 0.25 |

## Source

```kerf
// Stride: Theo Jansen's walking linkage on a standing board. Seven flat
// links turn on brass bushes in front of the board; turn the crank and the
// foot traces the scored path, lifting and stepping like a Strandbeest leg.

/* [Mechanism] */
// Overall size: every Jansen length is multiplied by this
unit_scale = 2; // [1.6:0.1:2.2]
// Crank radius in Jansen units; changes the shape of the foot path
crank_radius = 15; // [14:0.5:15]
// Width of the links in mm, whatever the scale
link_width = 10; // [8:1:12]

/* [Fit] */
// Added to the 6 mm holes the brass bushes turn in
pivot_clearance = 0.3; // [0.2:0.05:0.4]

/* [Assembly] */
// Crank angle in the assembled view
crank_angle = 0; // [0:5:360]

/* [Export] */
// All parts, or one group at a time
output = "all"; // [all:All parts, links:Links, frame:Backboard, feet:Stand feet, accessories:Spacers and handle, coupon:Fit test]

/* [Material] */
// Sheet thickness
$thickness = 3; // [2.8:0.1:3.2]
// Beam width
$kerf = 0.15; // [0:0.01:0.25]

/* [Hidden] */
$material = "plywood";
$sheet = [600, 400];
$gap = 5;
$fn = 96;
s = unit_scale;
t = $thickness;
r = link_width / 2;
hole = 6 + pivot_clearance;
assert(s >= 1.6 && s <= 2.2, "Scale: 1.6 to 2.2");
assert(crank_radius >= 14 && crank_radius <= 15, "Crank radius: 14 to 15");
assert(link_width >= 8 && link_width <= 12, "Link width: 8 to 12 mm");
assert(pivot_clearance >= 0.2 && pivot_clearance <= 0.4, "Pivot clearance: 0.2 to 0.4 mm");
assert(t >= 2.8 && t <= 3.2, "Thickness: 2.8 to 3.2 mm");
assert($kerf >= 0 && $kerf <= 0.25, "Kerf: 0 to 0.25 mm");
assert(crank_angle >= 0 && crank_angle <= 360, "Crank angle: 0 to 360 degrees");
assert(contains(["all", "links", "frame", "feet", "accessories", "coupon"], output), "Unknown output");

function polar(rad, a) = [rad * cos(a), rad * sin(a)];
// Where circles round p (radius rad) and q (radius rad2) cross; sgn picks the side
function meet(p, rad, q, rad2, sgn) = let (v = q - p, d = norm(v), a = (rad * rad - rad2 * rad2 + d * d) / (2 * d), h = sqrt(max(0, rad * rad - a * a)))
  p + v * a / d + [-v[1], v[0]] * h / d * sgn;
// Joints O, Y, Z, X, W, V, U, T at crank angle theta: Jansen's lengths, scaled
function joints(theta) = let (
  O = [0, 0],
  Y = [-38, -7.8],
  Z = polar(crank_radius, theta),
  X = meet(Z, 50, Y, 41.5, -1),
  W = meet(Z, 61.9, Y, 39.3, 1),
  V = meet(Y, 40.1, X, 55.8, 1),
  U = meet(V, 39.4, W, 36.7, -1),
  T = meet(W, 49, U, 65.7, 1))
  [for (p = [O, Y, Z, X, W, V, U, T]) p * s];
J = joints(0);
FW = 180 * s;
FH = 170 * s;
// Where the crank axle O sits on the board
origin = [125 * s, 133 * s];

module capsule(a, b, rr) {
  hull() {
    translate(a) circle(r = rr);
    translate(b) circle(r = rr);
  }
}

module rod(a, b, n) {
  difference() {
    union() {
      capsule(a, b, r);
      translate(a) circle(r = 7);
      translate(b) circle(r = 7);
    }
    translate(a) circle(d = hole);
    translate(b) circle(d = hole);
  }
  score() line(a, b);
  score() translate((a + b) / 2 + [0, -1.5]) text(n, size = 3, halign = "center");
}

module triangle(a, b, c, n) {
  difference() {
    union() {
      capsule(a, b, r);
      capsule(b, c, r);
      capsule(c, a, r);
      for (p = [a, b, c]) translate(p) circle(r = 7);
    }
    for (p = [a, b, c]) translate(p) circle(d = hole);
  }
  score() translate((a + b) / 2 + [0, -1.5]) text(n, size = 3, halign = "center");
}

module crank() {
  difference() {
    capsule([0, 0], [crank_radius * s, 0], 8);
    circle(d = 4.4);
    translate([crank_radius * s, 0]) circle(d = hole);
  }
  score() line([0, 0], [crank_radius * s, 0]);
}

module frame() {
  difference() {
    rect([FW, FH], r = 8);
    translate(origin) circle(d = 6.2);
    translate(origin + J[1]) circle(d = 4.4);
    // Slots for the two stand feet
    for (x = [25 * s, 155 * s]) translate([x - t, 0]) rect([2 * t, 15]);
  }
  // The path the foot T follows through a full turn
  score() polyline([for (a = [0:2:360]) origin + joints(a)[7]]);
  score() translate([FW / 2, FH - 18]) text("STRIDE", size = 12, halign = "center");
  score() translate([FW / 2, FH - 30]) text("JANSEN LINKAGE / TURN SLOWLY", size = 4, halign = "center");
  score() translate(origin + [9, 0]) text("O", size = 4);
  score() translate(origin + J[1] + [-9, 0]) text("Y", size = 4);
}

module stand_foot() {
  difference() {
    rect([130, 35], r = 3);
    translate([65 - 1.5 * t, 15]) rect([3 * t, 22]);
  }
}

module disc(d, inner) {
  difference() {
    circle(d = d);
    circle(d = inner);
  }
}

// Spacer rings on the bushes: the joints and layers they sit between, the gap
// in mm, then the joint (O Y Z X W V U T) and the layer they start from
spacers = [
  ["Z, C to A", 5, 2, "C"],
  ["Z, A to B", 2 * t + 15, 2, "A"],
  ["X, A to R", 5, 3, "A"],
  ["W, D to B", 5, 4, "D"],
  ["W, B to F", t + 10, 4, "B"],
  ["U, E to F", 5, 6, "E"],
  ["V, R to E", 2 * t + 15, 5, "R"],
  ["Y, R to D", 5, 1, "R"],
  ["Y, board to R", 10 + 2 * (t + 5), 1, ""]
];

// The assembled view, z up from the table, the board's front face at y = 0
// and the links in front of it (towards -y), back to front C A R D B E F,
// each one t + 5 mm further out. A link drawn along x from its first joint
// turns to point at its second; the rocker and foot, drawn where they sit at
// crank angle 0, turn about their first joint.
P = joints(crank_angle);
function depth(layer) = layer == "" ? 0 : 10 + search(layer, "CARDBEF") * (t + 5) + t;
function front(j, d) = [origin.x + P[j].x, -d, origin.y + P[j].y];
function heading(i, j) = let (v = P[j] - P[i]) atan2(v[1], v[0]);
function face(a) = [90, -a, 0];
function link_at(layer, i) = front(i, depth(layer) - t);
// The rocker or foot, turned about joint i as it swings from J to P
function swing(i, j) = let (v = J[j] - J[i]) heading(i, j) - atan2(v[1], v[0]);
function pivoted(layer, i, j) = let (b = swing(i, j), w = [-J[i].x * cos(b) + J[i].y * sin(b), -J[i].x * sin(b) - J[i].y * cos(b)])
  link_at(layer, i) + [w.x, 0, w.y];
// Behind the board: the hex socket, two rear cranks and the handle grip
turn = crank_angle - 70;
behind = -3 * t - 1;
function on_axle(d) = [origin.x, -d, origin.y];

// Steps are numbered in the order they first run, so name them here in build order
step("Glue the three backboards together and stand them in the feet") {}
step("Fit the links on brass bushes, back to front, with the spacer rings between them") {}
step("Fit the hex sockets, the rear cranks and the handle grip on the spindle") {}
if (output == "all" || output == "links") step("Fit the links on brass bushes, back to front, with the spacer rings between them") {
  part("C crank", at = link_at("C", 0), rotate = face(crank_angle)) crank();
  part("A upper link", at = link_at("A", 2), rotate = face(heading(2, 3))) rod([0, 0], [50 * s, 0], "A");
  part("B lower link", at = link_at("B", 2), rotate = face(heading(2, 4))) rod([0, 0], [61.9 * s, 0], "B");
  part("R rocker", at = pivoted("R", 1, 3), rotate = face(swing(1, 3))) triangle(J[1], J[3], J[5], "R");
  part("D anchor link", at = link_at("D", 1), rotate = face(heading(1, 4))) rod([0, 0], [39.3 * s, 0], "D");
  part("E coupler", at = link_at("E", 5), rotate = face(heading(5, 6))) rod([0, 0], [39.4 * s, 0], "E");
  part("F foot", at = pivoted("F", 4, 6), rotate = face(swing(4, 6))) triangle(J[4], J[6], J[7], "F");
}
if (output == "all" || output == "frame") step("Glue the three backboards together and stand them in the feet") part("Backboard", qty = 3, at = [for (k = [1:3]) [0, k * t, 0]], rotate = face(0)) frame();
// Two plies each, standing across the board under its ends
if (output == "all" || output == "feet")
  step("Glue the three backboards together and stand them in the feet")
    part("Stand foot", qty = 4, at = [for (x = [25, 155], k = [0:1]) [x * s - t + k * t, 1.5 * t - 65, 0]], rotate = [90, 0, 90]) stand_foot();
if (output == "all" || output == "accessories") {
  // As many rings as fit each gap; make up the rest with metal shims
  step("Fit the links on brass bushes, back to front, with the spacer rings between them")
    for (sp = spacers) let (n = floor(sp[1] / t))
      part(str("Spacer ", sp[0]), qty = n, at = [for (k = [0:n - 1]) front(sp[2], depth(sp[3]) + k * t)], rotate = face(0)) disc(12, 6.4);
  step("Fit the hex sockets, the rear cranks and the handle grip on the spindle") {
    part("Handle grip", qty = 6, at = [for (k = [1:6]) on_axle(behind - 3 * t - k * t) + [40 * cos(turn), 0, 40 * sin(turn)]], rotate = face(turn))
      disc(18, hole);
    part("Rear crank", qty = 2, at = [on_axle(behind - t), on_axle(behind - 2 * t)], rotate = face(turn)) difference() {
      capsule([0, 0], [40, 0], 10);
      circle(d = 4.4);
      translate([40, 0]) circle(d = 4.4);
    }
    // One in front of the crank C, one behind the board under the rear cranks
    part("Hex socket", qty = 2, at = [on_axle(depth("C")), on_axle(behind - 3 * t)], rotate = [face(crank_angle), face(turn)]) difference() {
      circle(d = 18);
      circle(d = 8.31, $fn = 6);
    }
  }
}
// The fit test lies on the table beside the board
if (output == "all" || output == "coupon") part("Fit test", at = [FW + 20, -60, 0]) {
  difference() {
    rect([130, 50], r = 3);
    for (i = [0:3]) translate([18 + 28 * i, 18]) circle(d = 6.1 + 0.1 * i);
    translate([20, 35]) circle(d = 4.4);
    translate([45, 32]) rect([3 * t, 12]);
    translate([80, 32]) rect([2 * t, 12]);
  }
  for (i = [0:3]) score() translate([18 + 28 * i, 5]) text(str(6.1 + 0.1 * i), size = 3, halign = "center");
}

echo(str("Board ", FW, " x ", FH, " mm; crank radius ", crank_radius * s, " mm"));

// Assembly: glue the three backboards together and stand them in the two
// feet (two plies each). The links go in front of the board on 6 mm brass
// bushes, back to front in this order: C, A, R, D, B, E, F, with a rear face
// every t + 5 mm from 10 mm out. Thread the spacer rings onto the bushes
// between the layers they are named for. The M4 spindle at O turns the front
// crank C and, behind the board, the rear crank with its handle grip.
```

Set power, speed and cut order in your laser software. See the [laser software guide](https://kerfscript.mylasertools.com/docs/compatibility/index.md).
