Model Editor Workflows

Multi-step recipes you can paste into the Script Editor while the Model Editor is open. Each one builds, queries, or transforms geometry across several methods, and verifies the result with console.log or an inline check.

File I/O

Parent / unparent / delete nodes, add an image plane, and clear the scene

Spawn nodes; parent and unparent them; add an image plane; open a project; delete the nodes; clear the scene.

Methods usedModelEditor.io.newScene ModelEditor.io.openScene ModelEditor.create.imagePlane ModelEditor.scene.select ModelEditor.scene.delete ModelEditor.create.cube Utils.wait.frame node.translate node.setParent node.unparent

Example

const parent = await create.cube({ name: 'ParentBox' });
parent.translate.set([2.5, 1.3, -0.7]); select(null, {mode: 'clear'});
const child = await create.cube({ name: 'ChildBox' });
child.translate.set([5.0, 1.3, -0.7]); select(null, {mode: 'clear'});
await Utils.wait.frame();

child.setParent(parent);
console.log('parented child to parent');

child.unparent();
console.log('unparented child');

async function probe(label, fn) {
  try {
    await fn();
    console.log(label, 'ok');
  } catch (err) {
    console.log(label, 'skipped:', err.message);
  }
}

await probe('imagePlane', () => create.imagePlane({}));
await probe('openScene', () => io.openScene());

parent.delete();
child.delete();
console.log('deleted both meshes');

// newScene clears everything; call last. Guard since a save-reconcile
// modal can block the call when the scene is dirty.
try {
  await io.newScene();
  console.log('newScene fired');
} catch (err) {
  console.log('newScene blocked or unavailable:', err.message);
}

What you'll seeconsole: parent/unparent ops; imagePlane and openScene probes; final clear-scene result.

Open in editor →

Viewport & Camera

Toggle viewport display modes + gizmo settings

Control wireframe / x-ray / backface-cull / transform-mode / pivot-mode / snap-mode / grid-unit getters and setters.

Example

viewport.setWireframe(true);
viewport.setXray(true);
viewport.setBackfaceCull(true);
await Utils.wait.frame();
console.log('wireframe:', viewport.wireframe, 'xray:', viewport.xray, 'backfaceCull:', viewport.backfaceCull);

viewport.setTransformMode('rotate');
viewport.setPivotMode('boundingBox');
await Utils.wait.frame();
console.log('transformMode:', viewport.transformMode, 'pivotMode:', viewport.pivotMode);

viewport.setSnapMode({ translate: true, rotate: false, scale: false }, true);
await Utils.wait.frame();
const snap = viewport.snapMode;
console.log('snap:', snap.translate, snap.rotate, snap.scale);

viewport.setGridUnit('m');
viewport.setShowGrid(true);
await Utils.wait.frame();
console.log('gridUnit:', viewport.gridUnit, 'grid:', viewport.showGrid);

viewport.toggleOrtho();
await Utils.wait.frame();
console.log('ortho?', viewport.isOrtho);
viewport.toggleWireframe();
viewport.toggleXray();
viewport.toggleGrid();
await Utils.wait.frame();
console.log('final wireframe:', viewport.wireframe, 'xray:', viewport.xray, 'grid:', viewport.showGrid);

What you'll seeconsole: per-toggle current state; final view in ortho mode with wireframe.

Open in editor →

Toggle render modes, component modes, and sculpt mode in the Model editor

Frame view; flip wireframe / xray / backface-cull / grid / normals / live-snap; cycle render and component modes; enter and exit sculpt mode.

Example

const cube = await create.cube({ name: 'ModeProbe' });
cube.translate.set([2.5, 1.3, -0.7]);
select(null, {mode: 'clear'});
await Utils.wait.frame();

viewport.frameAll();
viewport.frameSelection();

const renderBefore = viewport.renderMode;
viewport.setRenderMode('clay');
console.log('renderMode ' + renderBefore + ' → ' + viewport.renderMode);

const compBefore = getComponentMode();
setComponentMode('vertex');
console.log('componentMode ' + compBefore + ' → ' + getComponentMode());
setComponentMode('object');

viewport.setBackfaceCull(true);
viewport.setShowGrid(false);
viewport.setShowNormals(false);
viewport.setLiveMeshSnap(false);
viewport.setWireframe(false);
viewport.setXray(false);
console.log('viewport flags set');

const matBefore = getActiveMaterial();
console.log('activeMaterial:', matBefore);

async function probe(label, fn) {
  try {
    await fn();
    console.log(label, 'ok');
  } catch (err) {
    console.log(label, 'skipped:', err.message);
  }
}

// Sculpt enter / exit goes through the SculptSession lifecycle: enter() returns
// a session handle, and you end it by calling .cancel() (or .commit()) on that
// handle rather than a separate exit free-function.
let __sculptSess = null;
await probe('enterSculptMode', async () => { __sculptSess = await tool.sculpt.enter(); });
if (__sculptSess && typeof __sculptSess.cancel === 'function') {
  __sculptSess.cancel();
  console.log('SculptSession.cancel() called');
}

await probe('import', () => io.importModel({}));
await probe('export', () => io.exportFile({ filename: 'probe.glb', format: 'glb' }));
await probe('exportSelection', () => io.exportSelectedModel({ filename: 'sel.glb', format: 'glb' }));

What you'll seeconsole: render/component before/after; sculpt enter/exit; import/export probe.

Open in editor →

Switch active tool and probe pickAt

Cycle through measure / drawline / select tools; read activeTool; raycast viewport coords via pickAt.

Methods usedModelEditor.tool.setActive ModelEditor.tool.active ModelEditor.viewport.pickAt ModelEditor.create.cube Utils.wait.frame node.translate

Example

const cube = await create.cube({ name: 'PickTarget' });
cube.translate.set([2.5, 1.3, -0.7]);
select(null, {mode: 'clear'});
await Utils.wait.frame();

console.log('activeTool initial:', tool.active);

tool.setActive('measure');
console.log('after measure:', tool.active);

tool.setActive('drawline');
console.log('after drawline:', tool.active);

tool.setActive('select');
console.log('after select:', tool.active);

tool.setActive(null);
console.log('after null:', tool.active);

// pickAt: raycast at viewport client coords. Returns null when no hit.
const hit = viewport.pickAt(400, 300);
console.log('pickAt(400, 300):', JSON.stringify(hit ? { meshId: hit.meshId, point: hit.point } : null));

What you'll seeconsole: active tool before/after each switch; pickAt result.

Open in editor →

Geometry & Topology

Tally the surface area of every mesh

Walk every mesh in the asset, read mesh.area and mesh.bbox extents, and log a CSV summary you can copy out.

Methods usedModelEditor.scene.ls mesh.area mesh.bbox

Example

// CSV summary of mesh size and surface area.
const rows = ['name,area,bbX,bbY,bbZ'];
let total = 0;

for (const me of ls({ type: 'mesh' })) {
  const bb = me.bbox();
  const sx = bb.max.x - bb.min.x;
  const sy = bb.max.y - bb.min.y;
  const sz = bb.max.z - bb.min.z;
  rows.push(me.name + ',' + me.area.toFixed(4) + ',' + sx.toFixed(3) + ',' + sy.toFixed(3) + ',' + sz.toFixed(3));
  total += me.area;
}

// Print the CSV so you can copy it straight out of the console.
const csv = rows.join('\n');
console.log(csv);
console.log('total:', rows.length - 1, 'meshes, total area', total.toFixed(4));

What you'll seeA CSV block printed to the console (name,area,bbX,bbY,bbZ) plus a summary line with the total area.

Open in editor →

Mark every vertex of a mesh with a small sphere

Build a low-poly mesh, then mark every vertex with a tiny sphere at its world position and parent the lot under a group. Handy for visually debugging topology.

Methods usedModelEditor.create.cube ModelEditor.create.sphere ModelEditor.create.group mesh.geometry.bbox mesh.verts node.translate

Example

// Self-contained from an EMPTY scene: build a low-poly mesh, then drop a
// tiny sphere on each of its vertices.

// 1. A subdivided cube gives a modest, predictable vertex count to mark.
const mesh = await create.cube({
  width: 2, height: 2, depth: 2,   // 2 m box (>0)
  subdivisionsX: 1,                // extra cuts per axis (0 = box corners only)
  subdivisionsY: 1,
  subdivisionsZ: 1,
  name: 'Topo',
});
select(null, { mode: 'clear' });

// 2. Size the markers relative to the mesh so they stay readable at any scale.
//    bbox lives on mesh.geometry; space 'world' applies the mesh transform.
const bb = mesh.geometry.bbox({ space: 'world' });
const sizeX = bb.max.x - bb.min.x;
const radius = Math.max(0.02, sizeX * 0.04);

// 3. One sphere per vertex. mesh.verts.count = vertex total; mesh.verts
//    .position(i) returns a Vec3 (.x / .y / .z) of the UNDEFORMED position.
const dots = [];
for (let i = 0; i < mesh.verts.count; i++) {
  const p = mesh.verts.position(i);
  const dot = await create.sphere({ radius, widthSegments: 12, heightSegments: 8 });
  dot.translate.set([p.x, p.y, p.z]);
  dots.push(dot);
  select(null, { mode: 'clear' });
}

// 4. Group the markers and report (never a silent no-op). create.group is
//    ASYNC -> await.
const group = await create.group(dots, { name: mesh.name + '_vertDots' });
console.log('marked', mesh.verts.count, 'verts of', mesh.name,
  'with radius', radius.toFixed(4), 'under group', group.name);

What you'll seeconsole: vertex count + sphere radius used; viewport: a small sphere on each vertex, parented under one group.

Open in editor →

Summarize the UV island layout on every mesh

Build a couple of meshes, then read mesh.uv.islands on each: log the island count and per-island UV-space size for a quick "is this UV layout sane" sweep.

Methods usedModelEditor.create.cube ModelEditor.create.cylinder ModelEditor.scene.ls mesh.uv.islands

Example

// Self-contained from an EMPTY scene: build a couple of auto-unwrapped
// meshes, then report their UV-island layout.

// 1. Two meshes with distinct default unwraps (a cube unwraps to 6 islands).
const box = await create.cube({ width: 1, name: 'BoxUV' });
select(null, { mode: 'clear' });
const tube = await create.cylinder({
  radiusTop: 0.5,        // top cap radius (NO 'radius' param on cylinder)
  radiusBottom: 0.5,     // bottom cap radius
  height: 2,             // along Y
  radialSegments: 16,    // sides around the circumference
  heightSegments: 1,     // stacks along the height
  openEnded: false,      // false = capped ends; true = open tube
  name: 'TubeUV',
});
select(null, { mode: 'clear' });

// 2. Walk every mesh and read its islands. Each island carries:
//    index, faceIndices[], loopIndices[], bounds { minU, maxU, minV, maxV }.
let totalIslands = 0;
for (const me of ls({ type: 'mesh' })) {
  const islands = me.uv.islands;
  totalIslands += islands.length;
  console.log(me.name, '->', islands.length, 'UV island' + (islands.length === 1 ? '' : 's'));
  islands.forEach((isl, i) => {
    const b = isl.bounds;
    const w = (b.maxU - b.minU).toFixed(3);   // UV-space width
    const h = (b.maxV - b.minV).toFixed(3);   // UV-space height
    console.log('  [' + i + '] ' + isl.faceIndices.length + ' faces, uvSize=' + w + 'x' + h);
  });
}

// 3. Summary line so it's never a silent no-op.
console.log('total UV islands across all meshes:', totalIslands);

What you'll seeconsole: per-mesh island count; per-island index + UV size + face count.

Open in editor →

Report per-mesh topology stats

Walk every mesh and log face / vertex / edge counts plus surface area. Handy for catching outliers before export.

Methods usedModelEditor.scene.ls mesh.faces mesh.verts mesh.edges mesh.area

Example

// Per-mesh topology summary.
let totalFaces = 0, totalVerts = 0, totalArea = 0;
for (const m of ls({ type: 'mesh' })) {
  console.log(
    m.name,
    'faces=' + m.faces.count,
    'verts=' + m.verts.count,
    'edges=' + m.edges.count,
    'area=' + m.area.toFixed(3),
  );
  totalFaces += m.faces.count;
  totalVerts += m.verts.count;
  totalArea += m.area;
}
console.log('TOTALS faces=' + totalFaces, 'verts=' + totalVerts, 'area=' + totalArea.toFixed(3));

What you'll seeconsole: per-mesh table-like line with faces, verts, edges, area; totals at the bottom.

Open in editor →

Build a cube, sphere, and cylinder and group them

Create three primitive meshes, place them at offset positions so they do not overlap, then wrap them under one named group and log the group bounding box.

Methods usedModelEditor.create.cube ModelEditor.create.sphere ModelEditor.create.cylinder ModelEditor.create.group mesh.bbox node.translate

Example

// Build a 3-primitive scene from an EMPTY Model scene and group it.
// create.* primitives are ASYNC — every one must be awaited.

// 1) Cube — explicit full size + a 2x2x2 subdivision grid (default 0).
const cube = await create.cube({
  width: 1,            // X extent, meters (default 1)
  height: 1,           // Y extent, meters (default 1)
  depth: 1,            // Z extent, meters (default 1)
  subdivisionsX: 2,    // extra cuts along X (default 0)
  subdivisionsY: 2,    // extra cuts along Y (default 0)
  subdivisionsZ: 2,    // extra cuts along Z (default 0)
  name: 'Cube',
});

// 2) Sphere — radius + longitude/latitude ring counts (NO 'size' param).
const sphere = await create.sphere({
  radius: 0.5,         // meters (default 0.5)
  widthSegments: 24,   // longitude rings (default 16 — higher = rounder)
  heightSegments: 16,  // latitude rings (default 12)
  name: 'Sphere',
});

// 3) Cylinder — separate top/bottom radii (NO 'radius'); openEnded caps off.
const cyl = await create.cylinder({
  radiusTop: 0.4,      // top cap radius, meters (default 0.5)
  radiusBottom: 0.6,   // bottom cap radius, meters (default 0.5) — a frustum
  height: 1,           // meters (default 1)
  radialSegments: 24,  // sides around the axis (default 16)
  heightSegments: 2,   // rings up the side (default 1)
  openEnded: false,    // false = capped both ends (default false)
  name: 'Cylinder',
});

// Space them apart along X so they don't overlap. translate is a Vec3Attribute
// whose .set([x, y, z]) batches all three axes into one history command.
cube.translate.set([0, 0, 0]);
sphere.translate.set([1.5, 0, 0]);
cyl.translate.set([3, 0, 0]);

// create.group is ASYNC — pass the child nodes + a name (no empty-name form).
const group = await create.group([cube, sphere, cyl], { name: 'PrimitiveTrio' });

console.log('built:', cube.name, sphere.name, cyl.name);

// Walk the children and log each WORLD-space bounding-box span.
// geometry.bbox(...) returns a BoundingBox with Vec3 .min / .max / .size.
for (const m of [cube, sphere, cyl]) {
  const size = m.geometry.bbox({ space: 'world' }).size; // Vec3 (meters)
  console.log(' ', m.name, 'size',
    size.x.toFixed(2) + ' x ' + size.y.toFixed(2) + ' x ' + size.z.toFixed(2) + ' m');
}

// Group-level span: union of the three child boxes.
const trio = [cube, sphere, cyl];
let minX = Infinity, maxX = -Infinity;
for (const m of trio) {
  const b = m.geometry.bbox({ space: 'world' });
  minX = Math.min(minX, b.min.x);
  maxX = Math.max(maxX, b.max.x);
}
console.log('grouped under "' + group.name + '"; total X span',
  (maxX - minX).toFixed(2) + ' m across', group.children().length, 'children');

What you'll seeconsole: each primitive name + final group bounding-box span; outliner: a new group containing three meshes.

Open in editor →

Subdivide a cube and bend it

Start with a 1m cube, subdivide it twice to add resolution, bend it 60 degrees around the Y axis, and log the before / after vertex count.

Methods usedModelEditor.create.cube mesh.subdivide mesh.bend mesh.verts mesh.faces mesh.bbox

Example

// Subdivide a cube, then bend it, then read back the final shape.
// Self-contained from an empty scene.

// 1) Seed primitive: a tall, thin bar so the bend reads clearly.
const cube = await create.cube({
  width: 1,   // meters
  height: 3,  // tall along Y — this is the bend axis the curl wraps around
  depth: 1,   // meters
  name: 'BentBar',
});

const startVerts = cube.verts.count;   // mesh.verts.count, NOT mesh.numVerts
const startFaces = cube.faces.count;   // mesh.faces.count
console.log('start: V=' + startVerts, 'F=' + startFaces);

// 2) Add resolution so the bend has segments to deform. iterations is the
//    Catmull-Clark pass count (default 1); each pass roughly quadruples faces.
await cube.subdivide({ iterations: 2 });
console.log('after 2 subdivisions: V=' + cube.verts.count, 'F=' + cube.faces.count);

// 3) Bend about the Y axis. angle is in RADIANS (Math.PI/3 = 60 degrees);
//    positive curls one way, negative the other. axis is a letter 'x'|'y'|'z'.
await cube.bend({ axis: 'y', angle: Math.PI / 3 });
console.log('after bend: V=' + cube.verts.count);

// 4) Final shape's WORLD bounding box. Spatial/health queries live under
//    mesh.geometry.*, not flat on the mesh. .size is a Vec3 in meters.
const size = cube.geometry.bbox({ space: 'world' }).size;
console.log('final bbox:',
  size.x.toFixed(3) + ' x ' + size.y.toFixed(3) + ' x ' + size.z.toFixed(3) + ' meters');

What you'll seeconsole: starting / post-subdivide / post-bend vertex count + final bbox size in meters.

Open in editor →

Cut a hole through a cube with a sphere

Build a cube, position a smaller sphere inside it, run a difference boolean, and log the resulting vertex and face counts.

Methods usedModelEditor.create.cube ModelEditor.create.sphere mesh.boolean mesh.verts mesh.faces mesh.bbox node.translate

Example

// Cut a hole through a cube with a sphere — difference boolean.
// A boolean needs TWO meshes, so build both up front.

// 1) The solid being carved.
const cube = await create.cube({
  width: 2, height: 2, depth: 2,  // meters
  name: 'Cube',
});

// 2) The cutter. Make it a smooth sphere so the carved hole reads cleanly.
const sphere = await create.sphere({
  radius: 1,            // meters
  widthSegments: 32,    // longitude rings (default 16) — smoother cut wall
  heightSegments: 24,   // latitude rings (default 12)
  name: 'Cutter',
});

// 3) Slide the cutter half-way out the top (+Y) face so the cut breaks the
//    surface rather than carving a fully enclosed cavity.
sphere.translate.set([0, 1, 0]);

console.log('cube before:    V=' + cube.verts.count, 'F=' + cube.faces.count);
console.log('cutter sphere:  V=' + sphere.verts.count, 'F=' + sphere.faces.count);

// Health + size sanity check BEFORE the cut (geometry namespace).
const before = cube.geometry.bbox({ space: 'world' });
console.log('cube height before cut:', before.size.y.toFixed(2) + 'm',
  '| closed=' + cube.geometry.isClosed, '| manifold=' + cube.geometry.isManifold);

// 4) Subtract: a.boolean(b, 'difference') = a − b. Arguments are POSITIONAL —
//    mode is one of 'union' | 'difference' | 'intersection'. The 'cube' handle
//    is updated in place; the cutter sphere is consumed by the operation.
await cube.boolean(sphere, 'difference');

const after = cube.geometry;
console.log('cube after cut: V=' + cube.verts.count, 'F=' + cube.faces.count);
console.log('carved cube "' + cube.name + '"',
  '| closed=' + after.isClosed, '| holes=' + after.holes, '| shells=' + after.shells);

What you'll seeconsole: cube counts before / after the cut, plus the final face count of the carved cube.

Open in editor →

Extrude a tall tower and bevel its top edges

Take a 1m cube, extrude the top face upward to make a tower, then bevel every edge on the top so it has a soft chamfer.

Methods usedModelEditor.create.cube mesh.extrude mesh.bevel mesh.faces mesh.verts mesh.bbox

Example

// Build a tower by extruding the top face upward, then bevel its top edges.
// Self-contained from an empty scene.

// 1) Seed primitive: a 1m cube. create.cube is ASYNC.
const tower = await create.cube({ width: 1, height: 1, depth: 1, name: 'Tower' });
console.log('start: V=' + tower.verts.count, 'F=' + tower.faces.count);

// 2) Extrude the top face up 4 meters. The component selector key is 'faces'
//    (a face-index array). On a fresh cube the face order is +Y, -Y, +X, -X,
//    +Z, -Z, so index 0 is the top (+Y) face.
//    - faces: explicit face index array (no current-selection assumption)
//    - distance: extrusion length along the face normal, meters
await tower.extrude({ faces: [0], distance: 4 });
console.log('after extrude up 4m: F=' + tower.faces.count);

// Read the WORLD height after extrusion (geometry namespace).
const midHeight = tower.geometry.bbox({ space: 'world' }).size.y;
console.log('mid-step height:', midHeight.toFixed(3) + 'm');

// 3) Bevel the four edges around the top face to soften the silhouette.
//    - edges: edge indices to round into a strip
//    - width: bevel offset, meters (smaller = tighter chamfer)
//    - segments: cross-cuts across the bevel (1 = flat chamfer, >1 = rounder)
await tower.bevel({ edges: [0, 1, 2, 3], width: 0.05, segments: 2 });
console.log('after bevel: V=' + tower.verts.count, 'F=' + tower.faces.count);

const finalHeight = tower.geometry.bbox({ space: 'world' }).size.y;
console.log('final tower "' + tower.name + '" height:', finalHeight.toFixed(3) + 'm');

What you'll seeconsole: face counts after each step + final bbox height.

Open in editor →

Unwrap a cube and pin a UV corner

Create a cube, run an automatic UV unwrap, then pin a single UV so subsequent re-unwraps preserve that corner. Logs the UV count and the pinned position.

Methods usedModelEditor.create.cube UVSet.unwrap UVSet.pin mesh.uv mesh.uv.get mesh.uv.addSet

Example

// Unwrap a cube and pin one UV loop so future re-unwraps leave it in
// place. UV scripting goes through the mesh.uv collection. Self-contained.

// A subdivided cube gives the unwrap more loops to lay out.
const cube = await create.cube({
  width: 1, height: 1, depth: 1,
  subdivisionsX: 2, subdivisionsY: 2, subdivisionsZ: 2,
  name: 'PinnedCube',
});
cube.xform({ t: [2.5, 1.3, -0.7] });
await select(null, { mode: 'clear' });
await Utils.wait.frame();

// uv.count = number of face-corners (loops) on the active channel.
const startLoops = cube.uv.count;
console.log('UV loops before unwrap:', startLoops);

// Auto-unwrap with the smart angle-based projection engine
// ('conformal' preserves angles exactly; 'cube-projection' is blocky).
// setIdx 0 targets the first UV channel.
await cube.uv.unwrap({ strategy: 'smartProject', setIdx: 0 });
console.log('UV islands after unwrap:', cube.uv.islands.length);

// Read loop 0's [u,v] so we know what we're pinning. uv.get() returns a
// flat Float32Array packed [u0, v0, u1, v1, ...].
const uvs = cube.uv.get(0);
const u0 = uvs[0].toFixed(3);
const v0 = uvs[1].toFixed(3);
console.log('pinning UV loop 0 at (' + u0 + ', ' + v0 + ')');

// Pin loops 0 and 1 on channel 0. Pinned loops are held in place by
// subsequent unwrap / relax passes.
await cube.uv.pin({ loops: [0, 1], setIdx: 0 });
console.log('loop 0 pinned?', cube.uv.isPinned(0, 0)); // true
console.log('loop 2 pinned?', cube.uv.isPinned(2, 0)); // false

// Pinning never changes the loop count.
console.log('UV loops after pin:', cube.uv.count, '(unchanged from', startLoops + ')');
console.log('unwrap + pin complete on "' + cube.name + '"');

What you'll seeconsole: number of UVs before / after the unwrap and the pinned UV position.

Open in editor →

Topology query and manifold audit across primitives

Spawn cube + sphere + plane (with explicit deselect between via select(null, {mode: "clear"})); query isClosed / isManifold / holes / shells / triangle counts.

Methods usedModelEditor.create.cube ModelEditor.create.sphere ModelEditor.create.plane mesh.isClosed mesh.isManifold mesh.holes mesh.shells mesh.nonManifoldEdges mesh.nonManifoldVertices mesh.faces node.translate Utils.wait.frame

Example

// Topology + manifold audit across three primitives, built from an empty
// scene. A closed solid (cube), a closed sphere, and an OPEN plane contrast
// the closed/holes/shells readings. Spatial & health queries live under
// mesh.geometry.*, NOT flat on the mesh.

// 1) Subdivided cube — closed solid.
const cube = await create.cube({
  width: 1, height: 1, depth: 1,
  subdivisionsX: 2, subdivisionsY: 2, subdivisionsZ: 2,
  name: 'TopoCube',
});
cube.translate.set([2.5, 1.3, -0.7]);
await select(null, { mode: 'clear' }); // deselect between builds

// 2) Sphere — closed, smooth.
const sphere = await create.sphere({
  radius: 0.8, widthSegments: 24, heightSegments: 16, name: 'TopoSphere',
});
sphere.translate.set([5.0, 1.3, -0.7]);
await select(null, { mode: 'clear' });

// 3) Plane — a single OPEN quad sheet (one boundary loop, not closed).
//    Note: plane uses widthSegments / heightSegments (NOT subdivisionsX/Y).
const plane = await create.plane({
  width: 1, height: 1, widthSegments: 2, heightSegments: 2, name: 'TopoPlane',
});
plane.translate.set([7.5, 1.3, -0.7]);
await select(null, { mode: 'clear' });
await Utils.wait.frame(); // let topology caches settle before reading

for (const m of [cube, sphere, plane]) {
  const g = m.geometry;
  console.log(m.name + ': verts=' + m.verts.count
    + ' faces=' + m.faces.count
    + ' tris=' + m.faces.numTriangles
    + ' area=' + g.area.toFixed(3)
    + ' closed=' + g.isClosed
    + ' manifold=' + g.isManifold
    + ' holes=' + g.holes
    + ' shells=' + g.shells
    + ' badEdges=' + g.nonManifoldEdges.length
    + ' badVerts=' + g.nonManifoldVertices.length);
}
console.log('audit complete: 3 meshes scanned');

What you'll seeconsole: per-mesh closed/manifold/holes/shells/triangle counts.

Open in editor →

Vertex iteration + nearest / within radius queries

Spawn a subdivided cube; forEachVertex + log; query nearestVertices + verticesWithin.

Methods usedModelEditor.create.cube mesh.forEachVertex mesh.nearestVertices mesh.verticesWithin mesh.verts mesh.verts.getPositions node.translate Utils.wait.frame

Example

// Vertex iteration + nearest / within-radius queries on a subdivided cube.
// Self-contained from an empty scene.
const cube = await create.cube({
  width: 2, height: 2, depth: 2,
  subdivisionsX: 2, subdivisionsY: 2, subdivisionsZ: 2,
  name: 'VertCube',
});
cube.translate.set([2.5, 1.3, -0.7]);
await select(null, { mode: 'clear' });
await Utils.wait.frame();

console.log('vert count:', cube.verts.count);

// getPositions returns a FLAT Float32Array [x0,y0,z0, x1,y1,z1, ...].
// Pass space: 'object' for local coords, 'world' to apply the transform.
const pts = cube.verts.getPositions({ space: 'object' });
console.log('first vertex (object):',
  pts[0].toFixed(3), pts[1].toFixed(3), pts[2].toFixed(3));

// verts.forEach((i, total) => ...) visits every vertex index in order.
let counted = 0;
let sumX = 0;
cube.verts.forEach((i, total) => {
  counted++;
  sumX += pts[i * 3]; // accumulate object-space X to confirm we touched each
});
console.log('verts.forEach iterated:', counted, 'of', cube.verts.count,
  '| mean X =', (sumX / counted).toFixed(3));

// verts.nearest(point, k) returns the k closest vertex INDICES. Vertex spatial
// queries read OBJECT space, so query around the local centroid [0, 0, 0].
const nearest = cube.verts.nearest([0, 0, 0], 5); // k = 5 closest
console.log('nearest 5 to local centroid:', JSON.stringify(nearest));

// verts.within(point, radius) returns every vertex INDEX inside the sphere.
const within = cube.verts.within([0, 0, 0], 1.5); // radius = 1.5m, object space
console.log('within 1.5m of local centroid:', within.length, 'verts');

What you'll seeconsole: cube vertex count, point sample, nearest-5 verts, within-radius count.

Open in editor →

Raycast a sphere and place a locator at the hit

Spawn a sphere; raycast from camera origin; place a locator at the hit; query closestPoint to a test position.

Methods usedModelEditor.create.sphere ModelEditor.create.locator mesh.raycast mesh.raycastAll mesh.closestPoint mesh.distanceTo node.translate Utils.wait.frame

Example

// Raycast a sphere, drop a locator at the first hit, then query the nearest
// surface point + signed distance to a test position. Spatial queries live
// under mesh.geometry and take POSITIONAL (origin, dir, {space}) args.
// Self-contained from an empty Model scene.

const sphere = await create.sphere({
  radius: 1.5,
  widthSegments: 32,
  heightSegments: 16,
  name: 'RayTarget',
});
sphere.xform({ t: [2.5, 1.3, -0.7] });
await select(null, { mode: 'clear' });
await Utils.wait.frame();

// Cast a ray from in front of the sphere straight through it (world space).
const origin = [2.5, 1.3, -10];
const dir = [0, 0, 1];
const hit = sphere.geometry.raycast(origin, dir, { space: 'world' }); // {point,normal,faceIdx,distance} | null
if (hit) {
  const p = hit.point; // Vec3 — has .x/.y/.z + .toArray()
  console.log('hit point:', p.x.toFixed(3), p.y.toFixed(3), p.z.toFixed(3));
  console.log('hit normal:', hit.normal.toArray().map((n) => n.toFixed(2)).join(','));
  console.log('hit distance:', hit.distance.toFixed(3), 'faceIdx:', hit.faceIdx);

  // Place a locator right on the hit point (create.locator is synchronous;
  // position can be passed in the opts directly).
  create.locator({ name: 'HitMarker', position: [p.x, p.y, p.z] });
}
await select(null, { mode: 'clear' });

// raycastAll returns every intersection sorted by distance — expect 2
// (entry + exit) through a solid sphere.
const allHits = sphere.geometry.raycastAll(origin, dir, { space: 'world' });
console.log('raycastAll count:', allHits.length);

// closestPoint returns { position: Vec3, ... } for the nearest surface point.
const closest = sphere.geometry.closestPoint([0, 0, 0], { space: 'world' });
if (closest) {
  const cp = closest.position;
  console.log('closestPoint to world origin:', cp.x.toFixed(3), cp.y.toFixed(3), cp.z.toFixed(3));
}

// distanceTo gives the signed distance from a point to the surface.
const d = sphere.geometry.distanceTo([0, 0, 0], { space: 'world' });
console.log('distance from world origin to surface:', d.toFixed(3));

What you'll seeconsole: raycast hit + locator placement + closestPoint result.

Open in editor →

Reverse / recalc / smooth normals

Spawn a cube; flip normals; recalculate; smooth; inspect getNormals at each step.

Methods usedModelEditor.create.cube mesh.normals.reverse mesh.normals.recalculate mesh.normals.smooth mesh.normals.get node.translate Utils.wait.frame

Example

// Reverse -> recalculate -> smooth the normals of a cube, sampling the first
// normal vector at each step. Self-contained from an empty scene.
const cube = await create.cube({
  width: 1.5, height: 1.5, depth: 1.5, name: 'NormalsCube',
});
cube.translate.set([2.5, 1.3, -0.7]);
await select(null, { mode: 'clear' });
await Utils.wait.frame();

// normals.get() returns a FLAT Float32Array [nx0,ny0,nz0, ...]; [0..2] is the
// first vertex's normal. A helper keeps the per-step logging readable.
const sample = (label) => {
  const n = cube.normals.get();
  console.log(label + ' n[0..2]:', n[0].toFixed(3), n[1].toFixed(3), n[2].toFixed(3));
};
sample('orig');

// 1) reverse(faceIndices?) flips winding. Pass a face-index array to flip only
//    those faces; omit it to flip the whole mesh. Here: flip the first 3 faces.
await cube.normals.reverse([0, 1, 2]);
await Utils.wait.frame();
sample('partial-reverse');

// 2) recalculate() rebuilds face normals from geometry — undoes the flip and
//    restores outward-facing normals across the whole mesh.
await cube.normals.recalculate();
await Utils.wait.frame();
sample('recalc');

// 3) smooth() averages adjacent face normals into per-vertex normals for a
//    rounded shading look (no geometry change).
await cube.normals.smooth();
await Utils.wait.frame();
sample('smoothed');

console.log('normals workflow complete on "' + cube.name + '"');

What you'll seeconsole: normal sample at each step.

Open in editor →

Three cubes with varied bevel strategies (vertex / flat-edge / rounded-edge)

Spawn three cubes; bevelVertices on one, a single-segment (flat) edge bevel on another, a multi-segment (rounded) edge bevel on the third; log vert/face deltas.

Methods usedModelEditor.create.cube mesh.bevelVertices mesh.bevelEdges mesh.verts mesh.faces mesh.edges node.translate Utils.wait.frame ModelEditor.viewport.frameAll

Example

// Three cubes, three corner-rounding strategies, side by side. Each uses the
// component-selector surface: mesh.verts([...]) / mesh.edges([...]) build a
// component handle, then a mutator runs on exactly those indices. Bevel is the
// single canonical edge round-off: a 1-segment bevel is a flat chamfer-style
// cut, a multi-segment bevel is a smooth rounded fillet-style curve.
let x = -3;

// 1) VERTEX bevel — round two corners into small faces. verts(...).bevel
//    accepts { width, offset } and is SINGLE-SEGMENT by design (no segments).
const cube1 = await create.cube({ width: 1, height: 1, depth: 1, name: 'BevelVerts' });
cube1.translate.set([x, 1.3, -0.7]);
const b1 = { v: cube1.verts.count, f: cube1.faces.count };
await cube1.verts([0, 1]).bevel({ width: 0.08 }); // width = corner cut, meters
console.log('verts.bevel: V ' + b1.v + '->' + cube1.verts.count + ', F ' + b1.f + '->' + cube1.faces.count);
await select(null, { mode: 'clear' });
x += 2.5;

// 2) EDGE bevel, FLAT — a single-segment edge bevel replaces each edge with a
//    flat strip (the classic chamfer). edges(...).bevel takes { width, segments }.
const cube2 = await create.cube({ width: 1, height: 1, depth: 1, name: 'FlatBevelEdges' });
cube2.translate.set([x, 1.3, -0.7]);
const b2 = { v: cube2.verts.count, f: cube2.faces.count };
await cube2.edges([0, 1, 2, 3]).bevel({ width: 0.1, segments: 1 }); // 1 segment = flat strip
console.log('edges.bevel(flat): V ' + b2.v + '->' + cube2.verts.count + ', F ' + b2.f + '->' + cube2.faces.count);
await select(null, { mode: 'clear' });
x += 2.5;

// 3) EDGE bevel, ROUNDED — a multi-segment edge bevel rounds each edge into a
//    smooth curve (the classic fillet). More segments = tighter, smoother curve.
const cube3 = await create.cube({ width: 1, height: 1, depth: 1, name: 'RoundBevelEdges' });
cube3.translate.set([x, 1.3, -0.7]);
const b3 = { v: cube3.verts.count, f: cube3.faces.count };
await cube3.edges([0, 1, 2, 3]).bevel({ width: 0.1, segments: 3 }); // 3 segments = rounded
console.log('edges.bevel(round): V ' + b3.v + '->' + cube3.verts.count + ', F ' + b3.f + '->' + cube3.faces.count);
await select(null, { mode: 'clear' });

await Utils.wait.frame();
viewport.frameAll(1.5); // paddingFactor — frame all three cubes
console.log('bevel comparison built (vertex / flat-edge / rounded-edge)');

What you'll seeconsole: per-cube before/after V/F counts.

Open in editor →

Mutate a curve: degree, closed flag, control vertex position

Read .numPoints / .closed / .degree; mutate via .toggleClosed / .setDegree / .setPoint.

Methods usedModelEditor.create.circle curve.numPoints curve.closed curve.degree curve.toggleClosed curve.setDegree curve.setPoint

Example

const ring = await create.circle({ center: [2.5, 1.3, -0.7], radius: 1.0, name: 'CurveMut' });
select(null, {mode: 'clear'});
console.log('numPoints:', ring.numPoints, 'closed:', ring.closed, 'degree:', ring.degree);
ring.toggleClosed(); console.log('toggle closed:', ring.closed);
ring.toggleClosed(); console.log('re-toggle:', ring.closed);
ring.setDegree(1); console.log('degree(1):', ring.degree);
ring.setDegree(3); console.log('degree(3):', ring.degree);
try { await ring.setDegree(2); } catch (e) { console.log('setDegree(2) rejected:', e.code); }
await ring.setPoint(0, [3.5, 2.0, -0.7]);
console.log('final:', ring.numPoints, ring.closed, ring.degree);

What you'll seeconsole: per-step CV count + closed/degree state.

Open in editor →

Transform helpers: translate / rotate / scale / xform / freeze / reset

Drive a node through the compound TRS attrs, a bulk .xform({...}) write (local + world, relative), then .freezeTransform() and .resetTransform() to see the full transform lifecycle.

Methods usedModelEditor.create.cube Utils.wait.frame transform.translate transform.rotate transform.scale transform.xform transform.freezeTransform transform.resetTransform

Example

const cube = await create.cube({ width: 1, height: 1, depth: 1, name: 'XformDemo' });
select(null, {mode: 'clear'});
cube.translate.set([2.5, 1.3, -0.7]);
await Utils.wait.frame();
cube.translate.set([2.5, 1.3, -0.7]);
cube.rotate.set([0, 45, 0]);
cube.scale.set([1.2, 1.2, 1.2]);
console.log('TRS:', JSON.stringify(cube.translate.get()), JSON.stringify(cube.rotate.get()), JSON.stringify(cube.scale.get()));
cube.xform({ t: [0.1, 0, 0], r: [0, 5, 0], relative: true });
console.log('after rel xform: translate=' + JSON.stringify(cube.translate.get()));
cube.xform({ t: [0.05, 0, 0], space: 'world', relative: true });
console.log('after world rel t: translate=' + JSON.stringify(cube.translate.get()));
cube.freezeTransform();
console.log('post-freeze:', JSON.stringify(cube.translate.get()));
cube.translate.set([5, 1, 0]);
cube.resetTransform();
console.log('post-reset:', JSON.stringify(cube.translate.get()));

What you'll seeconsole: TRS values after each set, after relative local + world xforms, post-freeze, and post-reset.

Open in editor →

Spawn 10 composite primitives in a row (arch / arrow / bolt / box / bracket / capsule / channel / compartment / cross / funnel)

Build a contact sheet of structural shapes, deselecting between each to keep undo clean.

Methods usedModelEditor.create.arch ModelEditor.create.arrow ModelEditor.create.bolt ModelEditor.create.boxWithLid ModelEditor.create.bracket ModelEditor.create.capsule ModelEditor.create.channel ModelEditor.create.compartmentGrid ModelEditor.create.cross ModelEditor.create.funnel Utils.wait.frame ModelEditor.viewport.frameAll node.translate

Example

let x = -12;
const step = 2.7;

const a1 = await create.arch({});
a1.translate.set([x, 1.3, -0.7]); select(null, {mode: 'clear'}); console.log('arch:', a1.name); x += step;

const a2 = await create.arrow({});
a2.translate.set([x, 1.3, -0.7]); select(null, {mode: 'clear'}); console.log('arrow:', a2.name); x += step;

const a3 = await create.bolt({});
a3.translate.set([x, 1.3, -0.7]); select(null, {mode: 'clear'}); console.log('bolt:', a3.name); x += step;

const a4 = await create.boxWithLid({});
a4.translate.set([x, 1.3, -0.7]); select(null, {mode: 'clear'}); console.log('boxWithLid:', a4.name); x += step;

const a5 = await create.bracket({});
a5.translate.set([x, 1.3, -0.7]); select(null, {mode: 'clear'}); console.log('bracket:', a5.name); x += step;

const a6 = await create.capsule({});
a6.translate.set([x, 1.3, -0.7]); select(null, {mode: 'clear'}); console.log('capsule:', a6.name); x += step;

const a7 = await create.channel({});
a7.translate.set([x, 1.3, -0.7]); select(null, {mode: 'clear'}); console.log('channel:', a7.name); x += step;

const a8 = await create.compartmentGrid({});
a8.translate.set([x, 1.3, -0.7]); select(null, {mode: 'clear'}); console.log('compartmentGrid:', a8.name); x += step;

const a9 = await create.cross({});
a9.translate.set([x, 1.3, -0.7]); select(null, {mode: 'clear'}); console.log('cross:', a9.name); x += step;

const a10 = await create.funnel({});
a10.translate.set([x, 1.3, -0.7]); select(null, {mode: 'clear'}); console.log('funnel:', a10.name);

await Utils.wait.frame();
viewport.frameAll();

What you'll seeconsole: 10 spawn lines with mesh ids; viewport reframed.

Open in editor →

Spawn 13 more composite primitives (gear / heart / knob / lShape / ring / roundedBox / screw / screwAndNut / spring / star / storageBox / tShape / tube)

Second half of the structural-primitives sweep: gears, decorative shapes, fasteners, and storage forms.

Methods usedModelEditor.create.gear ModelEditor.create.heart ModelEditor.create.knob ModelEditor.create.lShape ModelEditor.create.ring ModelEditor.create.roundedBox ModelEditor.create.screw ModelEditor.create.screwAndNut ModelEditor.create.spring ModelEditor.create.star ModelEditor.create.storageBox ModelEditor.create.tShape ModelEditor.create.tube Utils.wait.frame node.translate

Example

let x = -16;
const step = 2.7;

const b1 = await create.gear({});
b1.translate.set([x, 1.3, 2.5]); select(null, {mode: 'clear'}); console.log('gear:', b1.name); x += step;

const b2 = await create.heart({});
b2.translate.set([x, 1.3, 2.5]); select(null, {mode: 'clear'}); console.log('heart:', b2.name); x += step;

const b3 = await create.knob({});
b3.translate.set([x, 1.3, 2.5]); select(null, {mode: 'clear'}); console.log('knob:', b3.name); x += step;

const b4 = await create.lShape({});
b4.translate.set([x, 1.3, 2.5]); select(null, {mode: 'clear'}); console.log('lShape:', b4.name); x += step;

const b5 = await create.ring({});
b5.translate.set([x, 1.3, 2.5]); select(null, {mode: 'clear'}); console.log('ring:', b5.name); x += step;

const b6 = await create.roundedBox({});
b6.translate.set([x, 1.3, 2.5]); select(null, {mode: 'clear'}); console.log('roundedBox:', b6.name); x += step;

const b7 = await create.screw({});
b7.translate.set([x, 1.3, 2.5]); select(null, {mode: 'clear'}); console.log('screw:', b7.name); x += step;

const b8 = await create.screwAndNut({});
b8.translate.set([x, 1.3, 2.5]); select(null, {mode: 'clear'}); console.log('screwAndNut:', b8.name); x += step;

const b9 = await create.spring({});
b9.translate.set([x, 1.3, 2.5]); select(null, {mode: 'clear'}); console.log('spring:', b9.name); x += step;

const b10 = await create.star({});
b10.translate.set([x, 1.3, 2.5]); select(null, {mode: 'clear'}); console.log('star:', b10.name); x += step;

const b11 = await create.storageBox({});
b11.translate.set([x, 1.3, 2.5]); select(null, {mode: 'clear'}); console.log('storageBox:', b11.name); x += step;

const b12 = await create.tShape({});
b12.translate.set([x, 1.3, 2.5]); select(null, {mode: 'clear'}); console.log('tShape:', b12.name); x += step;

const b13 = await create.tube({});
b13.translate.set([x, 1.3, 2.5]); select(null, {mode: 'clear'}); console.log('tube:', b13.name);

await Utils.wait.frame();

What you'll seeconsole: 13 spawn lines confirming each primitive.

Open in editor →

Build a polyline, a circle, and a rectangle curve

Demonstrate create / createCircle / createRectangle: the three curve constructors.

Methods usedModelEditor.create.curve ModelEditor.create.circle ModelEditor.create.rectangle Utils.wait.frame

Example

const poly = await create.curve({
  points: [[0, 0, 0], [1, 0, 0], [1, 0, 1], [0, 0, 1]],
  degree: 1,
  closed: true,
  name: 'SquarePoly',
});
select(null, {mode: 'clear'});
console.log('polyline:', poly.name);

const circle = await create.circle({
  center: [3, 0, 0],
  radius: 1.0,
  name: 'UnitCircle',
});
select(null, {mode: 'clear'});
console.log('circle:', circle.name);

const rect = await create.rectangle({
  p0: [6, 0, -1],
  p1: [8, 0, 1],
  name: 'TwoByTwo',
});
select(null, {mode: 'clear'});
console.log('rectangle:', rect.name);

await Utils.wait.frame();

What you'll seeconsole: 3 curves created with their names.

Open in editor →

Build meshes from raw verts, polylines, profiles, and revolves

Demonstrate every non-class mesh factory: fromVertsAndFaces / empty / loft and Curve sweep methods: extrudeAlong / revolveAround / fillBoundary.

Methods usedModelEditor.create.fromVertsAndFaces ModelEditor.create.empty ModelEditor.create.loft Curve.extrudeAlong Curve.revolveAround Curve.fillBoundary Utils.wait.frame node.translate

Example

// 1. fromVertsAndFaces: explicit pyramid
const pyramid = await create.fromVertsAndFaces({
  positions: [[-1,0,-1], [1,0,-1], [1,0,1], [-1,0,1], [0,1.5,0]],
  faceVertexCounts: [3, 3, 3, 3, 4],
  faceVertexIndices: [0,1,4, 1,2,4, 2,3,4, 3,0,4, 0,3,2,1],
  name: 'CustomPyramid',
});
pyramid.translate.set([2.5, 1.3, -0.7]);
select(null, {mode: 'clear'});
console.log('fromVertsAndFaces:', pyramid.name, 'verts=' + pyramid.verts.count);

// 2. empty: start with zero verts (caller appends incrementally)
const blank = await create.empty({ name: 'BlankSlate' });
console.log('empty:', blank.name, 'verts=' + blank.verts.count);

// 3. Curve.extrudeAlong: sweep a profile curve along a path
const profileCurve = await create.curve({
  points: [[-0.2, 0, 0], [0.2, 0, 0], [0.2, 0.4, 0], [-0.2, 0.4, 0]],
  closed: true,
});
const beam = await profileCurve.extrudeAlong([[0, 0, 0], [0, 0, 2]]);
await beam.rename('Beam');
beam.translate.set([5.0, 1.3, -0.7]);
select(null, {mode: 'clear'});
console.log('extrudeAlong:', beam.name, 'verts=' + beam.verts.count);

// 4. loft: bridge two profiles
const loft = await create.loft({
  profiles: [
    [[0,0,0], [1,0,0], [1,0,1], [0,0,1]],
    [[0,1,0], [0.7,1,0], [0.7,1,0.7], [0,1,0.7]],
  ],
  caps: true,
  name: 'LoftBridge',
});
loft.translate.set([10.0, 1.3, -0.7]);
select(null, {mode: 'clear'});
console.log('loft:', loft.name, 'verts=' + loft.verts.count);

// 5. Curve.revolveAround: spin a profile curve around an axis
const revolveProfile = await create.curve({
  points: [[0.5, 0, 0], [1.0, 0.5, 0], [0.5, 1.0, 0]],
});
const revolved = await revolveProfile.revolveAround('y', { segments: 12 });
await revolved.rename('RevolvedVase');
revolved.translate.set([12.5, 1.3, -0.7]);
select(null, {mode: 'clear'});
console.log('revolveAround:', revolved.name, 'verts=' + revolved.verts.count);

// 6. Curve.fillBoundary: closed boundary curve -> cap
const boundaryCurve = await create.curve({
  points: [[0,0,0], [1,0,0], [1,0,1], [0,0,1]],
  closed: true,
});
const cap = await boundaryCurve.fillBoundary();
await cap.rename('BoundaryCap');
cap.translate.set([15.0, 1.3, -0.7]);
select(null, {mode: 'clear'});
console.log('fillBoundary:', cap.name, 'verts=' + cap.verts.count);

await Utils.wait.frame();

What you'll seeconsole: one line per mesh confirming name and vert count.

Open in editor →

Spawn cone, hemisphere, pyramid, torus, and wedge primitives

Cover the five non-class poly mesh constructors that complete the primitives table.

Methods usedModelEditor.create.cone ModelEditor.create.hemisphere ModelEditor.create.pyramid ModelEditor.create.torus ModelEditor.create.wedge Utils.wait.frame

Example

// Self-contained from an EMPTY Model scene: spawn the five non-class poly
// primitives, spacing them along +X. Each constructor has a DISTINCT schema —
// every option below is set to a sensible NON-default value, with inline
// comments enumerating meaning / range / generator default. create.* are async.
let x = -5;
const step = 2.5;

// ── Cone ── radius (base) / height / radialSegments (sides around base) /
// heightSegments (rings up the side) / openEnded (drop the bottom cap?).
const cone = await create.cone({
  radius: 0.8,           // base radius, m; >0 (default 0.5)
  height: 1.5,           // apex height, m; >0 (default 1)
  radialSegments: 24,    // facets around the base; int >0 (default 32)
  heightSegments: 2,     // vertical subdivisions; int >0 (default 1)
  openEnded: false,      // false keeps the base cap; true leaves it open (default false)
  name: 'Cone1',
});
cone.translate.set([x, 1.3, -0.7]); select(null, { mode: 'clear' });
console.log('polyCone:', cone.name, 'verts=' + cone.verts.count); x += step;

// ── Hemisphere ── radius / widthSegments (longitude) / heightSegments
// (latitude) / flatBase (cap the open dome with a disc?).
const hemi = await create.hemisphere({
  radius: 0.9,           // dome radius, m; >0 (default 0.5)
  widthSegments: 24,     // longitude divisions; int >0 (default 32)
  heightSegments: 12,    // latitude divisions; int >0 (default 8)
  flatBase: true,        // true adds the flat base disc; false = open dome (default true)
  name: 'Hemi1',
});
hemi.translate.set([x, 1.3, -0.7]); select(null, { mode: 'clear' });
console.log('polyHemisphere:', hemi.name, 'verts=' + hemi.verts.count); x += step;

// ── Pyramid ── baseRadius (NOT 'radius') / height / sides (base polygon) /
// truncation (0..1 tip-flatten ratio; 0 = pointed apex).
const pyr = await create.pyramid({
  baseRadius: 0.7,       // circumradius of the base polygon, m; >0 (default 0.5)
  height: 1.2,           // apex height, m; >0 (default 1)
  sides: 6,              // base polygon sides; int >0 (default 4)
  truncation: 0.3,       // flatten the tip into a frustum; 0..1 ratio (default 0 = sharp apex)
  name: 'Pyr1',
});
pyr.translate.set([x, 1.3, -0.7]); select(null, { mode: 'clear' });
console.log('polyPyramid:', pyr.name, 'verts=' + pyr.verts.count); x += step;

// ── Torus ── radius (major ring) / tube (minor; MUST be < radius) /
// radialSegments (around the tube) / tubularSegments (around the ring) / arc.
const torus = await create.torus({
  radius: 0.7,           // major (ring) radius, m; >0 (default 0.5)
  tube: 0.2,             // minor (tube) radius, m; >0 and STRICTLY < radius (default 0.2)
  radialSegments: 20,    // facets around the tube cross-section; int >0 (default 16)
  tubularSegments: 40,   // facets around the major ring; int >0 (default 48)
  arc: Math.PI * 2,      // sweep angle in radians; >0 (default 2*PI = full ring)
  name: 'Torus1',
});
torus.translate.set([x, 1.3, -0.7]); select(null, { mode: 'clear' });
console.log('polyTorus:', torus.name, 'verts=' + torus.verts.count); x += step;

// ── Wedge ── triangular prism (ramp): width / height / depth, all in m.
const wedge = await create.wedge({
  width: 1.2,            // X span, m; >0 (default 1)
  height: 1.5,           // Y rise of the ramp, m; >0 (default 1)
  depth: 1.0,            // Z run, m; >0 (default 1)
  name: 'Wedge1',
});
wedge.translate.set([x, 1.3, -0.7]); select(null, { mode: 'clear' });
console.log('polyWedge:', wedge.name, 'verts=' + wedge.verts.count);

await Utils.wait.frame(); // let the render settle before the summary
console.log('Spawned 5 poly primitives:', [cone, hemi, pyr, torus, wedge].map((m) => m.name).join(', '));

What you'll seeconsole: 5 primitive spawn lines with vert counts.

Open in editor →

Non-linear deformer tour: bend / twist / taper / squash / wave / sine

Spawn six subdivided cubes and apply each non-linear deformer to one. Log the resulting deformer stack on each.

Methods usedModelEditor.create.cube Utils.wait.frame ModelEditor.viewport.frameAll node.translate mesh.addBend mesh.addTwist mesh.addTaper mesh.addSquash mesh.addWave mesh.addSine mesh.deformerStack

Example

// Tour every non-linear deformer MODE, applying one to each of six
// subdivided cubes. The six non-linear modes
// ('bend' | 'twist' | 'taper' | 'squash' | 'sine' | 'wave') all go through
// mesh.deformers.add('nonLinear', { mode }). Self-contained from an empty
// Model scene.
const subs = { subdivisionsX: 4, subdivisionsY: 4, subdivisionsZ: 4 }; // dense so curves read smoothly
const offsets = [
  [-7.5, 1.3, -0.7], [-5, 1.3, -0.7], [-2.5, 1.3, -0.7],
  [0, 1.3, -0.7], [2.5, 1.3, -0.7], [5, 1.3, -0.7],
];

// BEND — curvature is the bend amount (radians of bend across the height).
const bendCube = await create.cube({ width: 1, height: 1, depth: 1, ...subs, name: 'Bend' });
bendCube.xform({ t: offsets[0] });
const bend = await bendCube.deformers.add('nonLinear', { mode: 'bend' });
bend.curvature.set(1.2); // strong bend (default ~0)
await select(null, { mode: 'clear' });

// TWIST — startAngle / endAngle (degrees) set the twist at each end.
const twistCube = await create.cube({ width: 1, height: 1, depth: 1, ...subs, name: 'Twist' });
twistCube.xform({ t: offsets[1] });
const twist = await twistCube.deformers.add('nonLinear', { mode: 'twist' });
twist.startAngle.set(0);    // base untwisted
twist.endAngle.set(120);    // 120deg twist at the top
await select(null, { mode: 'clear' });

// TAPER — endScaleX / endScaleZ pinch (or flare) the far end.
const taperCube = await create.cube({ width: 1, height: 1, depth: 1, ...subs, name: 'Taper' });
taperCube.xform({ t: offsets[2] });
const taper = await taperCube.deformers.add('nonLinear', { mode: 'taper' });
taper.endScaleX.set(0.4);   // pinch X to 40% at the top
taper.endScaleZ.set(0.4);   // pinch Z to 40% at the top
await select(null, { mode: 'clear' });

// SQUASH — factor squashes/stretches; expand controls the bulge.
const squashCube = await create.cube({ width: 1, height: 1, depth: 1, ...subs, name: 'Squash' });
squashCube.xform({ t: offsets[3] });
const squash = await squashCube.deformers.add('nonLinear', { mode: 'squash' });
squash.factor.set(-0.5);    // negative = squash (positive = stretch)
squash.expand.set(1.0);     // full lateral bulge
await select(null, { mode: 'clear' });

// WAVE — waveAmplitude / waveWavelength shape a radial ripple.
const waveCube = await create.cube({ width: 1, height: 1, depth: 1, ...subs, name: 'Wave' });
waveCube.xform({ t: offsets[4] });
const wave = await waveCube.deformers.add('nonLinear', { mode: 'wave' });
wave.waveAmplitude.set(0.15);  // ripple height (scene units)
wave.waveWavelength.set(0.5);  // distance between crests
await select(null, { mode: 'clear' });

// SINE — amplitude / wavelength drive a planar sine deform.
const sineCube = await create.cube({ width: 1, height: 1, depth: 1, ...subs, name: 'Sine' });
sineCube.xform({ t: offsets[5] });
const sine = await sineCube.deformers.add('nonLinear', { mode: 'sine' });
sine.amplitude.set(0.2);    // wave height
sine.wavelength.set(0.6);   // crest-to-crest distance
await select(null, { mode: 'clear' });

await Utils.wait.frame();
viewport.frameAll();

// Confirm each mesh carries exactly one deformer via deformers.stack().
const cubes = [bendCube, twistCube, taperCube, squashCube, waveCube, sineCube];
for (const c of cubes) console.log(c.name + ': stack=' + c.deformers.stack().length);
console.log('non-linear deformer tour complete (6 modes).');

What you'll seeconsole: per-cube deformer-stack length after each non-linear add.

Open in editor →

Smoothing deformer stack: smooth + deltaMush + normalPush + FFD + cage

Layer smooth + deltaMush + normalPush + FFD + cage deformers on one cube; log the stack growing.

Methods usedModelEditor.create.cube Utils.wait.frame ModelEditor.viewport.frameAll node.translate mesh.addSmooth mesh.addDeltaMush mesh.addNormalPush mesh.addFFD mesh.addCage mesh.deformerStack

Example

// Layer five smoothing / relaxation / lattice deformers on one cube and
// watch deformers.stack() grow 1 -> 5. Each add() returns its typed handle,
// so we tune one signature attribute per deformer. Self-contained.
const cube = await create.cube({
  width: 1.5, height: 1.5, depth: 1.5,
  subdivisionsX: 4, subdivisionsY: 4, subdivisionsZ: 4, // dense so smoothing visibly reads
  name: 'SmoothStack',
});
cube.xform({ t: [2.5, 1.3, -0.7] });
await select(null, { mode: 'clear' });

// 1) SMOOTH — Laplacian/Taubin relax. iterations + lambda control strength.
const smooth = await cube.deformers.add('smooth');
smooth.iterations.set(5);   // number of relaxation passes (default ~1)
smooth.lambda.set(0.6);     // per-step weight in 0..1
console.log('after Smooth: stack=' + cube.deformers.stack().length);

// 2) DELTA MUSH — preserves detail while smoothing. blend mixes mushed result.
const dm = await cube.deformers.add('deltaMush');
dm.iterations.set(8);       // mush smoothing passes
dm.blend.set(0.75);         // 0 = base, 1 = fully mushed
await select(null, { mode: 'clear' });
console.log('after DeltaMush: stack=' + cube.deformers.stack().length);

// 3) NORMAL PUSH — inflate along normals. pushAmount is the offset distance.
const np = await cube.deformers.add('normalPush');
np.pushAmount.set(0.05);    // inflate 0.05 scene units along each normal
np.averageNormals.set(1);   // 1 = use smoothed normals (softer push)
console.log('after NormalPush: stack=' + cube.deformers.stack().length);

// 4) FFD — free-form lattice. basis 'bspline' = smoother falloff than 'bernstein'.
const ffd = await cube.deformers.add('ffd', { basis: 'bspline' });
console.log('FFD basis:', ffd.basis.get());
console.log('after FFD: stack=' + cube.deformers.stack().length);

// 5) CAGE — bind to a wrapping cage. coordinateType 'meanValue' = MVC weights.
await cube.deformers.add('cage', { coordinateType: 'meanValue' });
console.log('after Cage: stack=' + cube.deformers.stack().length);

await Utils.wait.frame();
viewport.frameAll();
console.log('smoothing deformer stack built (5 deformers) on "' + cube.name + '"');

What you'll seeconsole: stack length after each add (1..5).

Open in editor →

Skinning, vertex-snap, shrinkwrap + reorder + remove cycle

Add skinCluster + vertexSnap + shrinkwrap; reorder the stack; remove one; log each step.

Methods usedModelEditor.create.cube ModelEditor.create.sphere Utils.wait.frame ModelEditor.viewport.frameAll ModelEditor.scene.ls node.translate mesh.addSkinCluster mesh.addVertexSnap mesh.addShrinkwrap mesh.deformerStack mesh.reorderDeformer mesh.removeDeformer

Example

// Constraint-family deformers + full stack lifecycle: add skinCluster
// (graceful skip if no joints) + vertexSnap + shrinkwrap, reorder the stack,
// then remove one. Self-contained from an empty Model scene — we build a
// target sphere for the snap/wrap deformers (both REQUIRE a target by name).
const cube = await create.cube({
  width: 1.5, height: 1.5, depth: 1.5,
  subdivisionsX: 3, subdivisionsY: 3, subdivisionsZ: 3,
  name: 'DeformerCycle',
});
cube.xform({ t: [2.5, 1.3, -0.7] });
await select(null, { mode: 'clear' });

// Build the target surface the snap + shrinkwrap deformers wrap onto.
const target = await create.sphere({ radius: 1.2, name: 'WrapTarget' });
target.xform({ t: [2.5, 1.3, -0.7] }); // co-located so verts have something to snap to
await select(null, { mode: 'clear' });

// SKIN CLUSTER — requires a non-empty Joint[]. Joints are a Control-Rig
// construct; in a bare Model scene there are none, so skip gracefully.
const joints = ls({ type: 'joint' });
if (joints.length > 0) {
  const skin = await cube.deformers.add('skinCluster', { joints: [joints[0]] });
  console.log('after skinCluster (' + skin.deformerType + '): stack=' + cube.deformers.stack().length);
} else {
  console.log('skinCluster skipped: no joints in scene (Control-Rig only).');
}

// VERTEX SNAP — snap verts onto the target when within threshold.
const snap = await cube.deformers.add('vertexSnap', { target: 'WrapTarget' });
snap.threshold.set(0.5); // max snap distance in scene units
console.log('after vertexSnap: stack=' + cube.deformers.stack().length);

// SHRINKWRAP — project every vert onto the target surface, with an offset.
const wrap = await cube.deformers.add('shrinkwrap', { target: 'WrapTarget' });
wrap.offset.set(0.02); // hover 0.02 units off the surface
console.log('after shrinkwrap: stack=' + cube.deformers.stack().length);

// Inspect order by deformerType (top-down = evaluation order).
const stack = cube.deformers.stack();
console.log('order: ' + stack.map((d) => d.deformerType).join(', '));

// REORDER — move the last deformer to the top of the stack (index 0).
if (stack.length >= 2) {
  cube.deformers.reorder(stack[stack.length - 1], 0);
  console.log('after reorder: ' + cube.deformers.stack().map((d) => d.deformerType).join(', '));
}

// REMOVE — drop the vertexSnap; its handle goes stale afterward.
cube.deformers.remove(snap);
console.log('after remove(snap): stack=' + cube.deformers.stack().length);

await Utils.wait.frame();
viewport.frameAll();
console.log('skinning / snap / shrinkwrap cycle complete on "' + cube.name + '"');

What you'll seeconsole: stack length and ordering at each step.

Open in editor →

Face op chain: faces().inset -> faces().extrudeIndividual -> faces().extrude -> faces().delete

On a subdivided cube, inset a face set, extrude each face individually, extrude the set together, then delete a face to open a hole. Every op is a face-selection verb (mesh.faces([...]).<verb>) and every step is wired headless; V/F deltas logged per step.

Methods usedModelEditor.create.cube Utils.wait.frame ModelEditor.viewport.frameAll node.translate mesh.faces().inset mesh.faces().extrudeIndividual mesh.faces().extrude mesh.faces().delete mesh.verts mesh.faces

Example

// Real multi-step FACE-OP chain on a subdivided cube. Every edit is a
// face-selection verb: mesh.faces([...]).<verb>(...). There is NO
// mesh.extrudeIndividualFaces / mesh.inset method on the bare handle — the
// face SELECTION object (mesh.faces([...])) is what exposes inset / extrude /
// extrudeIndividual / delete. (Some face verbs — bevel / bridge / fill — are
// interactive-tool-only and throw from a plain script, so this chain uses only
// the headless-wired verbs.) Self-contained from empty; each step logs the V/F
// delta. No reliance on a prior viewport selection.
const cube = await create.cube({
  width: 2, height: 2, depth: 2,
  subdivisionsX: 3, subdivisionsY: 3, subdivisionsZ: 3, // dense grid for headroom
  name: 'FaceChain',
});
cube.translate.set([2.5, 1.3, -0.7]);
await select(null, { mode: 'clear' });
console.log('start: V=' + cube.verts.count + ' F=' + cube.faces.count);

// 1) INSET a set of faces — shrink each face inward, adding a border ring.
//    - amount: inward shrink, meters (default 0.2)
//    - depth:  along-normal offset of the inset ring, meters (0 = flat, default 0)
await cube.faces([0, 1, 2, 3]).inset({ amount: 0.05, depth: 0.02 });
console.log('after inset: V=' + cube.verts.count + ' F=' + cube.faces.count);

// 2) EXTRUDE INDIVIDUAL — pull each inset face out along ITS OWN normal so the
//    four faces become four separate caps (not one merged block). The op key
//    is 'distance' (meters along each face normal).
await cube.faces([0, 1, 2, 3]).extrudeIndividual({ distance: 0.12 });
console.log('after extrudeIndividual: V=' + cube.verts.count + ' F=' + cube.faces.count);

// 3) EXTRUDE the set TOGETHER — pull all four faces out as one connected block
//    along their averaged normal (group extrude, distinct from the per-face
//    extrudeIndividual above). Key is 'distance' (meters).
await cube.faces([0, 1, 2, 3]).extrude({ distance: 0.1 });
console.log('after extrude: V=' + cube.verts.count + ' F=' + cube.faces.count);

// 4) DELETE a face — open a hole in the mesh (the headless face-removal verb).
//    deleteFaces consumes the selection's face indices; no options.
await cube.faces([18]).delete();
console.log('after delete (hole opened): V=' + cube.verts.count + ' F=' + cube.faces.count);

await Utils.wait.frame();
viewport.frameAll(1.5);
console.log('face-op chain complete on "' + cube.name + '": V=' + cube.verts.count + ' F=' + cube.faces.count);

What you'll seeconsole: V/F counts before/after each op.

Open in editor →

Edge op toolkit: insertEdgeLoop (x2) + edges().bevel + merge({ distance })

Add parallel edge loops, bevel an edge into supporting loops, add more loops, then weld doubles by distance. (offsetEdgeLoops and loopCut are interactive-tool-only / not-yet-wired — they throw from a plain script — so both loop steps use the scriptable insertEdgeLoop + edge bevel instead.)

Methods usedModelEditor.create.cube Utils.wait.frame ModelEditor.viewport.frameAll node.translate mesh.insertEdgeLoop mesh.edges().bevel mesh.merge mesh.verts mesh.edges

Example

// Edge toolkit on a subdivided cube. Every loop op runs HEADLESS when given
// an explicit edge selection — pass 'edges: [...]' so no viewport hover is
// required. Self-contained from an empty scene.
const cube = await create.cube({
  width: 2, height: 2, depth: 2,
  subdivisionsX: 2, subdivisionsY: 2, subdivisionsZ: 2,
  name: 'EdgeOpCube',
});
cube.translate.set([2.5, 1.3, -0.7]);
await select(null, { mode: 'clear' });
console.log('start: V=' + cube.verts.count + ' E=' + cube.edges.count);

// 1) insertEdgeLoop — slice fresh loops across the given edges.
//    - edges: edge indices the loop passes through (required for headless)
//    - cuts:  number of parallel loops to insert (default 1)
await cube.insertEdgeLoop({ edges: [0], cuts: 2 });
console.log('after insertEdgeLoop x2: V=' + cube.verts.count + ' E=' + cube.edges.count);

// 2) Add SUPPORT LOOPS around an edge. NOTE: mesh.offsetEdgeLoops is an
//    INTERACTIVE-tool-only operation — calling it from a plain script throws
//    "'mesh.offsetEdgeLoops' is not available in this editor." The scriptable
//    way to flank an edge with extra loops is the edge-selection BEVEL verb,
//    which runs headless from an explicit selection.
//    mesh.edges([...]).bevel takes { width, segments } (strict):
//    - width:    chamfer size, meters
//    - segments: how many loops across the bevel (>1 = rounded support loops)
await cube.edges([4, 7]).bevel({ width: 0.05, segments: 2 });
console.log('after edges.bevel (support loops): V=' + cube.verts.count + ' E=' + cube.edges.count);

// 3) A SECOND insertEdgeLoop on a different edge. NOTE: mesh.loopCut is a
//    planned op that is NOT yet wired — calling it from a script throws
//    "mesh.loopCutEdge: underlying edge->loop expansion primitive not yet
//    wired". The scriptable way to add more parallel loops today is another
//    insertEdgeLoop on the target edge.
await cube.insertEdgeLoop({ edges: [2], cuts: 1 });
console.log('after 2nd insertEdgeLoop: V=' + cube.verts.count + ' E=' + cube.edges.count);

// 4) Weld doubles by distance. The geometry weld lives on mesh.merge({ distance })
//    (there is NO top-level mesh.mergeByDistance — that name is the UV-island
//    helper under mesh.uv). 'distance' is the weld threshold in meters.
await cube.merge({ distance: 0.001 });
console.log('after merge({ distance }): V=' + cube.verts.count + ' E=' + cube.edges.count);

await Utils.wait.frame();
viewport.frameAll(1.5);
console.log('edge toolkit complete on "' + cube.name + '": V=' + cube.verts.count + ' E=' + cube.edges.count);

What you'll seeconsole: V/E counts before / after each op.

Open in editor →

Slide tools: compute slide data + edgeSlide + vertexSlide + generic slide

Compute slide data on chosen edges + vertices, then apply edgeSlide / vertexSlide at factor 0.3, plus the generic slide router.

Methods usedModelEditor.create.cube Utils.wait.frame ModelEditor.viewport.frameAll node.translate mesh.computeEdgeSlideData mesh.computeVertexSlideData mesh.edgeSlide mesh.vertexSlide mesh.slide mesh.verts mesh.edges

Example

// Slide tools — push edges / vertices along their incident rails without
// changing the topology (vertex / edge counts stay constant; only positions
// move). The one-shot 'mesh.slide({ edges|verts, factor })' form resolves the
// rails internally, so no precomputed slide-data is needed. Self-contained.
const cube = await create.cube({
  width: 2, height: 2, depth: 2,
  subdivisionsX: 4, subdivisionsY: 4, subdivisionsZ: 4, // dense = many slidable rails
  name: 'SlideCube',
});
cube.translate.set([2.5, 1.3, -0.7]);
await select(null, { mode: 'clear' });
console.log('start: V=' + cube.verts.count + ' E=' + cube.edges.count);

// 1) Edge slide via the flat key-dispatch form.
//    - edges: edge indices to slide
//    - factor: signed [-1, 1] ratio (0 = no move, 1 = all the way to the next
//      connected edge, negative = the other direction)
await cube.slide({ edges: [4, 5, 6], factor: 0.3 });
console.log('after slide(edges, 0.3): V=' + cube.verts.count + ' E=' + cube.edges.count);

// 2) Vertex slide via the flat key-dispatch form.
await cube.slide({ verts: [8, 9, 10], factor: -0.25 });
console.log('after slide(verts, -0.25): V=' + cube.verts.count + ' E=' + cube.edges.count);

// 3) Component-selector form — mesh.edges([...]) builds an EdgeComponent, then
//    .slide({ factor }) operates on exactly those edges (same rail resolution).
await cube.edges([12, 13]).slide({ factor: 0.5 });
console.log('after edges.slide(0.5): V=' + cube.verts.count + ' E=' + cube.edges.count);

// 4) Component-selector vertex slide.
await cube.verts([0, 1]).slide({ factor: 0.4 });
console.log('after verts.slide(0.4): V=' + cube.verts.count + ' E=' + cube.edges.count);

await Utils.wait.frame();
viewport.frameAll(1.5);
console.log('slide toolkit complete on "' + cube.name + '"');

What you'll seeconsole: slide-data sample + verts/edges after each slide.

Open in editor →

Imperative mesh builder: appendVertex + appendEdge + appendFace + bulkAppend + beginBatch

Start from a polyPlane, append two verts, an edge, a face; run bulkAppend; demo beginBatch for coalesced authoring.

Methods usedModelEditor.create.plane Utils.wait.frame ModelEditor.viewport.frameAll node.translate mesh.appendVertex mesh.appendEdge mesh.appendFace mesh.bulkAppend mesh.beginBatch mesh.verts mesh.edges mesh.faces

Example

// Build meshes from raw vertex + face data. The customer-facing construction
// entry points are create.buildMesh / .fromVertsAndFaces (the old
// per-element appendVertex / appendFace / bulkAppend builders are now internal).
// Two topology shapes are accepted and are mutually exclusive:
//   - N-gon meshes:  faceVertexCounts + faceVertexIndices
//   - Triangle mesh: indices

// 1) A square pyramid as an N-GON mesh: 1 quad base (count 4) + 4 side tris
//    (count 3 each). Positions are in METERS; one entry per vertex.
const pyramid = await create.buildMesh({
  positions: [
    [-0.5, 0, -0.5], // 0 base corner
    [ 0.5, 0, -0.5], // 1
    [ 0.5, 0,  0.5], // 2
    [-0.5, 0,  0.5], // 3
    [ 0,   1,  0],   // 4 apex
  ],
  // faceVertexCounts[i] = how many verts face i has; faceVertexIndices is the
  // flat concatenation of each face's vertex indices, in order.
  faceVertexCounts: [4, 3, 3, 3, 3],          // base quad, then 4 tris
  faceVertexIndices: [
    0, 1, 2, 3, // base (quad)
    0, 1, 4,    // side
    1, 2, 4,    // side
    2, 3, 4,    // side
    3, 0, 4,    // side
  ],
  name: 'Pyramid',
});
pyramid.translate.set([1.5, 0, -0.7]);
console.log('pyramid: V=' + pyramid.verts.count + ' F=' + pyramid.faces.count
  + ' closed=' + pyramid.geometry.isClosed);

// 2) A single TRIANGLE via the legacy 'indices' form (flat or nested), with
//    explicit per-vertex normals + a name. fromVertsAndFaces is an alias of
//    buildMesh — same options bag, same result.
const tri = await create.fromVertsAndFaces({
  positions: [[0, 0, 0], [1, 0, 0], [0, 1, 0]], // 3 verts, meters
  indices: [[0, 1, 2]],                          // one triangle (nested form)
  normals: [[0, 0, 1], [0, 0, 1], [0, 0, 1]],    // facing +Z
  name: 'Triangle',
});
tri.translate.set([4, 0.5, -0.7]);
console.log('triangle: V=' + tri.verts.count + ' F=' + tri.faces.count);

await Utils.wait.frame();
viewport.frameAll(1.5);
console.log('built "' + pyramid.name + '" + "' + tri.name + '" from raw data');

What you'll seeconsole: V/E/F counts after each append + batch commit.

Open in editor →

Topology cut tools: bisect + knife + slice + spin + mirror

Spawn four cubes; bisect by plane, slice axis-aligned, spin around Y, mirror across X. Knife runs as a session that gets cancelled.

Methods usedModelEditor.create.cube Utils.wait.frame ModelEditor.viewport.frameAll node.translate mesh.bisect mesh.knife mesh.slice mesh.spin mesh.mirror mesh.verts mesh.faces

Example

// Topology cut tools across four cubes: bisect, slice, spin, mirror — plus a
// knife SESSION lifecycle demo. bisect + slice are interactive by default;
// pass oneShot:true to run them HEADLESS in a script. Self-contained.
//
// 1) BISECT — cut along an axis-aligned plane. Headless needs oneShot:true
//    plus at least one of fill / clearInner / clearOuter true.
const a = await create.cube({ width: 1, height: 1, depth: 1, subdivisionsX: 3, subdivisionsY: 3, subdivisionsZ: 3, name: 'Bisect' });
a.translate.set([-3, 1.3, -0.7]);
await select(null, { mode: 'clear' });
const a0 = { v: a.verts.count, f: a.faces.count };
await a.bisect({
  oneShot: true,    // run headless (no interactive drag session)
  axis: 'x',        // plane perpendicular to X ('x'|'y'|'z')
  offset: 0,        // signed plane position along axis, meters
  fill: true,       // cap the cut with a new face
  clearInner: false,// keep the -X half (default false)
  clearOuter: false,// keep the +X half (default false)
});
console.log('bisect: V ' + a0.v + '->' + a.verts.count + ', F ' + a0.f + '->' + a.faces.count);

// 2) SLICE — split into two coplanar shells. Headless = oneShot + mode 'plane'.
const b = await create.cube({ width: 1, height: 1, depth: 1, subdivisionsX: 3, subdivisionsY: 3, subdivisionsZ: 3, name: 'Slice' });
b.translate.set([-1, 1.3, -0.7]);
await select(null, { mode: 'clear' });
const b0 = { v: b.verts.count, f: b.faces.count };
await b.slice({
  oneShot: true,  // headless one-shot (freeform mode needs interactive endpoints)
  mode: 'plane',  // 'plane' = axis+offset; 'freeform' is interactive-only
  axis: 'y',      // cut perpendicular to Y
  offset: 0,      // plane position, meters
  fill: false,    // slice leaves the cut open (fill is reserved on slice)
});
console.log('slice: V ' + b0.v + '->' + b.verts.count + ', F ' + b0.f + '->' + b.faces.count);

// 3) SPIN — revolve a profile around an axis. axis is a LETTER (not a vector);
//    angle is in DEGREES (360 = full revolution); steps = segments.
const c = await create.cube({ width: 1, height: 1, depth: 1, subdivisionsX: 3, subdivisionsY: 3, subdivisionsZ: 3, name: 'Spin' });
c.translate.set([1, 1.3, -0.7]);
await select(null, { mode: 'clear' });
const c0 = { v: c.verts.count, f: c.faces.count };
await c.spin({ axis: 'y', angle: 180, steps: 8 }); // half revolution in 8 steps
console.log('spin: V ' + c0.v + '->' + c.verts.count + ', F ' + c0.f + '->' + c.faces.count);

// 4) MIRROR (topology) — this REBUILDS a symmetric mesh from a HALF mesh; it
//    is a SILENT NO-OP on a full/already-symmetric cube (nothing to add). So we
//    first cut a half: bisect with clearOuter deletes the +X side, leaving only
//    the -X half. Then mirror with direction:-1 (keep -axis, reflect to +axis)
//    + weld rebuilds the full mesh — the vert count must roughly DOUBLE.
const d = await create.cube({ width: 1, height: 1, depth: 1, subdivisionsX: 2, subdivisionsY: 2, subdivisionsZ: 2, name: 'Mirror' });
d.translate.set([3, 1.3, -0.7]);
await select(null, { mode: 'clear' });
// 4a) Bisect at X=0 and DROP the +X half → a true half-mesh.
await d.bisect({ oneShot: true, axis: 'x', offset: 0, fill: false, clearOuter: true });
const dHalf = { v: d.verts.count, f: d.faces.count };
console.log('mirror half-mesh: V=' + dHalf.v + ' F=' + dHalf.f);
// 4b) Mirror the surviving -X half back across X and weld the seam.
await d.mirror({
  axis: 'x',          // symmetry plane perpendicular to X
  style: 'topology',  // rebuild geometry (default) vs 'positions'
  direction: -1,      // keep -X side (the half we kept), reflect to +X
  weld: true,         // weld the seam verts after mirroring
});
console.log('mirror: V ' + dHalf.v + '->' + d.verts.count + ', F ' + dHalf.f + '->' + d.faces.count
  + ' (doubled=' + (d.verts.count > dHalf.v) + ')');

// 5) KNIFE — interactive-only cut tool. Open a session, then cancel it to
//    demonstrate the session lifecycle (no headless commit path).
const knifeSession = await a.knife({ snapMode: 'edge' }); // snap to edges
if (knifeSession && typeof knifeSession.cancel === 'function') {
  await knifeSession.cancel();
  console.log('knife session opened + cancelled');
}

await Utils.wait.frame();
viewport.frameAll(1.5);
console.log('topology cut tools complete: bisect / slice / spin / mirror + knife');

What you'll seeconsole: V/F deltas across the five cut/mirror tools.

Open in editor →

Deformation ops sweep: smooth / pushPull / flatten / flattenToPlane / toSphere / shear / shrinkFatten

Spawn seven subdivided cubes; apply one deformation op to each; log V counts.

Methods usedModelEditor.create.cube Utils.wait.frame ModelEditor.viewport.frameAll node.translate mesh.smooth mesh.pushPull mesh.flatten mesh.flattenToPlane mesh.toSphere mesh.shear mesh.shrinkFatten mesh.verts

Example

// Sweep seven whole-mesh deformation OPS (these are geometry edits, not
// stacked deformers): smooth / pushPull / flatten / flattenToPlane /
// toSphere / shear / shrinkFatten. One subdivided cube each, every option
// set to a non-default value, V-count logged. Self-contained from empty.
const subs = { subdivisionsX: 3, subdivisionsY: 3, subdivisionsZ: 3 }; // 4x4x4 verts/face
const offsets = [
  [-7.5, 1.3, -0.7], [-5, 1.3, -0.7], [-2.5, 1.3, -0.7], [0, 1.3, -0.7],
  [2.5, 1.3, -0.7], [5, 1.3, -0.7], [7.5, 1.3, -0.7],
];

// 1) smooth — Laplacian relax. With no verts/faces/edges key the WHOLE mesh is
//    smoothed (there is NO mesh.smoothVertices; the verb is mesh.smooth).
//    - iterations: number of passes (default 1; higher = softer)
//    - strength:   per-pass blend [0,1] (default 0.5; 1 = full move to average)
const a = await create.cube({ width: 1, height: 1, depth: 1, ...subs, name: 'Smooth' });
// NOTE: the mesh-surface ops below (pushPull / flatten / flattenToPlane /
// toSphere / shear / shrinkFatten) act on the IN-SCOPE mesh and throw
// "no mesh in scope" if nothing is selected — so we scene.select(<mesh>)
// before each one (NOT clear). smooth() takes the handle directly, but we
// select it too for a uniform pattern.
a.xform({ t: offsets[0] }); await select(a);
await a.smooth({ iterations: 4, strength: 0.6 }); // whole-mesh relax, 4 passes

// 2) pushPull — move verts along their normals (omit 'verts' = all verts).
const b = await create.cube({ width: 1, height: 1, depth: 1, ...subs, name: 'PushPull' });
b.xform({ t: offsets[1] }); await select(b);
await b.pushPull({ distance: 0.2 }); // inflate 0.2 scene units along normals

// 3) flatten — collapse verts onto an auto-detected best-fit plane.
const c = await create.cube({ width: 1, height: 1, depth: 1, ...subs, name: 'Flatten' });
c.xform({ t: offsets[2] }); await select(c);
await c.flatten({ plane: 'y' }); // flatten along Y ('auto' | 'x' | 'y' | 'z')

// 4) flattenToPlane — collapse onto an explicit origin+normal plane.
const d = await create.cube({ width: 1, height: 1, depth: 1, ...subs, name: 'FlattenToPlane' });
d.xform({ t: offsets[3] }); await select(d);
await d.flattenToPlane({ planeOrigin: [0, 0, 0], planeNormal: [0, 1, 0] }); // XZ plane

// 5) toSphere — spherify verts. factor 0..1 blends cube -> sphere.
const e = await create.cube({ width: 1, height: 1, depth: 1, ...subs, name: 'ToSphere' });
e.xform({ t: offsets[4] }); await select(e);
await e.toSphere({ factor: 0.5 }); // half-way to a sphere

// 6) shear — slant verts along an axis. amount = shear factor.
const f = await create.cube({ width: 1, height: 1, depth: 1, ...subs, name: 'Shear' });
f.xform({ t: offsets[5] }); await select(f);
await f.shear({ amount: 0.3, axis: 'x' }); // slant along X

// 7) shrinkFatten — offset verts along normals (like pushPull, signed).
const g = await create.cube({ width: 1, height: 1, depth: 1, ...subs, name: 'ShrinkFatten' });
g.xform({ t: offsets[6] }); await select(g);
await g.shrinkFatten({ offset: 0.1 }); // fatten 0.1 units (negative shrinks)

const all = [a, b, c, d, e, f, g];
for (const m of all) console.log(m.name + ': V=' + m.verts.count);

await Utils.wait.frame();
viewport.frameAll();
console.log('deformation ops sweep complete (7 ops).');

What you'll seeconsole: per-op verts before/after.

Open in editor →

Resolution control: decimate + remesh + solidify

Decimate a sphere, voxel-remesh a separate sphere, solidify a plane; log V/F deltas.

Methods usedModelEditor.create.sphere ModelEditor.create.plane Utils.wait.frame ModelEditor.viewport.frameAll node.translate mesh.decimate mesh.remesh mesh.solidify mesh.verts mesh.faces

Example

// Self-contained: build three independent working meshes from an empty
// scene, then drive one resolution op against each and log V/F deltas.

// 1) DECIMATE — collapse a dense sphere down to a vertex/face budget.
//    create.* is async; spread the mesh out so they don't overlap.
const dec = await create.sphere({
  radius: 1,            // sphere radius in scene units (default 1)
  widthSegments: 32,    // longitudinal segments (default 32) — high so there is plenty to decimate
  heightSegments: 16,   // latitudinal segments (default 16)
  name: 'Decimate',
});
dec.translate.set([-2.5, 1.3, -0.7]);
select(null, { mode: 'clear' });
const dec0 = { v: dec.verts.count, f: dec.faces.count };
await dec.decimate({
  targetCount: 200,     // absolute target face count (alternative form: { ratio: 0.25 })
});
console.log('decimate: V ' + dec0.v + '->' + dec.verts.count + ', F ' + dec0.f + '->' + dec.faces.count);

// 2) REMESH — rebuild a coarse sphere as clean topology.
//    algorithm is 'advanced' (analytical) or 'quad' (FEQ retopology) — there is NO 'voxel'.
const rem = await create.sphere({
  radius: 1,
  widthSegments: 16,
  heightSegments: 8,
  name: 'Remesh',
});
rem.translate.set([0, 1.3, -0.7]);
select(null, { mode: 'clear' });
const rem0 = { v: rem.verts.count, f: rem.faces.count };
await rem.remesh({
  algorithm: 'advanced', // 'advanced' = analytical remesh (default) | 'quad' = FEQ retopology
  // Optional kernel picker for 'advanced': method: 'instantMeshes' (fast) |
  // 'quadwild' (sharp-feature strong) | 'autoremesher' (organic edge flow,
  // runs in the background + cancellable). Omitted = current popup selection.
  targetCount: 500,      // approximate target element count
});
console.log('remesh: V ' + rem0.v + '->' + rem.verts.count + ', F ' + rem0.f + '->' + rem.faces.count);

// 3) SOLIDIFY — give a flat panel real thickness (shell extrude).
//    plane subdivisions are widthSegments / heightSegments (NOT subdivisionsX/Y).
const sol = await create.plane({
  width: 1.5,
  height: 1.5,
  widthSegments: 4,     // columns of quads (default 1)
  heightSegments: 4,    // rows of quads (default 1)
  name: 'Solidify',
});
sol.translate.set([2.5, 1.3, -0.7]);
select(null, { mode: 'clear' });
const sol0 = { v: sol.verts.count, f: sol.faces.count };
await sol.solidify({
  thickness: 0.05,      // shell thickness in scene units (must be > 0; 0 throws / no-ops)
});
console.log('solidify: V ' + sol0.v + '->' + sol.verts.count + ', F ' + sol0.f + '->' + sol.faces.count);

await Utils.wait.frame();
viewport.frameAll();
console.log('resolution control done: decimate + remesh + solidify on three meshes.');

What you'll seeconsole: V/F before+after for decimate / remesh / solidify.

Open in editor →

UV authoring suite: setUV / setUVs / transferUV / closestUV / unwrapUV / uvIsland / uvIslandAt / packUV / markSeam

Unwrap a cube, list its UV islands, pack tightly, write one UV via setUV, write a whole UV map via setUVs, sample closestUV, mark a seam edge, and transfer the UV map to a sphere.

Methods usedModelEditor.create.cube ModelEditor.create.sphere Utils.wait.frame ModelEditor.viewport.frameAll node.translate mesh.unwrapUV mesh.packUV mesh.uv.setOne mesh.uv.set mesh.transferUV mesh.uv.closest mesh.uv.island mesh.uv.islandAt mesh.markSeam

Example

// Full UV-authoring pass on the mesh.uv collection: unwrap, pack, write one
// loop, write the whole map, query islands, sample the nearest loop, mark a
// seam, and transfer the layout to a topology-matched sibling. From empty.

const cube = await create.cube({
  width: 1, height: 1, depth: 1,
  subdivisionsX: 2, subdivisionsY: 2, subdivisionsZ: 2,
  name: 'UVSrc',
});
cube.xform({ t: [-2.5, 1.3, -0.7] });
await select(null, { mode: 'clear' });

// UNWRAP + PACK — generate islands then repack them into the unit square.
await cube.uv.unwrap({ strategy: 'smartProject', setIdx: 0 }); // 'fable' | 'xatlas' | 'smartProject' | 'pipeline'
await cube.uv.pack({ setIdx: 0 });
console.log('unwrap + pack islands:', cube.uv.islands.length);

// WRITE ONE — pin loop 0 to the UV center.
cube.uv.setOne(0, [0.5, 0.5], 0); // (loopIndex, [u,v], setIdx)

// WRITE WHOLE MAP — lay every loop on a 4x4 grid. uv.set takes a flat
// [u0,v0,u1,v1,...] buffer of length 2 * count.
const totalLoops = cube.uv.count;
const uvs = new Float32Array(totalLoops * 2);
for (let i = 0; i < totalLoops; i++) {
  uvs[i * 2] = (i % 4) * 0.25;                 // u
  uvs[i * 2 + 1] = (Math.floor(i / 4) % 4) * 0.25; // v
}
cube.uv.set(uvs, 0);

// QUERY ISLANDS — island(loop) by loop; islandAt([u,v]) by UV position.
const island = cube.uv.island(0);
console.log('island(0) loops:', island ? island.loopIndices.length : 'null');
const found = cube.uv.islandAt([0.1, 0.1]);
console.log('islandAt([0.1,0.1]):', found ? 'hit (island ' + found.index + ')' : 'miss');

// NEAREST LOOP — closest([u,v]) returns the nearest loop + its distance.
const near = cube.uv.closest([0.5, 0.5]);
console.log('closest([0.5,0.5]) loopIndex:', near ? near.loopIndex : 'null');

// MARK SEAM — flag edges 0..2 as UV seams (honored by future unwraps).
await cube.uv.markSeam({ edges: [0, 1, 2], setIdx: 0 });
console.log('any seam loop:', cube.uv.loopSeam().some(Boolean));

// TRANSFER — copy the UV layout onto a topology-matched sibling cube.
const dst = await create.cube({
  width: 1, height: 1, depth: 1,
  subdivisionsX: 2, subdivisionsY: 2, subdivisionsZ: 2, // SAME topology = clean transfer
  name: 'UVDst',
});
dst.xform({ t: [2.5, 1.3, -0.7] });
await select(null, { mode: 'clear' });
await dst.uv.transferFrom(cube, { setIdx: 0 });
console.log('after transferFrom -> dst islands:', dst.uv.islands.length);

await Utils.wait.frame();
viewport.frameAll();
console.log('UV authoring suite complete.');

What you'll seeconsole: island count, closestUV hit, transfer dst island count.

Open in editor →

Vertex attribute writes: setPoints / setVertexPositions / setNormals / setVertexColor(s) / mapVertices / markSharp

Spawn a subdivided cube; read points, mirror them with setPoints, write a per-index update with setVertexPositions, override normals + vertex colors, map every vertex through a closure, and mark sharp edges.

Methods usedModelEditor.create.cube Utils.wait.frame ModelEditor.viewport.frameAll node.translate mesh.points mesh.verts.setPositions mesh.setVertexPositions mesh.normals.set mesh.setVertexColor mesh.setVertexColors mesh.vertexColors mesh.tangents mesh.mapVertices mesh.markSharp

Example

// Self-contained: build a subdivided cube, then write through every
// vertex-attribute channel on the customer surface (mesh.verts.* + mesh.normals.* + mesh.edges.*).
const cube = await create.cube({
  width: 1.5, height: 1.5, depth: 1.5,
  subdivisionsX: 3, subdivisionsY: 3, subdivisionsZ: 3, // dense enough to see attribute writes
  name: 'AttrCube',
});
cube.translate.set([2.5, 1.3, -0.7]);
select(null, { mode: 'clear' });

// READ — verts.getPositions returns a flat [x,y,z,...] Float32Array.
//        space: 'object' = local (default) | 'world' = parent-transformed.
const pts = cube.verts.getPositions({ space: 'object' });
console.log('positions sample [0..2]:', pts[0].toFixed(2), pts[1].toFixed(2), pts[2].toFixed(2));

// WRITE (flat-buffer shape) — mirror every vertex across X by negating each x component.
const mirrored = new Float32Array(pts.length);
for (let i = 0; i < pts.length; i++) mirrored[i] = i % 3 === 0 ? -pts[i] : pts[i];
await cube.verts.setPositions(mirrored);

// WRITE (index shape) — nudge only verts 0 and 1 up by 0.05 in object space.
const first = cube.verts.getPositions({ space: 'object' });
await cube.verts.setPositions(
  [0, 1],                                                       // target vertex indices
  [[first[0], first[1] + 0.05, first[2]], [first[3], first[4] + 0.05, first[5]]],
  { space: 'object' },                                          // interpret values as local-space
);

// NORMALS — read the live buffer, then write it straight back (round-trip).
const n = cube.normals.get().slice();
cube.normals.set(n);

// VERTEX COLORS — single vertex via setColor, then a whole-buffer overwrite via setColors.
await cube.verts.setColor(0, [1, 0, 0, 1]);                     // vertex 0 -> opaque red (r,g,b,a in 0..1)
const green = new Float32Array(cube.verts.count * 4);
for (let i = 0; i < cube.verts.count; i++) {
  green[i * 4 + 0] = 0;                                         // r
  green[i * 4 + 1] = 1;                                         // g
  green[i * 4 + 2] = 0;                                         // b
  green[i * 4 + 3] = 1;                                         // a
}
cube.verts.setColors(green);                                    // paint every vertex solid green
console.log('colors len:', (cube.verts.colors ? cube.verts.colors.length : 0), 'tangents len:', cube.verts.tangents.length);

// MAP — run a closure over every vertex; here an identity pass that just counts.
let touched = 0;
await cube.verts.map((i, total) => {
  touched++;
  const p = cube.verts.position(i);
  return [p.x, p.y, p.z];                                       // return the (unchanged) position
});
console.log('verts.map touched:', touched, 'of', cube.verts.count);

// SHARP EDGES — flag edges 0 and 1 as hard creases for shading.
await cube.edges.markSharp({ indices: [0, 1] });

await Utils.wait.frame();
viewport.frameAll();
console.log('vertex attribute write-through complete.');

What you'll seeconsole: points sample, normal/color buffer lengths, mapVertices count.

Open in editor →

Mesh handle getters: id / meshId / faces / edges / vertices / verts / e / f + wireframe

Inspect a cube via every handle getter, iterate vertices(), and tube-ify the mesh via wireframe().

Methods usedModelEditor.create.cube Utils.wait.frame ModelEditor.viewport.frameAll node.translate mesh.id mesh.meshId mesh.faces mesh.edges mesh.verts mesh.vertices mesh.e mesh.f mesh.wireframe mesh.verts mesh.faces mesh.edges

Example

// Self-contained: build a cube and inspect it through every live handle
// getter, iterate its verts, then tube-ify it with the wireframe modifier.
const cube = await create.cube({
  width: 1.5, height: 1.5, depth: 1.5,
  subdivisionsX: 2, subdivisionsY: 2, subdivisionsZ: 2,
  name: 'HandleCube',
});
cube.translate.set([2.5, 1.3, -0.7]);
select(null, { mode: 'clear' });

// IDENTITY — id is the stable DG node id; name is the human-facing label.
console.log('cube.id:', cube.id);
console.log('cube.name:', cube.name);
console.log('nodeType:', cube.nodeType);

// COUNT GETTERS — verts / faces / edges expose .count on their namespace.
console.log('counts: V=' + cube.verts.count + ' F=' + cube.faces.count + ' E=' + cube.edges.count);

// COMPONENT BUILDERS — faces([...]) / edges([...]) / verts([...]) build a
// component handle whose .indices / .numIndices report the selected set.
const faceComp = cube.faces([0, 1]);
console.log('faces([0,1]) numIndices:', faceComp.numIndices, 'indices:', JSON.stringify(faceComp.indices));

const edgeComp = cube.edges([0, 1, 2]);
console.log('edges([0,1,2]) numIndices:', edgeComp.numIndices);

const vertComp = cube.verts([0, 1, 2, 3]);
console.log('verts([0,1,2,3]) numIndices:', vertComp.numIndices);

// ITERATOR — verts.forEach(cb) walks every vertex; (index, total) supplied.
let iterCount = 0;
cube.verts.forEach((i, total) => { iterCount++; });
console.log('vertices iterated:', iterCount, 'of', cube.verts.count);

// WIREFRAME MODIFIER — replace each edge with a solid tube of the given radius.
const before = { v: cube.verts.count, f: cube.faces.count, e: cube.edges.count };
await cube.wireframe({
  thickness: 0.02,   // tube radius in scene units (default ~0.02)
  offset: 0,         // inward/outward shell offset (default 0)
});
console.log('after wireframe: V ' + before.v + '->' + cube.verts.count + ', F ' + before.f + '->' + cube.faces.count + ', E ' + before.e + '->' + cube.edges.count);

await Utils.wait.frame();
viewport.frameAll();
console.log('mesh handle getter sweep complete.');

What you'll seeconsole: id, faces[0] component, e/f lengths, vertices() iterator count, V/F after wireframe.

Open in editor →

Interactive sessions: polyDraw / polyPen / sculptSession / buildOnNormal / fillHoles

Open each interactive session against a reference cube; immediately cancel or finish so the recipe runs headless.

Methods usedModelEditor.create.cube Utils.wait.frame ModelEditor.viewport.frameAll node.translate mesh.polyDraw mesh.polyPen mesh.sculptSession mesh.buildOnNormal mesh.fillHoles

Example

// Self-contained from an empty Model scene. Open each interactive session
// against a reference cube, then cancel / commit immediately so the recipe
// runs fully headless (no manual viewport interaction needed).
const refCube = await create.cube({
  width: 1.5, height: 1.5, depth: 1.5,
  subdivisionsX: 3, subdivisionsY: 3, subdivisionsZ: 3, // dense grid for sculpt/retopo
  name: 'SessionRef',
});
refCube.translate.set([2.5, 1.3, -0.7]); // park off-origin so BVH + renderer stay fresh
select(null, { mode: 'clear' });

// polyDraw — freehand quad placement; no opts (reads the global poly-draw store).
const polyDraw = await refCube.tools.polyDraw();
console.log('polyDraw opened; cancel is fn:', typeof polyDraw.cancel === 'function');
await polyDraw.cancel(); // lifecycle: open -> cancel (discard)

// polyPen — vertex/edge/face placement by raycast. Exercise every opt.
const polyPen = await refCube.tools.polyPen({
  mode: 'quad',        // 'quad' | 'tri' | 'extrude' | 'append'
  symmetry: null,      // 'x' | 'y' | 'z' | null (no mirror)
  worldCoords: true,   // interpret placements as world [x,y,z], skip the raycast
});
console.log('polyPen opened; cancel is fn:', typeof polyPen.cancel === 'function');
await polyPen.cancel();

// sculpt — entry point is mesh.tools.sculpt (NOT sculptSession). Config-only
// then cancel so no real strokes are baked.
const sculpt = await refCube.tools.sculpt({
  brushType: 'clay',   // brush algorithm id
  radius: 0.1,         // world-METERS, floored at 1e-5
  strength: 0.5,       // [0.01, 1.0]
});
console.log('sculpt opened; cancel is fn:', typeof sculpt.cancel === 'function');
await sculpt.cancel();

// buildOnNormal — HEADLESS one-shot: supplying BOTH position + normal commits
// immediately and resolves with the built result (not a session handle).
const built = await refCube.tools.buildOnNormal({
  primitiveType: 'sphere',     // 'cube' | 'sphere' | 'cylinder' | 'cone' | 'torus' | ...
  size: 0.15,                  // uniform size in grid-units (>0)
  depth: 0.15,                 // extent along the normal (>0)
  surfaceOffset: 0.0,          // lift off the surface along the normal
  position: [2.5, 2.05, -0.7], // world surface point (top face of the cube)
  normal: [0, 1, 0],           // world surface normal (non-zero)
});
console.log('buildOnNormal (headless) resolved:', built !== undefined);

// fillHole vs fillHoles: fillHole (no 's') is the INTERACTIVE session;
// fillHoles (with 's') is the headless op. Open the interactive one + cancel.
const fill = await refCube.tools.fillHole({ boundaryFromComponent: { edgeIndices: [] } });
console.log('fillHole opened; cancel is fn:', typeof fill.cancel === 'function');
await fill.cancel();

await Utils.wait.frame();
viewport.frameAll();
console.log('All five interactive sessions opened and resolved headlessly.');

What you'll seeconsole: per-session handle inspection + cancel/commit confirmation.

Open in editor →

Bisect tool: axis + offset + fill, then commit; cancel on a second pass

Open a Bisect session, configure the plane (axis + offset) and fill behavior, commit a cut, then open a second session and cancel to demonstrate the abort path.

Methods usedModelEditor.create.cube Utils.wait.frame ModelEditor.viewport.frameAll node.translate mesh.bisect bisectSession.toolId bisectSession.meshId bisectSession.state bisectSession.isActive bisectSession.setAxis bisectSession.setOffset bisectSession.setFill bisectSession.setClearInner bisectSession.setClearOuter bisectSession.commit bisectSession.cancel

Example

// Self-contained: spawn a subdivided cube the cut can land on.
const cube = await create.cube({
  width: 1, height: 1, depth: 1,
  subdivisionsX: 3, subdivisionsY: 3, subdivisionsZ: 3, // edges for the plane to cross
  name: 'BisectDemo',
});
cube.translate.set([2.5, 1.3, -0.7]);
select(null, { mode: 'clear' });
console.log('start: V=' + cube.verts.count + ' F=' + cube.faces.count);

// Open a Bisect session. The ctor opts seed the starting plane; every value
// can be re-set via the chained setters below. toolId / meshId / state /
// isActive reflect the live session (isActive is the customer-facing getter).
const session = await cube.bisect({
  axis: 'y',          // 'x' | 'y' | 'z' — plane is perpendicular to this axis (default 'x')
  offset: 0,          // signed offset along axis, scene units (default 0)
  fill: true,         // cap the cut with a new face (default false)
  clearInner: false,  // delete the negative half (default false)
  clearOuter: false,  // delete the positive half (default false)
});
console.log('session opened: ' + JSON.stringify({
  toolId: session.toolId,
  meshIdHead: session.meshId.slice(0, 8),
  state: session.state,
  isActive: session.isActive,
}));

// Re-configure via the chained setters (each returns `this`). Headless commit
// requires at least one of fill / clearInner / clearOuter to be true.
session
  .setAxis('y')        // re-assert the cutting axis
  .setOffset(0)        // mid-mesh cut
  .setFill(true)       // close the seam with a cap face
  .setClearInner(false)
  .setClearOuter(false);

// Bake the cut into history.
await session.commit();
console.log('after commit: V=' + cube.verts.count + ' F=' + cube.faces.count + ' state=' + session.state);

// Second pass — exercise the clear options + the abort path. cancel() reverts
// the preview and tears down the editor subscription (idempotent).
const second = await cube.bisect({ axis: 'x', offset: 0.5 });
second
  .setAxis('x')        // cut perpendicular to X
  .setOffset(0.5)      // half a unit off-center
  .setFill(false)      // leave the cut open
  .setClearInner(true) // would drop the negative half on commit
  .setClearOuter(false);
second.cancel();
console.log('after cancel: state=' + second.state + ' isActive=' + second.isActive);

await Utils.wait.frame();
viewport.frameAll();
console.log('bisect demo complete: one committed cut + one cancelled pass.');

What you'll seeconsole: session getters before commit, V/F counts after the cut, then a second session that is cancelled.

Open in editor →

Build on Normal: activate the surface-stamp tool, inspect the session, then cancel

Open the Build-on-Normal interactive session against a cube. The tool stays active so the user can click surfaces in the viewport; the script inspects every session getter then cancels.

Methods usedModelEditor.create.cube Utils.wait.frame ModelEditor.viewport.frameAll node.translate mesh.buildOnNormal buildOnNormalSession.toolId buildOnNormalSession.meshId buildOnNormalSession.state buildOnNormalSession.isActive buildOnNormalSession.commit buildOnNormalSession.cancel

Example

// Self-contained: Build-on-Normal stamps a parametric primitive onto the
// face the user clicks, oriented to that face's normal. Two call modes:
//  - position + normal supplied  -> headless one-shot (places immediately)
//  - position + normal BOTH omitted -> interactive session for viewport clicks
// (supplying exactly one of position/normal throws InvalidArgumentError).
const cube = await create.cube({
  width: 2, height: 2, depth: 2,
  subdivisionsX: 2, subdivisionsY: 2, subdivisionsZ: 2,
  name: 'BuildOnNormalDemo',
});
cube.translate.set([2.5, 1.3, -0.7]);
select(null, { mode: 'clear' });

// INTERACTIVE MODE — omit position+normal. Returns a session handle that
// activates the tool; the getters mirror the live tool state.
const session = await cube.buildOnNormal({
  primitiveType: 'sphere', // primitive to stamp ('cube'|'sphere'|'cylinder'|'cone'|'torus'|...)
  size: 0.2,               // uniform size in scene units (default 1 grid unit; must be > 0)
  depth: 0.2,              // extent along the surface normal (default 1 grid unit; must be > 0)
  surfaceOffset: 0,        // gap above the surface along the normal (default 0 = sits on it)
});
if (typeof session === 'object' && session && 'toolId' in session) {
  console.log('session opened: ' + JSON.stringify({
    toolId: session.toolId,
    meshIdHead: session.meshId.slice(0, 8),
    state: session.state,
    isActive: session.isActive,
  }));

  // In interactive mode commit() does NOT auto-place; it transitions the
  // session to 'committed' so further input throws. cancel() deactivates.
  session.commit();
  console.log('after commit: state=' + session.state);

  // Second pass with a different primitive — open then cancel to demo abort.
  const second = await cube.buildOnNormal({ primitiveType: 'cube', size: 0.15, depth: 0.15, surfaceOffset: 0.05 });
  if (typeof second === 'object' && second && 'cancel' in second) {
    second.cancel();
    console.log('after cancel: state=' + second.state + ' isActive=' + second.isActive);
  }
} else {
  // (Only reached if a position+normal were supplied — the headless one-shot.)
  console.log('headless mode placed: ' + JSON.stringify(session));
}

await Utils.wait.frame();
viewport.frameAll();
console.log('build-on-normal demo complete: tool activated then torn down.');

What you'll seeconsole: session getters confirm the tool is active, then cancel tear it down.

Open in editor →

Fill Hole tool: open against an auto-detected boundary loop, place an interior vert + tri face, then commit; cancel a second pass

Open a Fill Hole session against an auto-detected boundary loop on the live mesh. Demonstrate placeVertex (client-pixel coords) + placeFace (vertex ids) then commit; a second pass shows cancel.

Methods usedModelEditor.create.cube Utils.wait.frame ModelEditor.viewport.frameAll node.translate mesh.fillHole fillHoleSession.toolId fillHoleSession.meshId fillHoleSession.state fillHoleSession.isActive fillHoleSession.placeVertex fillHoleSession.placeFace fillHoleSession.commit fillHoleSession.cancel

Example

// Self-contained: spawn a cube so the auto-boundary detection has a mesh.
// (A real workflow deletes a face first; the session always picks the first
// detected boundary loop.)
const cube = await create.cube({
  width: 1.5, height: 1.5, depth: 1.5,
  subdivisionsX: 2, subdivisionsY: 2, subdivisionsZ: 2,
  name: 'FillHoleDemo',
});
cube.translate.set([2.5, 1.3, -0.7]);
select(null, { mode: 'clear' });

// Open the session. boundaryFromComponent is a reserved disambiguator for
// meshes with multiple loops (accepted but currently ignored — the first
// loop found is always used).
const session = await cube.fillHole({
  boundaryFromComponent: { edgeIndices: [0] }, // hint: which loop (reserved; first loop wins today)
});
console.log('session opened: ' + JSON.stringify({
  toolId: session.toolId,
  meshIdHead: session.meshId.slice(0, 8),
  state: session.state,
  isActive: session.isActive,
}));

// placeVertex takes client-pixel coords [clientX, clientY] and raycasts onto
// the surface; off-mesh picks are silent no-ops. placeFace takes 3 (tri) or 4
// (quad) vertex ids — either boundary ids or ids returned by prior placeVertex.
// In a headless script there is no live boundary/viewport, so this throws and
// we fall through to cancel().
try {
  session.placeVertex([400, 300]);                                       // interior point (client px)
  session.placeFace(['boundary-vid-0', 'boundary-vid-1', 'boundary-vid-2']); // tri spanning the loop
  console.log('placement attempted; committing.');
  await session.commit();
} catch (e) {
  console.log('placement skipped (no live boundary in headless context): ' + (e && e.message ? e.message : String(e)));
  session.cancel();
}
console.log('after first session: state=' + session.state);

// Second pass: open + cancel to demonstrate the abort path explicitly.
const second = await cube.fillHole({});
second.cancel();
console.log('after cancel: state=' + second.state + ' isActive=' + second.isActive);

await Utils.wait.frame();
viewport.frameAll();
console.log('fill-hole demo complete: placeVertex + placeFace lifecycle exercised.');

What you'll seeconsole: session getters before placement, optional placement attempts, then commit OR cancel.

Open in editor →

Knife tool: open a session, addPoint twice to seed a cut line, commit; cancel a second pass

Open the Knife session, seed two cut points (client-pixel coords) with addPoint, then commit. A second pass demonstrates cancel.

Methods usedModelEditor.create.cube Utils.wait.frame ModelEditor.viewport.frameAll node.translate mesh.knife knifeSession.toolId knifeSession.meshId knifeSession.state knifeSession.isActive knifeSession.addPoint knifeSession.commit knifeSession.cancel

Example

// Self-contained: subdivided cube so the knife has interior edges to cross.
const cube = await create.cube({
  width: 1, height: 1, depth: 1,
  subdivisionsX: 3, subdivisionsY: 3, subdivisionsZ: 3,
  name: 'KnifeDemo',
});
cube.translate.set([2.5, 1.3, -0.7]);
select(null, { mode: 'clear' });
console.log('start: V=' + cube.verts.count + ' F=' + cube.faces.count);

// snapMode is a reserved hint for which targets the cut attracts to; today
// every session snaps to both edges and vertices regardless.
const session = await cube.knife({
  snapMode: 'edge', // 'edge' | 'vertex' | 'none' (reserved hint)
});
console.log('session opened: ' + JSON.stringify({
  toolId: session.toolId,
  meshIdHead: session.meshId.slice(0, 8),
  state: session.state,
  isActive: session.isActive,
}));

// addPoint takes a KnifePoint = [clientX, clientY] (client-pixel coords).
// Two points define the cut line; commit() bakes it into history. A headless
// script has no live raycast context, so commit throws -> we cancel.
try {
  session.addPoint([300, 200]); // first cut-line endpoint (client px)
  session.addPoint([600, 400]); // second endpoint
  await session.commit();
  console.log('after commit: V=' + cube.verts.count + ' F=' + cube.faces.count);
} catch (e) {
  console.log('cut skipped (no live raycast context): ' + (e && e.message ? e.message : String(e)));
  session.cancel();
}

// Second pass: open + cancel to demonstrate the abort path.
const second = await cube.knife({ snapMode: 'vertex' });
second.cancel();
console.log('after cancel: state=' + second.state + ' isActive=' + second.isActive);

await Utils.wait.frame();
viewport.frameAll();
console.log('knife demo complete: two cut points seeded, lifecycle exercised.');

What you'll seeconsole: session getters before the cut, optional commit, then cancel on the second pass.

Open in editor →

PolyPen tool: placeVertex + placeEdge + placeFace + placeTriangleFromEdge in one session

Open a PolyPen retopo session against a reference surface and demonstrate every placement primitive: vertex, edge, quad face, triangle from edge. Commit bakes the new geometry; a second pass cancels.

Methods usedModelEditor.create.cube Utils.wait.frame ModelEditor.viewport.frameAll node.translate mesh.polyPen polyPenSession.toolId polyPenSession.meshId polyPenSession.state polyPenSession.isActive polyPenSession.placeVertex polyPenSession.placeEdge polyPenSession.placeFace polyPenSession.placeTriangleFromEdge polyPenSession.commit polyPenSession.cancel

Example

// Self-contained: reference cube the PolyPen retopo session draws onto.
const refCube = await create.cube({
  width: 1.5, height: 1.5, depth: 1.5,
  subdivisionsX: 3, subdivisionsY: 3, subdivisionsZ: 3,
  name: 'PolyPenDemo',
});
refCube.translate.set([2.5, 1.3, -0.7]);
select(null, { mode: 'clear' });

// Open with every PolyPen opt set. worldCoords:true lets a headless script
// pass literal [x,y,z] positions instead of screen-space clicks.
const session = await refCube.polyPen({
  mode: 'quad',       // 'quad' | 'tri' | 'extrude' | 'append' — fill behavior (default 'quad')
  symmetry: 'x',      // 'x' | 'y' | 'z' | null — mirror every placement across this axis
  worldCoords: true,  // interpret inputs as literal world positions (skips raycasting)
});
console.log('session opened: ' + JSON.stringify({
  toolId: session.toolId,
  meshIdHead: session.meshId.slice(0, 8),
  state: session.state,
  isActive: session.isActive,
}));

// World-coords mode: placeVertex / placeEdge accept a single [x,y,z];
// placeFace requires exactly 4 [x,y,z] tuples (a quad); placeTriangleFromEdge
// grows a tri from an existing QuadDraw edge id. Headless -> may throw, so
// guard with try/catch and cancel on failure.
try {
  session.placeVertex([0, 0.5, 0]);            // seed vertex
  session.placeEdge([0.2, 0.5, 0]);            // edge to the next point
  session.placeFace([                          // quad = 4 corners
    [0.4, 0.5, 0],
    [0.4, 0.5, 0.4],
    [0.6, 0.5, 0.4],
    [0.6, 0.5, 0],
  ]);
  // apex id is empty when the executor merged the apex into a nearby vert.
  const apex = session.placeTriangleFromEdge('seed-vert-A-seed-vert-B', [0.8, 0.5, 0.2]);
  console.log('placeTriangleFromEdge apex id: ' + JSON.stringify(apex));
  await session.commit();
} catch (e) {
  console.log('placement skipped (no QuadDraw seed in headless context): ' + (e && e.message ? e.message : String(e)));
  session.cancel();
}
console.log('after first session: state=' + session.state);

// Second pass: open + cancel to demonstrate the abort path.
const second = await refCube.polyPen({ mode: 'tri', worldCoords: true });
second.cancel();
console.log('after cancel: state=' + second.state + ' isActive=' + second.isActive);

await Utils.wait.frame();
viewport.frameAll();
console.log('polypen demo complete: vertex + edge + quad + tri placements exercised.');

What you'll seeconsole: session getters, placement attempts, optional commit, then cancel.

Open in editor →

Slice (freeform): set two endpoints in client-pixel space, commit; cancel a second pass

Open the freeform Slice session and drive setEndpoints with two client-pixel points to define a camera-relative cut. Commit bakes the cut; a second pass cancels.

Methods usedModelEditor.create.cube Utils.wait.frame ModelEditor.viewport.frameAll node.translate mesh.slice sliceFreeformSession.toolId sliceFreeformSession.meshId sliceFreeformSession.state sliceFreeformSession.isActive sliceFreeformSession.setEndpoints sliceFreeformSession.commit sliceFreeformSession.cancel

Example

// Self-contained: subdivided cube for the freeform slice to cross.
const cube = await create.cube({
  width: 1, height: 1, depth: 1,
  subdivisionsX: 3, subdivisionsY: 3, subdivisionsZ: 3,
  name: 'SliceFreeformDemo',
});
cube.translate.set([2.5, 1.3, -0.7]);
select(null, { mode: 'clear' });

// mode defaults to 'freeform'; set it explicitly for clarity.
const session = await cube.slice({
  mode: 'freeform', // 'freeform' (two screen points) | 'plane' (axis + offset)
});
console.log('session opened: ' + JSON.stringify({
  toolId: session.toolId,
  meshIdHead: session.meshId.slice(0, 8),
  state: session.state,
  isActive: session.isActive,
}));

// setEndpoints takes two SlicePoint = [clientX, clientY] arrays. The freeform
// kernel projects them through the active camera to build a cutting plane
// perpendicular to the screen. Headless -> no live camera, so commit throws.
try {
  session.setEndpoints([300, 250], [700, 350]); // two screen-space endpoints
  await session.commit();
  console.log('after commit: V=' + cube.verts.count + ' F=' + cube.faces.count);
} catch (e) {
  console.log('cut skipped (no live camera context): ' + (e && e.message ? e.message : String(e)));
  session.cancel();
}

// Second pass: open + cancel to demonstrate the abort path.
const second = await cube.slice({ mode: 'freeform' });
second.cancel();
console.log('after cancel: state=' + second.state + ' isActive=' + second.isActive);

await Utils.wait.frame();
viewport.frameAll();
console.log('freeform slice demo complete: two endpoints set, lifecycle exercised.');

What you'll seeconsole: session getters, endpoint configuration, optional commit, then cancel.

Open in editor →

Slice (plane, one-shot): mode + axis + offset + fill + oneShot — headless cut

Cut a mesh headless with mesh.slice({ mode:"plane", axis, offset, fill, oneShot:true }). A non-oneShot slice returns an INTERACTIVE session and applies nothing, so a script MUST pass oneShot:true (with axis + offset) to actually cut. There is no setAxis/setOffset/setFill chain.

Methods usedModelEditor.create.cube Utils.wait.frame ModelEditor.viewport.frameAll node.translate mesh.slice mesh.verts mesh.faces

Example

// Self-contained: subdivided cube for the axis-aligned plane cut. mesh.slice
// in PLANE mode with oneShot:true runs HEADLESS (no interactive drag session).
// The interactive setAxis()/setOffset()/setFill() chain does NOT exist on this
// API — the cut is fully described by the SliceOpts bag passed up front.
const cube = await create.cube({
  width: 1, height: 1, depth: 1,
  subdivisionsX: 3, subdivisionsY: 3, subdivisionsZ: 3,
  name: 'SlicePlaneDemo',
});
cube.translate.set([2.5, 1.3, -0.7]);
await select(null, { mode: 'clear' });
const before = { v: cube.verts.count, f: cube.faces.count };
console.log('start: V=' + before.v + ' F=' + before.f);

// Every SliceOpts field, each with an explicit non-default value + comment:
const result = await cube.slice({
  mode: 'plane',   // 'plane' = axis + offset cut; 'freeform' is interactive-only
  axis: 'z',       // 'x' | 'y' | 'z' — cutting plane is perpendicular to this axis
  offset: 0.15,    // signed plane position along axis, scene units (off-center cut)
  fill: true,      // reserved for symmetry with Bisect; the slice kernel IGNORES it
  oneShot: true,   // REQUIRED for scripts — headless commit (omit it and nothing cuts)
});
console.log('slice result: ' + ('ok' in result ? ('ok=' + result.ok) : 'session'));
console.log('after slice: V ' + before.v + '->' + cube.verts.count
  + ', F ' + before.f + '->' + cube.faces.count);

await Utils.wait.frame();
viewport.frameAll();
console.log('plane slice (one-shot) complete on "' + cube.name + '".');

What you'll seeconsole: V/F counts before and after the one-shot plane cut.

Open in editor →

Slice router: open in plane mode (axis/offset) and freeform mode (endpoints) and exercise every router method

The slice router is the public entry behind mesh.slice(): it discriminates on mode and forwards to either SlicePlaneSession or SliceFreeformSession. This recipe opens both modes and exercises every router-level method.

Methods usedModelEditor.create.cube Utils.wait.frame ModelEditor.viewport.frameAll node.translate mesh.slice sliceRouterSession.toolId sliceRouterSession.meshId sliceRouterSession.state sliceRouterSession.isActive sliceRouterSession.setAxis sliceRouterSession.setEndpoints sliceRouterSession.setOffset sliceRouterSession.commit sliceRouterSession.cancel

Example

// Self-contained: two cubes — one for plane mode, one for freeform. The
// slice router (mesh.slice) discriminates on mode and forwards to either the
// SlicePlaneSession or the SliceFreeformSession behind a single API.
const planeCube = await create.cube({
  width: 1, height: 1, depth: 1,
  subdivisionsX: 3, subdivisionsY: 3, subdivisionsZ: 3,
  name: 'SliceRouterPlane',
});
planeCube.translate.set([-1.5, 1.3, -0.7]);
select(null, { mode: 'clear' });

// PLANE MODE — setAxis / setOffset live on the router; setEndpoints would throw.
const planeSession = await planeCube.slice({ mode: 'plane', axis: 'x', offset: 0 });
console.log('plane session: ' + JSON.stringify({
  toolId: planeSession.toolId,
  meshIdHead: planeSession.meshId.slice(0, 8),
  state: planeSession.state,
  isActive: planeSession.isActive, // customer-facing status getter
}));
planeSession
  .setAxis('x')   // cut perpendicular to X
  .setOffset(0);  // through center
await planeSession.commit();
console.log('plane mode committed; state=' + planeSession.state);

// FREEFORM MODE — setEndpoints lives on the router; setAxis / setOffset would throw.
const freeCube = await create.cube({
  width: 1, height: 1, depth: 1,
  subdivisionsX: 3, subdivisionsY: 3, subdivisionsZ: 3,
  name: 'SliceRouterFreeform',
});
freeCube.translate.set([1.5, 1.3, -0.7]);
select(null, { mode: 'clear' });

const freeSession = await freeCube.slice({ mode: 'freeform' });
console.log('freeform session: ' + JSON.stringify({
  toolId: freeSession.toolId,
  meshIdHead: freeSession.meshId.slice(0, 8),
  state: freeSession.state,
  isActive: freeSession.isActive,
}));
try {
  freeSession.setEndpoints([300, 250], [700, 350]); // SlicePoint = [clientX, clientY]
  await freeSession.commit();
  console.log('freeform mode committed; state=' + freeSession.state);
} catch (e) {
  console.log('freeform commit skipped (no camera context): ' + (e && e.message ? e.message : String(e)));
  freeSession.cancel();
}

// Third (plane) session — configure then cancel to demonstrate the abort path.
const third = await planeCube.slice({ mode: 'plane' });
third
  .setAxis('y')
  .setOffset(0.5);
third.cancel(); // reverts the preview + tears down the editor subscription (idempotent)
console.log('after cancel: state=' + third.state + ' isActive=' + third.isActive);

await Utils.wait.frame();
viewport.frameAll();
console.log('slice router demo complete: plane committed, freeform + cancel exercised.');

What you'll seeconsole: per-mode session getters, configuration applied, optional commit, then cancel.

Open in editor →

HSW honeycomb wall (grid panel)

The HSW panel itself - a staggered grid of 20 mm hex sockets with the snap-lock lip, sized by columns and rows. Everything else clips into it.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// HSW grid — fast slab-minus-lipped-hex-holes build.
// Renders any size in ~seconds (one difference instead of a union of many
// struts), with the standard honeycomb-wall snap-lock profile. Self-contained.

$fn = 48;
cols = 3;
rows = 3;
depth = 8;

HSWX_INSIDE  = 20;
HSWX_WALL    = 1.8;
HSWX_OUTSIDE = HSWX_INSIDE + HSWX_WALL*2;   // 23.6
R_out        = HSWX_OUTSIDE / sqrt(3);      // outer circumradius 13.626
PITCH_X      = 1.5 * R_out;                 // 20.44 flat-top column pitch
PITCH_Y      = HSWX_OUTSIDE;                // 23.6  row pitch
STAG_Y       = HSWX_OUTSIDE / 2;            // 11.8  alternate-column stagger

// flat-top hexagon, flat-to-flat = af, as a 2D shape
module hexF(af) { circle(r = af/sqrt(3), $fn = 6); }

// one lipped hex socket: front mouth at z=0, bore into -z, lock step at 5.1-6mm.
// profile (the standard wall-hole inverse): 21mm chamfered mouth -> 20mm bore
// (front 5.1mm) -> taper 20->22 (depth 5.1-6) -> 22mm pocket to the back.
module hsw_hole(d = depth) {
    eps = 0.02;
    // mouth chamfer: 21mm at z=0 down to 20mm at z=-0.5
    translate([0,0,-0.5]) linear_extrude(0.5+eps, scale = 21/20) hexF(20);
    // front bore: 20mm, z=-0.5 .. -5.1
    translate([0,0,-5.1]) linear_extrude(4.6+eps) hexF(20);
    // lock taper: 22mm at z=-6 up to 20mm at z=-5.1 (the catch step)
    translate([0,0,-6]) linear_extrude(0.9+eps, scale = 20/22) hexF(22);
    // back pocket: 22mm, z=-6 .. -d
    if (d > 6) translate([0,0,-d]) linear_extrude(d-6+eps) hexF(22);
}

module hsw_grid(cols = 3, rows = 3, d = depth) {
    spanX = (cols-1) * PITCH_X;
    spanY = (rows-1) * PITCH_Y;
    slabW = spanX + HSWX_OUTSIDE;
    slabD = spanY + HSWX_OUTSIDE + STAG_Y;
    difference() {
        translate([0, 0, -d/2]) cube([slabW, slabD, d], center = true);
        for (c = [0:cols-1]) {
            stag = (c % 2 == 1) ? STAG_Y : 0;
            for (r = [0:rows-1]) {
                x = c*PITCH_X - spanX/2;
                y = r*PITCH_Y - spanY/2 + stag - STAG_Y/2;
                translate([x, y, 0]) hsw_hole(d);
            }
        }
    }
}

hsw_grid(cols, rows);
`);

Open in editor →

HSW spring clip (snap-lock connector)

The bare snap-in spring connector that locks into a single hex hole - push it in and the barbs catch behind the wall lip.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// ============================================================================
//  HSW spring clip — self-contained snap-lock connector for one wall cell.
//  The profile uses an inline rounded-polygon helper (round_corners, circle
//  method) so it needs no external libraries.
// ============================================================================
$fn = 48;

// ---- honeycomb-wall interface constants ----
HSWX_INSIDE       = 20;
HSWX_WALL         = 1.8;
HSWX_OUTSIDE      = HSWX_INSIDE + HSWX_WALL*2;     // 23.6
HSWX_SIDE         = HSWX_OUTSIDE / sqrt(3);
HSWX_OD           = HSWX_SIDE * 2;
HSWX_DEPTH        = 8;
HSWX_LOCK_DEPTH   = 5;
HSWX_LOCK_LIP     = 1;
HSWX_LOCK_CHAMFER = HSWX_LOCK_LIP;

// ---- plug constants ----
plug_base_thickness   = 1;
plug_base_lip         = 1;
plug_stud_thickness   = 1.7;
plug_stud_height      = HSWX_LOCK_DEPTH-2;
plug_spring_base      = 3;
plug_spring_depth     = 5;
plug_spring_thickness = 1.4;

// ============================================================================
//  Inline round_corners (circle method) — self-contained
// ============================================================================
function _unit(v) = v / norm(v);
function _approx(a,b) = abs(a-b) < 1e-9;
// angle (deg) at the middle point p1, between vectors (p0-p1) and (p2-p1)
function _vangle3(p0,p1,p2) =
    let(a=p0-p1, b=p2-p1)
    acos( max(-1, min(1, (a*b)/(norm(a)*norm(b)) )) );
// minor arc from 'start' to 'end' about center 'cp', N points
function _arcpts(N, cp, start, end) =
    let(
        a0 = atan2(start[1]-cp[1], start[0]-cp[0]),
        a1 = atan2(end[1]-cp[1],   end[0]-cp[0]),
        r  = norm(start-cp),
        d0 = a1 - a0,
        da = d0 - 360*floor((d0+180)/360)      // normalize to (-180,180]
    )
    [ for(j=[0:N-1]) cp + r*[cos(a0+da*j/(N-1)), sin(a0+da*j/(N-1))] ];
// one rounded corner (radius measure)
function _circlecorner(p0,p1,p2,r,fn) =
    let(
        ang  = _vangle3(p0,p1,p2)/2,
        d    = r/tan(ang),
        prev = _unit(p0-p1),
        next = _unit(p2-p1)
    )
    _approx(ang,90) ? [p1+prev*d, p1+next*d] :
    let(
        center = r/sin(ang)*_unit(prev+next) + p1,
        start  = p1+prev*d,
        end    = p1+next*d,
        N      = max(3, ceil((90-ang)/180*fn))
    )
    _arcpts(N, center, start, end);
// round_corners(circle) for a CLOSED path. pts=[[x,y]...], rds=[r...] (0=sharp)
function _round_corners(pts, rds, fn=90) =
    let(n = len(pts))
    [ for(i=[0:n-1]) each
        rds[i]==0 ? [pts[i]]
                  : _circlecorner(pts[(i-1+n)%n], pts[i], pts[(i+1)%n], rds[i], fn)
    ];

// ============================================================================
//  hsw_clip — profile outline + rounding
// ============================================================================
module hsw_clip(center=false, rotate=0, hexbase=0, rectbase=0, slop=0) {
    hswx_inside = HSWX_INSIDE - slop;
    // outline points
    pts = [
        [ -plug_base_lip,                              0 ],
        [           slop,                              0 ],
        [           slop,                HSWX_LOCK_DEPTH ],
        [ -HSWX_LOCK_LIP,  HSWX_LOCK_LIP+HSWX_LOCK_DEPTH ],
        [ -HSWX_LOCK_LIP,                     HSWX_DEPTH ],
        [ plug_stud_thickness,                HSWX_DEPTH ],
        [ plug_spring_base,                   HSWX_DEPTH ],
        [ hswx_inside/2,  HSWX_DEPTH-plug_spring_depth-0.5 ],
        [ hswx_inside-plug_spring_base,       HSWX_DEPTH ],
        [ hswx_inside-plug_stud_thickness,    HSWX_DEPTH ],
        [ hswx_inside,                        HSWX_DEPTH ],
        [ hswx_inside+HSWX_LOCK_LIP, HSWX_LOCK_DEPTH+HSWX_LOCK_LIP ],
        [ hswx_inside,                   HSWX_LOCK_DEPTH ],
        [ hswx_inside,                              0.1 ],
        [ hswx_inside+0.1,                           0 ],
        [ hswx_inside-plug_stud_thickness-0.5,       0 ],
        [ hswx_inside-plug_stud_thickness,         0.5 ],
        [ hswx_inside-plug_stud_thickness, HSWX_DEPTH-plug_spring_thickness-1.4 ],
        [ hswx_inside-plug_spring_base+.1, HSWX_DEPTH-plug_spring_thickness-0.1 ],
        [ HSWX_INSIDE/2,  HSWX_DEPTH-plug_spring_depth-plug_spring_thickness ],
        [ plug_spring_base, HSWX_DEPTH-plug_spring_thickness ],
        [ plug_stud_thickness,              HSWX_DEPTH/3 ],
        [ HSWX_INSIDE/3.4,                           0 ],
        [ plug_stud_thickness,                       0 ],
    ];
    // per-vertex rounding radii (0 = sharp)
    rds = [ 0, 0.1, 0, 0.5, 1.5, 0, 3.5, 5.0, 3.5, 0, 2.0, 0.5, 0,
            0.1, 0, 0, 1.0, 1.5, 1.0, 6.0, 2.0, 1.0, 0, 0 ];

    translate(center ? [0,0,0] : [HSWX_INSIDE/2, HSWX_INSIDE/4, 0])
    rotate([0,0,rotate])
        union() {
            translate([-HSWX_INSIDE/2, -HSWX_INSIDE/4, 0])
                rotate([-90,0,0])
                    linear_extrude(HSWX_INSIDE/2)
                        polygon( _round_corners(pts, rds, 90) );
        }
}

// render the bare connector for inspection
hsw_clip(center=true);
`);

Open in editor →

HSW friction mount (plug + back-plate)

A back-plate carrying a lattice of friction hex plugs - the simple, render-safe foundation that accessories build on.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// HSW simple friction mount — the shared, render-safe foundation accessories
// build on. A back-plate (front, +Z) carries plug(s) on the -Z side that press
// into the 20 mm hex holes. Millimetre-native. Self-contained.
$fn = 48;

HSW_PITCH_X = 20.4382;   // column pitch (flat-top honeycomb)
HSW_PITCH_Y = 23.6;      // row pitch
HSW_STAG_Y  = 11.8;      // alternate-column stagger

// one hex plug: presses into a single 20 mm hole, 'fit' = friction clearance.
module hsw_plug(fit = 0.35, len = 7) {
    af = 20 - 2 * fit;                 // flat-to-flat, slightly under 20
    translate([0, 0, -len])
        cylinder(h = len, d = af / cos(30), $fn = 6);   // hex prism into -Z
}

// a back-plate (front face at +Z) carrying an nx×ny plug lattice on -Z.
module hsw_mount(nx = 1, ny = 1, plate_t = 3, fit = 0.35) {
    spanX = (nx - 1) * HSW_PITCH_X;
    spanY = (ny - 1) * HSW_PITCH_Y;
    w = spanX + 24;
    d = spanY + 24;
    translate([0, 0, plate_t / 2]) cube([w, d, plate_t], center = true);   // plate
    for (c = [0 : nx - 1]) {
        stag = (c % 2 == 1) ? HSW_STAG_Y : 0;
        for (r = [0 : ny - 1])
            translate([c * HSW_PITCH_X - spanX / 2,
                       r * HSW_PITCH_Y - spanY / 2 + stag - HSW_STAG_Y / 2, 0])
                hsw_plug(fit);
    }
}

// demo: a 2×2 mount (the accessory body would union onto the +Z plate face)
hsw_mount(2, 2);
`);

Open in editor →

HSW Bin

A parametric wall bin split into sections, with optional honeycomb-pattern panels on the front, back, sides, separators and bottom. Clips on with hex connectors.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
width = 100;
back_height = 20;
front_height = 15;
depth = 30;

sections = 3;
wall_thickness = 2;
separator_thickness = 1;

front_wall_honeycomb = false;
back_wall_honeycomb = false;
sides_honeycomb = false;
separators_honeycomb = true;
bottom_honeycomb = false;

//-----------------
/* [Honeycomb pattern] */ 

// diameter in mm
hexagon_size = 10;
// mm
hexagon_spacing = 1;

hex_radius = hexagon_size / 2;
hex_width = sqrt(3) * hex_radius;
raster_spacing = hex_width + hexagon_spacing;


//-----------------
/* [HSW connector] */ 

// inner distance between corners
connector_size = 15.47;
connector_depth = 13;
tolerance = 0.1;
hexagon_distance = 40.88;

/* functions*/
function hexagon(radius) = [
    for (i = [0:5])
        [radius * cos(i * 60), radius * sin(i * 60)]
];

module hsw_connector() {
    rotate([90, 0, 0])
    linear_extrude(height = connector_depth)
    offset(r = -tolerance)
    polygon(points = hexagon(connector_size / 2));
}

module connectors() {
    count = max(1, round(width / (hexagon_distance + connector_size / 2)));
    dist = (width - (count-1) * hexagon_distance) / 2;
    h = (connector_size/2 - tolerance)*sqrt(3)/2;
    
    translate([dist, connector_depth - wall_thickness, h])
    for (i = [1 : count]) {
        translate([(i-1) * hexagon_distance, 0, 0])
        hsw_connector();    
    }
    
    rotate([90, 0, 0])
    hex_panel(width, back_height, wall_thickness, !back_wall_honeycomb, true);
}

module hexagon_cutout() {
    circle(hex_radius, $fn=6);
}
 
module hex_grid(size_x, size_y, solid = false, frame = false) {
    difference(){
        square([size_x, size_y]);
        
        if (!solid) {
            for (x = [-hex_radius : raster_spacing - 1 : size_x + hex_radius]) {
                for (y = [-hex_radius : raster_spacing : size_y + hex_radius]) {
                    translate(
                        [x,
                        y + (((x / raster_spacing) % 2) * raster_spacing / 2)])
                        hexagon_cutout();
                }
            }
        }
    }
    
    if (frame) {
        difference() {
            square([size_x, size_y]);
            
            translate([wall_thickness, wall_thickness])
            square([size_x - wall_thickness * 2, size_y - wall_thickness * 2]);
        }
    }
}

module hex_panel(size_x, size_y, thickness, solid = false, frame = false) {
    linear_extrude(thickness)
    hex_grid(size_x, size_y, solid, frame);
}

module hex_side(thickness = wall_thickness, solid = false) {
    linear_extrude(thickness)
    hex_grid(depth, back_height, solid);
}

module side(thickness = wall_thickness, solid = false) {
    intersection() {
        translate([wall_thickness, wall_thickness, 0])
        rotate([90, 0, -90])
        hex_side(thickness, solid);
        
        rotate([0, 90, 0])
        linear_extrude(wall_thickness)
        polygon([[0, 0], [0, -depth], [-front_height, -depth], [-back_height, 0]]);
    }

    translate([wall_thickness-thickness, 0, 0])
    rotate([0,90,0])
    linear_extrude(thickness)
    difference() {
        polygon([[0, 0], [0, -depth], [-front_height, -depth], [-back_height, 0]]);

        offset(-wall_thickness)
        polygon([[0, 0], [0, -depth], [-front_height, -depth], [-back_height, 0]]);
    }
}


module tray() {
    // bottom
    translate([0, -depth, 0])
    hex_panel(width, depth, wall_thickness, !bottom_honeycomb, true);

    // front
    translate([0, wall_thickness - depth, 0])
    rotate([90, 0, 0])
    hex_panel(width, front_height, wall_thickness, !front_wall_honeycomb, true);
    
    // sides
    side(wall_thickness, !sides_honeycomb);
    
    translate([width - wall_thickness, 0, 0])
    side(wall_thickness, !sides_honeycomb);
}

module separators() {
    section_count = max(1, sections);
    count = max(section_count - 1, 1);
    for (i = [1 : count]) {
        translate([i * width / (count + 1), 0, 0])
        side(separator_thickness, !separators_honeycomb);
    }
}

/* MAIN */
connectors();
tray();
if (sections > 1) {
    separators();
}
`);

Open in editor →

HSW Tube Holder (diamond lattice)

A row of round tube holders with decorative diamond-lattice walls and a bottom plate, on a hex-connector strip. Set square_size = 0 for solid (faster) walls.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// number of tubes
tube_count = 4;
inner_diameter = 50;
// thickness of tube wall
wall_thickness = 2;
// total tube lenght in mm
height = 80;

// hole size in mm, set to 0 for solid walls
square_size = 8;
// grid thickness in mm
grid_thickness = 3;

// bottom plate
bottom_plate = true;

// additional connector for stronger connection
wider_connection = false;

// taller back wall
taller_connection = false;

inner_radius = inner_diameter/2;
outer_radius = inner_radius + wall_thickness;


//-----------------
/* [HSW connector] */ 

// inner distance between corners
connector_size = 15.47;
connector_depth = 13;
tolerance = 0.1;
hexagon_distance = 40.88;

$fn = 100;

/* functions*/
module diamond_tube() {
	square_diagonal = sqrt(square_size * square_size * 2);
	spacing = square_diagonal + grid_thickness;
	outer_circumference = outer_radius * 2 * PI;
	steps = round(outer_circumference / spacing);
	angle_step = 360 / steps;

	difference() {
		cylinder(h = height, r = outer_radius);

		cylinder(h = height + 1, r = inner_radius);

		// Square pattern
		union() {
			for (pattern = [0 : 1]) {
				for (z = [0 : square_diagonal + grid_thickness : height]) {
					for (angle = [angle_step/2 * pattern : angle_step : 360]) {
						rotate([0, 0, angle])
							translate([inner_radius + (outer_radius - inner_radius) / 2, 0, z + spacing /2 * pattern])
							rotate([0, 90])
							rotate([0, 0, 45])
							linear_extrude(height=wall_thickness*3, center=true)
							square([square_size, square_size], center = true);
					}
				}
			}
		}
	}

	difference() {
		union() {
			translate([0, 0, height - grid_thickness])
				cylinder(h = grid_thickness, r = outer_radius);

			cylinder(h = grid_thickness, r = outer_radius);
		}

		translate([0,0, -1])
			cylinder(h = height + 2, r = inner_radius);
	}

	if (bottom_plate) {
		cylinder(h = wall_thickness, r = outer_radius);
	}
}

function hexagon(radius) = [
    for (i = [0:5])
        [radius * cos(i * 60), radius * sin(i * 60)]
];

module hsw_connector() {
    rotate([90, 0, 0])
    linear_extrude(height = connector_depth)
    offset(r = -tolerance)
    polygon(points = hexagon(connector_size / 2));
}

module connectors() {
    tubes_width = tube_count * (inner_diameter + wall_thickness) + wall_thickness;

    count = max(1, round((wider_connection ? 1 : 0) + tubes_width / (hexagon_distance + connector_size / 2)));
    strip_width = (count - 0.5) * hexagon_distance;

    real_width = strip_width;
    
    dist = (real_width - (count-1) * hexagon_distance) / 2;
    h = (connector_size/2 - tolerance)*sqrt(3)/2;    
    diff = (tubes_width - strip_width) / 2;
    
    translate([-outer_radius + diff, 0, 0])
    union() {
        translate([dist, connector_depth, h])
        for (i = [1 : count]) {
            translate([(i-1) * hexagon_distance, 0, 0])
            hsw_connector();    
        }

        cube([real_width, wall_thickness, connector_size * (taller_connection ? 2 : 1)], center = false);
    }
}

/* MAIN */
connectors();
for (i = [1 : tube_count]) {
//    translate([(i-1) * (outer_radius * 2), wall_thickness-outer_radius, 0])
    translate([(i-1) * (inner_radius * 2 + wall_thickness), wall_thickness-outer_radius, 0])
    diamond_tube();
}
`);

Open in editor →

HSW Scalpel / Craft-Knife Holder

Holds a round knife handle with internal retention lips and a side slot for spare blades; clips on with a hex plug.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
THICKNESS = 1.0;

outer_diameter = 9.0;
inner_diameter = 7.86;
holder_height = 50;

cutout_width = 1.5;
blades_holder_width = 3.0;
cutout_height = 30;
blade_width = 8.1;

lip_width = 1.5;

chamfer = 1;

$fn=200;

/* [Hidden] */
PLUG_HEXAGON_DIAMETER = 15.3;
PLUG_LENGTH = 10;

module hexagon_plug(){
    cylinder(d=PLUG_HEXAGON_DIAMETER, h=PLUG_LENGTH, $fn=6, center=true);
}

module housing() {
    xw = max(outer_diameter + THICKNESS * 2, PLUG_HEXAGON_DIAMETER + THICKNESS * 2) + chamfer*2;
    yw = outer_diameter + THICKNESS * 2 + chamfer*2;
    zw = holder_height + THICKNESS * 2 + chamfer*2;
    difference() {
        cuboid([xw, yw, zw], chamfer=chamfer);
        translate([0, 0, THICKNESS]) tube(ir = 0, or=outer_diameter / 2, h=holder_height + THICKNESS*2 * chamfer*2, center=true);
    }
    translate([0, yw/2 + PLUG_LENGTH/2, zw/2 - PLUG_LENGTH/2 - chamfer*2 - THICKNESS]) rotate([90, 0, 0]) hexagon_plug();

    translate([0, -yw/2 - blades_holder_width / 2 - THICKNESS + chamfer, -zw / 2 + cutout_height / 2]) {
        difference() {
            cuboid([xw, blades_holder_width + THICKNESS * 2 + chamfer * 2, cutout_height], chamfer=chamfer);
            translate([0, 0, THICKNESS]) cuboid([blade_width, blades_holder_width, cutout_height]);
        }
    }
}


module lip() {
    width = outer_diameter - inner_diameter;
    translate([outer_diameter / 2 + width / 2, 0, (cutout_height) / 2 - 2]) {
        scale([width, lip_width, 1])
        tube(ir=0, or=1, holder_height - cutout_height);
    }
}

module lips() {
    intersection() {
        union() {
            rotate([0, 0, 30]) lip();
            rotate([0, 0, -30]) lip();

            rotate([0, 0, 210]) lip();
            rotate([0, 0, -210]) lip();
        }
        tube(ir = 0, or=inner_diameter / 2 + THICKNESS, holder_height + THICKNESS);
    }
}

module cutout() {
    intersection() {

        translate([0, 0, -holder_height / 2 + cutout_height / 2]) tube(ir = 0, or=outer_diameter / 2 + THICKNESS, cutout_height);

        union() {
            translate([outer_diameter / 2 + cutout_width / 2, 0, 0]) cuboid([outer_diameter, outer_diameter*2, holder_height + THICKNESS]);
            translate([-outer_diameter / 2 - cutout_width / 2, 0, 0]) cuboid([outer_diameter, outer_diameter*2, holder_height + THICKNESS]);
        }
    }
}

difference() {
    union() {
        cutout();
        lips();
        housing();
    }
}
`);

Open in editor →

HSW Pen / Pencil Cup

A round, slightly back-tilted pen and pencil cup with an optional drain hole. Pick how it clips to the wall: friction peg, bare peg (into a latch), latch insert, or spring clip.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// HSW Pen / Pencil Cup
//
// Source: honeycomb-wall pen cup
// Generated from the library above, used under its license.

/* [Wall mount] */
// How it attaches to the wall
connector_type = "peg";       // [peg:Friction peg (into wall), barepeg:Bare peg (into a latch), latch:Latch insert (into wall), clip:Spring clip (into wall)]
// Plug support style
support_style = "grid";       // [grid:Grid (aligned rows + columns), honeycomb:Honeycomb (staggered, denser)]
// Rotate the plug pattern (to match a wall mounted sideways)
connector_rotation = 0;       // [0:0 degrees, 90:90 degrees]
// Hex connectors across (wider/heavier = more)
connectors_x = 1;             // [1:8]
// Hex connector rows (2 = cantilever)
connectors_y = 2;             // [1:4]
// Fit tweak: + looser / - tighter
clearance = 0;                // [-0.3:0.05:0.5]

/* [Cup] */
// Inner bore diameter
cup_inner_d = 40;         // [20:80]
// Side wall thickness
cup_wall = 2.4;           // [1.2:0.2:4]
// Tube height (base to rim)
cup_height = 70;          // [30:120]
// Closed-base thickness
cup_base_t = 2.4;         // [1.2:0.2:5]
// Lean toward the wall (degrees)
back_tilt = 6;            // [0:15]
// Drain hole through the base
drain = true;
// Drain hole diameter
drain_d = 6;              // [3:12]

// ============================================================================
//  HSW CONNECTOR TEMPLATE — the single canonical, self-contained connector kit
//  every HSW example inlines VERBATIM so plug spacing + sizing stay identical.
//  OpenSCAD 2021.01-safe. Self-contained: no include/use, no external libraries.
//
//  THE ONE RULE: plugs (hsw_mount) and wall holes (hsw_grid) are placed by the
//  SAME lattice functions hsw_cx()/hsw_cy(), so plug(c,r) == hole(c,r) for ANY
//  count by construction — verified 0.0000 mm deviation for 1..5 in each axis.
//
//  Frame: +Z = wall-normal (out of the wall). Connectors point into -Z (into the
//  wall); the back-plate front face sits at +Z = plate_t; accessory bodies build
//  on the +Z face. UP the wall = +Y, X = horizontal.
//
//  CUSTOMIZER: everything below is in the Hidden group so a product recipe that
//  inlines this template exposes ONLY its own dimensions + connectors_x/y +
//  connector_type + one clearance tweak. The HSW internals are NEVER customer-tunable.
// ============================================================================
/* [Hidden] */
$fn = 48;

// ---- Core hex interface (the 20mm hole a connector plugs into) -------------
HSWX_INSIDE       = 20;                              // hex hole flat-to-flat
HSWX_WALL         = 1.8;                             // shared cell wall thickness
HSWX_OUTSIDE      = HSWX_INSIDE + HSWX_WALL*2;       // 23.6  outside flat-to-flat
HSWX_SIDE         = HSWX_OUTSIDE / sqrt(3);          // ~13.6255 outer side length
HSWX_DEPTH        = 8;                               // panel / plug depth (Std Duty)
HSWX_LOCK_DEPTH   = 5;                               // depth where the lock step starts
HSWX_LOCK_LIP     = 1;                               // 1mm internal lip the barb catches
HSWX_LOCK_CHAMFER = HSWX_LOCK_LIP;                   // 1mm @ 45deg lead-in

// ---- Verified honeycomb lattice (flat-topped hexes, column tiling) ---------
HSW_PITCH_X       = 1.5 * HSWX_SIDE;                 // ~20.4382 column-to-column
HSW_PITCH_Y       = HSWX_OUTSIDE;                    // 23.6    row-to-row in a column
HSW_STAGGER_Y     = HSWX_OUTSIDE / 2;               // 11.8    alternate-column offset

// ---- Shared connector tunables ---------------------------------------------
PEG_FIT_DEFAULT   = 0.35;                            // bare-peg friction clearance
PEG_LEN_DEFAULT   = 7;                               // bare-peg depth into wall (< HSWX_DEPTH)
PLATE_T_DEFAULT   = 3;                               // back-plate thickness (welds depend on it)
HSW_WELD          = 0.6;                              // connector overlap INTO the plate (one fused solid)

// Across-flats -> circumscribed diameter (a $fn=6 cylinder lands on those flats).
// af/sqrt(3)*2 is IDENTICAL to af/cos(30); ONE form library-wide.
function hsw_af_to_d(af) = af / sqrt(3) * 2;

// ============================================================================
//  THE LATTICE — the single source of truth for WHERE connectors/holes go.
//  Bounding-box-centred on the origin for ANY nx/ny (incl. the single-column
//  case): the staggered odd columns only exist when nx>1, so the y-centring of
//  the cluster is conditional on nx>1. hsw_mount AND hsw_grid both call these.
// ============================================================================
function hsw_max_stag(nx) = (nx > 1) ? HSW_STAGGER_Y : 0;     // odd col only exists if nx>1
function hsw_cx(c, nx)    = c*HSW_PITCH_X - (nx-1)*HSW_PITCH_X/2;
function hsw_cy(c, r, nx, ny) =
    r*HSW_PITCH_Y
    - (ny-1)*HSW_PITCH_Y/2
    + ((c % 2 == 1) ? HSW_STAGGER_Y : 0)            // real alternate-column stagger
    - hsw_max_stag(nx)/2;                            // centre the cluster (cond. on nx>1)

// straight=true strip: every-OTHER column, no stagger (the legacy 40.88 strip).
// Use 2*HSW_PITCH_X (=40.8764), NEVER the rounded 40.88 literal.
function hsw_cx_straight(c, nx) = c*(2*HSW_PITCH_X) - (nx-1)*(2*HSW_PITCH_X)/2;

// ============================================================================
//  CONNECTOR 1 — hsw_peg : bare friction press-peg (the de-facto canonical peg).
//  $fn=6 hex prism, across-flats = HSWX_INSIDE - 2*fit, into -Z. Press fit only.
// ============================================================================
module hsw_peg(fit = PEG_FIT_DEFAULT, len = PEG_LEN_DEFAULT) {
    af = HSWX_INSIDE - 2*fit;                        // flat-to-flat, slightly under 20
    // hex prism from z=+HSW_WELD (buried INTO the plate) down to z=-len (into wall),
    // so the peg fuses with any plate occupying z>=0 into ONE solid (no coincident-face seam).
    translate([0, 0, -len])
        cylinder(h = len + HSW_WELD, d = hsw_af_to_d(af), $fn = 6);
}

// ============================================================================
//  CONNECTOR 1b — hsw_bare_peg : the THIN CORE peg (hex-plug-library hexagon_plug)
//  that plugs into a SEPARATE latch insert pre-snapped in the wall — NOT the grid
//  directly. Verbatim dims: 14.7 across-corners, 13 deep. Into -Z, welds the plate.
// ============================================================================
BAREPEG_D   = 14.7;     // across-corners ($fn=6) — source PLUG_HEXAGON_DIAMETER
BAREPEG_LEN = 13;       // source PLUG_LENGTH
module hsw_bare_peg(fit = 0) {
    translate([0, 0, -BAREPEG_LEN])
        cylinder(h = BAREPEG_LEN + HSW_WELD, d = BAREPEG_D - 2*fit, $fn = 6);
}

// ============================================================================
//  hsw_mount(nx, ny, type, plate_t, fit, straight)
//  ONE back-plate (front face +Z = plate_t) carrying an nx*ny connector lattice
//  on -Z, placed by hsw_cx/hsw_cy. type dispatches the per-cell connector.
// ============================================================================
// straight=true  -> GRID support  : pegs on an aligned rectangular grid
//                                    (40.8764 horiz x 23.6 vert, every-other
//                                    honeycomb column -> all land in real holes).
// straight=false -> HONEYCOMB support: pegs follow the staggered hex lattice
//                                    (20.4382 column pitch, odd columns staggered).
module hsw_mount(nx = 1, ny = 1, type = "peg", plate_t = PLATE_T_DEFAULT,
                 clearance = 0, straight = false, margin = 3, crot = 0) {
    // clamp counts so a user 0 (or negative) never yields an empty / garbage mount
    gnx = max(1, nx);
    gny = max(1, ny);
    // per-type base fit (peg=press 0.35, clip=snap 0.15, latch/barepeg=0 lip-tuned)
    // + the product's single user clearance tweak (+ looser / - tighter).
    pfit = (type == "clip" ? CLIP_FIT_DEFAULT
          : (type == "latch" || type == "barepeg") ? 0
          : PEG_FIT_DEFAULT) + clearance;
    // plate footprint spans the lattice + margin. GRID has no stagger; only the
    // staggered honeycomb extends Y by the odd-column stagger.
    spanX = straight ? (gnx-1)*(2*HSW_PITCH_X) : (gnx-1)*HSW_PITCH_X;
    spanY = (gny-1)*HSW_PITCH_Y;
    w = spanX + HSWX_OUTSIDE + 2*margin;
    d = spanY + HSWX_OUTSIDE + (straight ? 0 : hsw_max_stag(gnx)) + 2*margin;
    // crot rotates the PLUG PATTERN (plate + connectors, together so plugs stay on
    // the plate) about the wall normal so the accessory can match a wall installed
    // rotated 90deg. The body is built separately by the recipe and is NOT rotated
    // (plug layout only — body fixed).
    rotate([0, 0, crot]) {
        translate([0, 0, plate_t/2]) cube([w, d, plate_t], center = true);   // plate
        for (c = [0 : gnx-1])
            for (r = [0 : gny-1]) {
                x = straight ? hsw_cx_straight(c, gnx) : hsw_cx(c, gnx);
                y = straight ? (r*HSW_PITCH_Y - spanY/2) : hsw_cy(c, r, gnx, gny);
                translate([x, y, 0]) hsw_connector(type, pfit);
            }
    }
}

// ============================================================================
//  CONNECTOR 2 — hsw_latch_insert : snap-tab latching insert (vanilla port of
//  hex-plug-library / hsw-custom-insert, sh1-verified). Built front-face(lip) at
//  z=0 with body in +Z, then flipped to -Z and welded into the plate.
// ============================================================================
INSERT_BODY_FLATS = 19.7;   INSERT_LIP_FLATS = 22.5;   INSERT_TOTAL_H = 10;
INSERT_LIP_H = 2.5;         INSERT_SNAP_H = 6.5;       INSERT_TAB_OUT = 0.5;
INSERT_TAB_LEN = 2;         INSERT_SLOT_LEN = 8;       INSERT_SLOT_W = 0.8;
INSERT_SLOT_SIDE = 1;       INSERT_SLOT_RAD = 8.25;

module _hsw_bevel_cut(diameter) {
    h = diameter/2;                                     // tan(45)==1
    difference() { cylinder(d = diameter*2, h = h); cylinder(d1 = diameter, d2 = 0, h = h); }
}
module _hsw_insert_body(fit) {
    bodyD = hsw_af_to_d(INSERT_BODY_FLATS - 2*fit);
    lipD  = hsw_af_to_d(INSERT_LIP_FLATS);
    difference() {
        union() {
            cylinder(d = bodyD, h = INSERT_TOTAL_H, $fn = 6);   // main plug
            cylinder(d = lipD,  h = INSERT_LIP_H,  $fn = 6);    // overhang lip
        }
        translate([0,0,INSERT_TOTAL_H - 0.35]) _hsw_bevel_cut(bodyD);   // soften top edge
    }
}
module hsw_latch_insert(fit = 0) {
    translate([0,0,HSW_WELD]) rotate([180,0,0])
    union() {
        // six snap tabs (non-degenerate tip r=0.2, tops kept below the bevel)
        for (i=[0:5]) rotate([0,0,i*60]) translate([0, INSERT_BODY_FLATS/2, 0])
            hull() {
                translate([0,0,INSERT_SNAP_H + INSERT_SLOT_SIDE + INSERT_TAB_OUT])
                    rotate([0,90,0]) cylinder(r = INSERT_TAB_OUT, h = INSERT_TAB_LEN, center=true, $fn=20);
                translate([0,0,INSERT_TOTAL_H - 0.6])
                    rotate([0,90,0]) cylinder(r = 0.2, h = INSERT_TAB_LEN, center=true, $fn=20);
            }
        // body with flex slots so each tab deflects on insertion
        difference() {
            _hsw_insert_body(fit);
            for (i=[0:5]) rotate([0,0,i*60]) {
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_SLOT_W, INSERT_TOTAL_H]);
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_TOTAL_H, INSERT_SLOT_SIDE]);
            }
        }
    }
}

// ============================================================================
//  CONNECTOR 3 — hsw_clip : spring snap clip (from hsw-lib-core, sh1-verified).
//  Two cantilever arms catch the 1mm lip at 5mm depth. Mouth at z=0 into -Z.
// ============================================================================
CLIP_FIT_DEFAULT = 0.15;
CLIP_AF  = HSWX_INSIDE;      // 20 plug across-flats target
CLIP_LEN = HSWX_DEPTH;       // 8  plug length into the wall
SPRING_WALL = 1.6;           // cantilever arm wall (>=1.4 to flex)
SPRING_SLOT = 2.2;           // central relief slot width
module hsw_clip(fit = CLIP_FIT_DEFAULT) {
    af = CLIP_AF - 2*fit;  L = CLIP_LEN;
    barb = HSWX_LOCK_LIP;  locz = HSWX_LOCK_DEPTH;  cham = HSWX_LOCK_CHAMFER;  halfX = af/2;
    translate([0,0,HSW_WELD])
    difference() {
        union() {
            translate([0,0,-L/2]) linear_extrude(height = L, center = true) hsw_hex2d(af);   // hex plug
            for (sx=[-1,1]) translate([sx*halfX,0,-locz]) rotate([90,0,0])                    // outward barbs
                linear_extrude(height = af*0.62, center = true)
                    polygon([[0,0],[sx*barb,0],[sx*barb,cham],[0,cham+barb]]);
            translate([0,0,0.6/2]) linear_extrude(height = 0.6, center = true) hsw_hex2d(af + 1.2);  // mouth flange
        }
        translate([0,0,-L/2-0.5]) cube([SPRING_SLOT, af+4, L+2-1.2], center = true);          // central relief slot
        for (sx=[-1,1]) translate([sx*(halfX-SPRING_WALL-0.3),0,-L/2-1]) cube([1.4, af*0.5, L], center=true);  // arm hollow
    }
}

// per-cell connector dispatch:
//   peg     = friction peg, jams the bare grid hole (one-part)
//   barepeg = thin core peg, plugs into a SEPARATE latch pre-snapped in the wall
//   latch   = snap-tab insert, snaps into the bare grid hole
//   clip    = spring clip, snaps into the bare grid hole
module hsw_connector(type = "peg", fit = PEG_FIT_DEFAULT) {
    if      (type == "latch")   hsw_latch_insert(fit);
    else if (type == "clip")    hsw_clip(fit);
    else if (type == "barepeg") hsw_bare_peg(fit);
    else                        hsw_peg(fit);
}

// ============================================================================
//  hsw_grid(nx, ny, depth) — the FEMALE wall panel. Holes placed by the SAME
//  hsw_cx/hsw_cy so a hsw_mount(nx,ny) co-registers EXACTLY (proof artifact).
//  Lipped hex socket: 20mm bore, 1mm catch lip at 5mm depth.
// ============================================================================
module hsw_hex2d(af) { rotate([0,0,90]) circle(r = af/sqrt(3), $fn = 6); }

module hsw_hex_hole(depth) {
    afMouth = HSWX_INSIDE + 2*HSWX_LOCK_CHAMFER;
    afFull  = HSWX_INSIDE;
    afLip   = HSWX_INSIDE - 2*HSWX_LOCK_LIP;
    translate([0,0,-HSWX_LOCK_CHAMFER/2 + 0.01])
        linear_extrude(HSWX_LOCK_CHAMFER + 0.02, center=true, scale = afFull/afMouth) hsw_hex2d(afMouth);
    translate([0,0,-HSWX_LOCK_DEPTH/2])
        linear_extrude(HSWX_LOCK_DEPTH + 0.02, center=true) hsw_hex2d(afFull);
    translate([0,0,-HSWX_LOCK_DEPTH])
        linear_extrude(0.6, center=true) hsw_hex2d(afLip);
    backLen = depth - HSWX_LOCK_DEPTH;
    if (backLen > 0.1)
        translate([0,0,-(HSWX_LOCK_DEPTH + backLen/2)])
            linear_extrude(backLen + 0.4, center=true) hsw_hex2d(afFull);
}

module hsw_grid(nx = 3, ny = 3, depth = HSWX_DEPTH) {
    spanX = (nx-1)*HSW_PITCH_X;
    spanY = (ny-1)*HSW_PITCH_Y;
    slabW = spanX + HSWX_OUTSIDE;
    slabD = spanY + HSWX_OUTSIDE + hsw_max_stag(nx);
    difference() {
        translate([0, -hsw_max_stag(nx)/2, -depth/2]) cube([slabW, slabD, depth], center = true);
        for (c = [0 : nx-1])
            for (r = [0 : ny-1])
                translate([hsw_cx(c, nx), hsw_cy(c, r, nx, ny), 0]) hsw_hex_hole(depth);
    }
}

// ============================================================================
//  hsw_display() — canonical AnimBox display orientation. The geometry is built
//  in the OpenSCAD print frame (scad +Z = wall normal, +Y = up the wall). The
//  The OpenSCAD->AnimBox import is IDENTITY (verified by bbox: cube([10,20,40])
//  imports to world [10,20,40]). The wall-frame is already the display frame:
//  up-the-wall (+Y) = world UP, along-the-wall (+X) = world X, wall normal (+Z)
//  = toward the viewer (the body projects out of the wall). So hsw_display() is a
//  pass-through; it stays as the single place to adjust display orientation if the
//  import convention ever changes. Wrap every recipe's top call: hsw_display() my_part();
// ============================================================================
module hsw_display() { children(); }

// ---- product body (hidden internals) ----
web_embed   = 2.0;
gap_fix     = 0.02;
cup_outer_d = cup_inner_d + 2 * cup_wall;
cup_outer_r = cup_outer_d / 2;
PLATE       = PLATE_T_DEFAULT;

module cup_body() {
    difference() {
        rotate([-90, 0, 0]) cylinder(h = cup_height, d = cup_outer_d);
        translate([0, cup_base_t, 0]) rotate([-90, 0, 0])
            cylinder(h = cup_height - cup_base_t + gap_fix, d = cup_inner_d);
        if (drain)
            translate([0, -gap_fix, 0]) rotate([-90, 0, 0])
                cylinder(h = cup_base_t + 2 * gap_fix, d = drain_d);
    }
}
module connect_web() {
    web_w = cup_outer_d - 1;
    web_h = cup_height * 0.55;
    z0 = PLATE - web_embed;
    z1 = PLATE + cup_outer_r;
    translate([-web_w / 2, 0, z0]) cube([web_w, web_h, z1 - z0]);
}
module pen_cup() {
    hsw_mount(connectors_x, connectors_y, type = connector_type, clearance = clearance,
              straight = (support_style == "grid"), crot = connector_rotation);
    translate([0, 0, PLATE]) rotate([back_tilt, 0, 0]) translate([0, 0, -PLATE]) {
        translate([0, 0, PLATE + cup_outer_r - 0.5]) cup_body();
        connect_web();
    }
}
hsw_display() pen_cup();
`);

Open in editor →

HSW Open Parts Bin

An open-top parts bin with a lowered front wall for easy scooping, on swappable wall plugs. Good for screws, clips, and small components.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// HSW Open Parts Bin
//
// Source: honeycomb-wall open parts bin
// Generated from the library above, used under its license.

/* [Wall mount] */
// How it attaches to the wall
connector_type = "peg";       // [peg:Friction peg (into wall), barepeg:Bare peg (into a latch), latch:Latch insert (into wall), clip:Spring clip (into wall)]
// Plug support style
support_style = "grid";       // [grid:Grid (aligned rows + columns), honeycomb:Honeycomb (staggered, denser)]
// Rotate the plug pattern (to match a wall mounted sideways)
connector_rotation = 0;       // [0:0 degrees, 90:90 degrees]
// Hex connectors across (wider = more)
connectors_x = 2;             // [1:8]
// Hex connector rows (more = heavier loads)
connectors_y = 2;             // [1:4]
// Fit tweak: + looser / - tighter
clearance = 0;                // [-0.3:0.05:0.5]

/* [Bin] */
// Inside width (mm)
bin_width = 80;               // [30:200]
// Inside depth out from the wall (mm)
bin_depth = 45;               // [20:120]
// Back wall height (mm)
bin_height = 50;              // [20:120]
// Front wall height — lower for scooping (mm)
front_height = 28;            // [8:120]
// Wall thickness (mm)
wall = 2.4;                   // [1.2:0.2:4]
// Floor thickness (mm)
floor_t = 2.4;                // [1.2:0.2:5]

// ============================================================================
//  HSW CONNECTOR TEMPLATE — the single canonical, self-contained connector kit
//  every HSW example inlines VERBATIM so plug spacing + sizing stay identical.
//  OpenSCAD 2021.01-safe. Self-contained: no include/use, no external libraries.
//
//  THE ONE RULE: plugs (hsw_mount) and wall holes (hsw_grid) are placed by the
//  SAME lattice functions hsw_cx()/hsw_cy(), so plug(c,r) == hole(c,r) for ANY
//  count by construction — verified 0.0000 mm deviation for 1..5 in each axis.
//
//  Frame: +Z = wall-normal (out of the wall). Connectors point into -Z (into the
//  wall); the back-plate front face sits at +Z = plate_t; accessory bodies build
//  on the +Z face. UP the wall = +Y, X = horizontal.
//
//  CUSTOMIZER: everything below is in the Hidden group so a product recipe that
//  inlines this template exposes ONLY its own dimensions + connectors_x/y +
//  connector_type + one clearance tweak. The HSW internals are NEVER customer-tunable.
// ============================================================================
/* [Hidden] */
$fn = 48;

// ---- Core hex interface (the 20mm hole a connector plugs into) -------------
HSWX_INSIDE       = 20;                              // hex hole flat-to-flat
HSWX_WALL         = 1.8;                             // shared cell wall thickness
HSWX_OUTSIDE      = HSWX_INSIDE + HSWX_WALL*2;       // 23.6  outside flat-to-flat
HSWX_SIDE         = HSWX_OUTSIDE / sqrt(3);          // ~13.6255 outer side length
HSWX_DEPTH        = 8;                               // panel / plug depth (Std Duty)
HSWX_LOCK_DEPTH   = 5;                               // depth where the lock step starts
HSWX_LOCK_LIP     = 1;                               // 1mm internal lip the barb catches
HSWX_LOCK_CHAMFER = HSWX_LOCK_LIP;                   // 1mm @ 45deg lead-in

// ---- Verified honeycomb lattice (flat-topped hexes, column tiling) ---------
HSW_PITCH_X       = 1.5 * HSWX_SIDE;                 // ~20.4382 column-to-column
HSW_PITCH_Y       = HSWX_OUTSIDE;                    // 23.6    row-to-row in a column
HSW_STAGGER_Y     = HSWX_OUTSIDE / 2;               // 11.8    alternate-column offset

// ---- Shared connector tunables ---------------------------------------------
PEG_FIT_DEFAULT   = 0.35;                            // bare-peg friction clearance
PEG_LEN_DEFAULT   = 7;                               // bare-peg depth into wall (< HSWX_DEPTH)
PLATE_T_DEFAULT   = 3;                               // back-plate thickness (welds depend on it)
HSW_WELD          = 0.6;                              // connector overlap INTO the plate (one fused solid)

// Across-flats -> circumscribed diameter (a $fn=6 cylinder lands on those flats).
// af/sqrt(3)*2 is IDENTICAL to af/cos(30); ONE form library-wide.
function hsw_af_to_d(af) = af / sqrt(3) * 2;

// ============================================================================
//  THE LATTICE — the single source of truth for WHERE connectors/holes go.
//  Bounding-box-centred on the origin for ANY nx/ny (incl. the single-column
//  case): the staggered odd columns only exist when nx>1, so the y-centring of
//  the cluster is conditional on nx>1. hsw_mount AND hsw_grid both call these.
// ============================================================================
function hsw_max_stag(nx) = (nx > 1) ? HSW_STAGGER_Y : 0;     // odd col only exists if nx>1
function hsw_cx(c, nx)    = c*HSW_PITCH_X - (nx-1)*HSW_PITCH_X/2;
function hsw_cy(c, r, nx, ny) =
    r*HSW_PITCH_Y
    - (ny-1)*HSW_PITCH_Y/2
    + ((c % 2 == 1) ? HSW_STAGGER_Y : 0)            // real alternate-column stagger
    - hsw_max_stag(nx)/2;                            // centre the cluster (cond. on nx>1)

// straight=true strip: every-OTHER column, no stagger (the legacy 40.88 strip).
// Use 2*HSW_PITCH_X (=40.8764), NEVER the rounded 40.88 literal.
function hsw_cx_straight(c, nx) = c*(2*HSW_PITCH_X) - (nx-1)*(2*HSW_PITCH_X)/2;

// ============================================================================
//  CONNECTOR 1 — hsw_peg : bare friction press-peg (the de-facto canonical peg).
//  $fn=6 hex prism, across-flats = HSWX_INSIDE - 2*fit, into -Z. Press fit only.
// ============================================================================
module hsw_peg(fit = PEG_FIT_DEFAULT, len = PEG_LEN_DEFAULT) {
    af = HSWX_INSIDE - 2*fit;                        // flat-to-flat, slightly under 20
    // hex prism from z=+HSW_WELD (buried INTO the plate) down to z=-len (into wall),
    // so the peg fuses with any plate occupying z>=0 into ONE solid (no coincident-face seam).
    translate([0, 0, -len])
        cylinder(h = len + HSW_WELD, d = hsw_af_to_d(af), $fn = 6);
}

// ============================================================================
//  CONNECTOR 1b — hsw_bare_peg : the THIN CORE peg (hex-plug-library hexagon_plug)
//  that plugs into a SEPARATE latch insert pre-snapped in the wall — NOT the grid
//  directly. Verbatim dims: 14.7 across-corners, 13 deep. Into -Z, welds the plate.
// ============================================================================
BAREPEG_D   = 14.7;     // across-corners ($fn=6) — source PLUG_HEXAGON_DIAMETER
BAREPEG_LEN = 13;       // source PLUG_LENGTH
module hsw_bare_peg(fit = 0) {
    translate([0, 0, -BAREPEG_LEN])
        cylinder(h = BAREPEG_LEN + HSW_WELD, d = BAREPEG_D - 2*fit, $fn = 6);
}

// ============================================================================
//  hsw_mount(nx, ny, type, plate_t, fit, straight)
//  ONE back-plate (front face +Z = plate_t) carrying an nx*ny connector lattice
//  on -Z, placed by hsw_cx/hsw_cy. type dispatches the per-cell connector.
// ============================================================================
// straight=true  -> GRID support  : pegs on an aligned rectangular grid
//                                    (40.8764 horiz x 23.6 vert, every-other
//                                    honeycomb column -> all land in real holes).
// straight=false -> HONEYCOMB support: pegs follow the staggered hex lattice
//                                    (20.4382 column pitch, odd columns staggered).
module hsw_mount(nx = 1, ny = 1, type = "peg", plate_t = PLATE_T_DEFAULT,
                 clearance = 0, straight = false, margin = 3, crot = 0) {
    // clamp counts so a user 0 (or negative) never yields an empty / garbage mount
    gnx = max(1, nx);
    gny = max(1, ny);
    // per-type base fit (peg=press 0.35, clip=snap 0.15, latch/barepeg=0 lip-tuned)
    // + the product's single user clearance tweak (+ looser / - tighter).
    pfit = (type == "clip" ? CLIP_FIT_DEFAULT
          : (type == "latch" || type == "barepeg") ? 0
          : PEG_FIT_DEFAULT) + clearance;
    // plate footprint spans the lattice + margin. GRID has no stagger; only the
    // staggered honeycomb extends Y by the odd-column stagger.
    spanX = straight ? (gnx-1)*(2*HSW_PITCH_X) : (gnx-1)*HSW_PITCH_X;
    spanY = (gny-1)*HSW_PITCH_Y;
    w = spanX + HSWX_OUTSIDE + 2*margin;
    d = spanY + HSWX_OUTSIDE + (straight ? 0 : hsw_max_stag(gnx)) + 2*margin;
    // crot rotates the PLUG PATTERN (plate + connectors, together so plugs stay on
    // the plate) about the wall normal so the accessory can match a wall installed
    // rotated 90deg. The body is built separately by the recipe and is NOT rotated
    // (plug layout only — body fixed).
    rotate([0, 0, crot]) {
        translate([0, 0, plate_t/2]) cube([w, d, plate_t], center = true);   // plate
        for (c = [0 : gnx-1])
            for (r = [0 : gny-1]) {
                x = straight ? hsw_cx_straight(c, gnx) : hsw_cx(c, gnx);
                y = straight ? (r*HSW_PITCH_Y - spanY/2) : hsw_cy(c, r, gnx, gny);
                translate([x, y, 0]) hsw_connector(type, pfit);
            }
    }
}

// ============================================================================
//  CONNECTOR 2 — hsw_latch_insert : snap-tab latching insert (vanilla port of
//  hex-plug-library / hsw-custom-insert, sh1-verified). Built front-face(lip) at
//  z=0 with body in +Z, then flipped to -Z and welded into the plate.
// ============================================================================
INSERT_BODY_FLATS = 19.7;   INSERT_LIP_FLATS = 22.5;   INSERT_TOTAL_H = 10;
INSERT_LIP_H = 2.5;         INSERT_SNAP_H = 6.5;       INSERT_TAB_OUT = 0.5;
INSERT_TAB_LEN = 2;         INSERT_SLOT_LEN = 8;       INSERT_SLOT_W = 0.8;
INSERT_SLOT_SIDE = 1;       INSERT_SLOT_RAD = 8.25;

module _hsw_bevel_cut(diameter) {
    h = diameter/2;                                     // tan(45)==1
    difference() { cylinder(d = diameter*2, h = h); cylinder(d1 = diameter, d2 = 0, h = h); }
}
module _hsw_insert_body(fit) {
    bodyD = hsw_af_to_d(INSERT_BODY_FLATS - 2*fit);
    lipD  = hsw_af_to_d(INSERT_LIP_FLATS);
    difference() {
        union() {
            cylinder(d = bodyD, h = INSERT_TOTAL_H, $fn = 6);   // main plug
            cylinder(d = lipD,  h = INSERT_LIP_H,  $fn = 6);    // overhang lip
        }
        translate([0,0,INSERT_TOTAL_H - 0.35]) _hsw_bevel_cut(bodyD);   // soften top edge
    }
}
module hsw_latch_insert(fit = 0) {
    translate([0,0,HSW_WELD]) rotate([180,0,0])
    union() {
        // six snap tabs (non-degenerate tip r=0.2, tops kept below the bevel)
        for (i=[0:5]) rotate([0,0,i*60]) translate([0, INSERT_BODY_FLATS/2, 0])
            hull() {
                translate([0,0,INSERT_SNAP_H + INSERT_SLOT_SIDE + INSERT_TAB_OUT])
                    rotate([0,90,0]) cylinder(r = INSERT_TAB_OUT, h = INSERT_TAB_LEN, center=true, $fn=20);
                translate([0,0,INSERT_TOTAL_H - 0.6])
                    rotate([0,90,0]) cylinder(r = 0.2, h = INSERT_TAB_LEN, center=true, $fn=20);
            }
        // body with flex slots so each tab deflects on insertion
        difference() {
            _hsw_insert_body(fit);
            for (i=[0:5]) rotate([0,0,i*60]) {
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_SLOT_W, INSERT_TOTAL_H]);
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_TOTAL_H, INSERT_SLOT_SIDE]);
            }
        }
    }
}

// ============================================================================
//  CONNECTOR 3 — hsw_clip : spring snap clip (from hsw-lib-core, sh1-verified).
//  Two cantilever arms catch the 1mm lip at 5mm depth. Mouth at z=0 into -Z.
// ============================================================================
CLIP_FIT_DEFAULT = 0.15;
CLIP_AF  = HSWX_INSIDE;      // 20 plug across-flats target
CLIP_LEN = HSWX_DEPTH;       // 8  plug length into the wall
SPRING_WALL = 1.6;           // cantilever arm wall (>=1.4 to flex)
SPRING_SLOT = 2.2;           // central relief slot width
module hsw_clip(fit = CLIP_FIT_DEFAULT) {
    af = CLIP_AF - 2*fit;  L = CLIP_LEN;
    barb = HSWX_LOCK_LIP;  locz = HSWX_LOCK_DEPTH;  cham = HSWX_LOCK_CHAMFER;  halfX = af/2;
    translate([0,0,HSW_WELD])
    difference() {
        union() {
            translate([0,0,-L/2]) linear_extrude(height = L, center = true) hsw_hex2d(af);   // hex plug
            for (sx=[-1,1]) translate([sx*halfX,0,-locz]) rotate([90,0,0])                    // outward barbs
                linear_extrude(height = af*0.62, center = true)
                    polygon([[0,0],[sx*barb,0],[sx*barb,cham],[0,cham+barb]]);
            translate([0,0,0.6/2]) linear_extrude(height = 0.6, center = true) hsw_hex2d(af + 1.2);  // mouth flange
        }
        translate([0,0,-L/2-0.5]) cube([SPRING_SLOT, af+4, L+2-1.2], center = true);          // central relief slot
        for (sx=[-1,1]) translate([sx*(halfX-SPRING_WALL-0.3),0,-L/2-1]) cube([1.4, af*0.5, L], center=true);  // arm hollow
    }
}

// per-cell connector dispatch:
//   peg     = friction peg, jams the bare grid hole (one-part)
//   barepeg = thin core peg, plugs into a SEPARATE latch pre-snapped in the wall
//   latch   = snap-tab insert, snaps into the bare grid hole
//   clip    = spring clip, snaps into the bare grid hole
module hsw_connector(type = "peg", fit = PEG_FIT_DEFAULT) {
    if      (type == "latch")   hsw_latch_insert(fit);
    else if (type == "clip")    hsw_clip(fit);
    else if (type == "barepeg") hsw_bare_peg(fit);
    else                        hsw_peg(fit);
}

// ============================================================================
//  hsw_grid(nx, ny, depth) — the FEMALE wall panel. Holes placed by the SAME
//  hsw_cx/hsw_cy so a hsw_mount(nx,ny) co-registers EXACTLY (proof artifact).
//  Lipped hex socket: 20mm bore, 1mm catch lip at 5mm depth.
// ============================================================================
module hsw_hex2d(af) { rotate([0,0,90]) circle(r = af/sqrt(3), $fn = 6); }

module hsw_hex_hole(depth) {
    afMouth = HSWX_INSIDE + 2*HSWX_LOCK_CHAMFER;
    afFull  = HSWX_INSIDE;
    afLip   = HSWX_INSIDE - 2*HSWX_LOCK_LIP;
    translate([0,0,-HSWX_LOCK_CHAMFER/2 + 0.01])
        linear_extrude(HSWX_LOCK_CHAMFER + 0.02, center=true, scale = afFull/afMouth) hsw_hex2d(afMouth);
    translate([0,0,-HSWX_LOCK_DEPTH/2])
        linear_extrude(HSWX_LOCK_DEPTH + 0.02, center=true) hsw_hex2d(afFull);
    translate([0,0,-HSWX_LOCK_DEPTH])
        linear_extrude(0.6, center=true) hsw_hex2d(afLip);
    backLen = depth - HSWX_LOCK_DEPTH;
    if (backLen > 0.1)
        translate([0,0,-(HSWX_LOCK_DEPTH + backLen/2)])
            linear_extrude(backLen + 0.4, center=true) hsw_hex2d(afFull);
}

module hsw_grid(nx = 3, ny = 3, depth = HSWX_DEPTH) {
    spanX = (nx-1)*HSW_PITCH_X;
    spanY = (ny-1)*HSW_PITCH_Y;
    slabW = spanX + HSWX_OUTSIDE;
    slabD = spanY + HSWX_OUTSIDE + hsw_max_stag(nx);
    difference() {
        translate([0, -hsw_max_stag(nx)/2, -depth/2]) cube([slabW, slabD, depth], center = true);
        for (c = [0 : nx-1])
            for (r = [0 : ny-1])
                translate([hsw_cx(c, nx), hsw_cy(c, r, nx, ny), 0]) hsw_hex_hole(depth);
    }
}

// ============================================================================
//  hsw_display() — canonical AnimBox display orientation. The geometry is built
//  in the OpenSCAD print frame (scad +Z = wall normal, +Y = up the wall). The
//  The OpenSCAD->AnimBox import is IDENTITY (verified by bbox: cube([10,20,40])
//  imports to world [10,20,40]). The wall-frame is already the display frame:
//  up-the-wall (+Y) = world UP, along-the-wall (+X) = world X, wall normal (+Z)
//  = toward the viewer (the body projects out of the wall). So hsw_display() is a
//  pass-through; it stays as the single place to adjust display orientation if the
//  import convention ever changes. Wrap every recipe's top call: hsw_display() my_part();
// ============================================================================
module hsw_display() { children(); }

// ---- product body (hidden internals) ----
eps   = 0.05;
PLATE = PLATE_T_DEFAULT;

module open_bin() {
    ow = bin_width + 2 * wall;          // outer width  (X)
    od = bin_depth + 2 * wall;          // outer depth  (Z, out from wall)
    z0 = PLATE - HSW_WELD;              // weld the back wall into the plate
    y0 = -bin_height / 2;               // centre the bin vertically so the back wall covers the plate
    difference() {
        // outer block rising up the wall (+Y), open at the top
        translate([-ow / 2, y0, z0])
            cube([ow, bin_height, od + HSW_WELD]);
        // inner cavity (leaves walls + floor, open top)
        translate([-bin_width / 2, y0 + floor_t, PLATE + wall])
            cube([bin_width, bin_height, bin_depth + eps]);
        // lower the front wall (the far +Z face) for scooping access
        translate([-bin_width / 2, y0 + front_height, PLATE + bin_depth + wall - eps])
            cube([bin_width, bin_height, wall + 2 * eps]);
    }
}
module open_parts_bin() {
    hsw_mount(connectors_x, connectors_y, type = connector_type, clearance = clearance,
              straight = (support_style == "grid"), crot = connector_rotation);
    open_bin();
}
hsw_display() open_parts_bin();
`);

Open in editor →

HSW Deep Bin

A tall, fully-enclosed bin for long parts, bottles, brushes, or rolled items, on swappable wall plugs. Open top, full-height walls.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// HSW Deep Bin
//
// Source: honeycomb-wall deep bin
// Generated from the library above, used under its license.

/* [Wall mount] */
// How it attaches to the wall
connector_type = "peg";       // [peg:Friction peg (into wall), barepeg:Bare peg (into a latch), latch:Latch insert (into wall), clip:Spring clip (into wall)]
// Plug support style
support_style = "grid";       // [grid:Grid (aligned rows + columns), honeycomb:Honeycomb (staggered, denser)]
// Rotate the plug pattern (to match a wall mounted sideways)
connector_rotation = 0;       // [0:0 degrees, 90:90 degrees]
// Hex connectors across
connectors_x = 2;             // [1:8]
// Hex connector rows (taller = more)
connectors_y = 3;             // [1:4]
// Fit tweak: + looser / - tighter
clearance = 0;                // [-0.3:0.05:0.5]

/* [Bin] */
// Inside width (mm)
bin_width = 55;               // [25:160]
// Inside depth out from the wall (mm)
bin_depth = 55;               // [20:120]
// Inside height (mm)
bin_height = 95;              // [40:200]
// Wall thickness (mm)
wall = 2.4;                   // [1.2:0.2:4]
// Floor thickness (mm)
floor_t = 2.6;                // [1.2:0.2:5]

// ============================================================================
//  HSW CONNECTOR TEMPLATE — the single canonical, self-contained connector kit
//  every HSW example inlines VERBATIM so plug spacing + sizing stay identical.
//  OpenSCAD 2021.01-safe. Self-contained: no include/use, no external libraries.
//
//  THE ONE RULE: plugs (hsw_mount) and wall holes (hsw_grid) are placed by the
//  SAME lattice functions hsw_cx()/hsw_cy(), so plug(c,r) == hole(c,r) for ANY
//  count by construction — verified 0.0000 mm deviation for 1..5 in each axis.
//
//  Frame: +Z = wall-normal (out of the wall). Connectors point into -Z (into the
//  wall); the back-plate front face sits at +Z = plate_t; accessory bodies build
//  on the +Z face. UP the wall = +Y, X = horizontal.
//
//  CUSTOMIZER: everything below is in the Hidden group so a product recipe that
//  inlines this template exposes ONLY its own dimensions + connectors_x/y +
//  connector_type + one clearance tweak. The HSW internals are NEVER customer-tunable.
// ============================================================================
/* [Hidden] */
$fn = 48;

// ---- Core hex interface (the 20mm hole a connector plugs into) -------------
HSWX_INSIDE       = 20;                              // hex hole flat-to-flat
HSWX_WALL         = 1.8;                             // shared cell wall thickness
HSWX_OUTSIDE      = HSWX_INSIDE + HSWX_WALL*2;       // 23.6  outside flat-to-flat
HSWX_SIDE         = HSWX_OUTSIDE / sqrt(3);          // ~13.6255 outer side length
HSWX_DEPTH        = 8;                               // panel / plug depth (Std Duty)
HSWX_LOCK_DEPTH   = 5;                               // depth where the lock step starts
HSWX_LOCK_LIP     = 1;                               // 1mm internal lip the barb catches
HSWX_LOCK_CHAMFER = HSWX_LOCK_LIP;                   // 1mm @ 45deg lead-in

// ---- Verified honeycomb lattice (flat-topped hexes, column tiling) ---------
HSW_PITCH_X       = 1.5 * HSWX_SIDE;                 // ~20.4382 column-to-column
HSW_PITCH_Y       = HSWX_OUTSIDE;                    // 23.6    row-to-row in a column
HSW_STAGGER_Y     = HSWX_OUTSIDE / 2;               // 11.8    alternate-column offset

// ---- Shared connector tunables ---------------------------------------------
PEG_FIT_DEFAULT   = 0.35;                            // bare-peg friction clearance
PEG_LEN_DEFAULT   = 7;                               // bare-peg depth into wall (< HSWX_DEPTH)
PLATE_T_DEFAULT   = 3;                               // back-plate thickness (welds depend on it)
HSW_WELD          = 0.6;                              // connector overlap INTO the plate (one fused solid)

// Across-flats -> circumscribed diameter (a $fn=6 cylinder lands on those flats).
// af/sqrt(3)*2 is IDENTICAL to af/cos(30); ONE form library-wide.
function hsw_af_to_d(af) = af / sqrt(3) * 2;

// ============================================================================
//  THE LATTICE — the single source of truth for WHERE connectors/holes go.
//  Bounding-box-centred on the origin for ANY nx/ny (incl. the single-column
//  case): the staggered odd columns only exist when nx>1, so the y-centring of
//  the cluster is conditional on nx>1. hsw_mount AND hsw_grid both call these.
// ============================================================================
function hsw_max_stag(nx) = (nx > 1) ? HSW_STAGGER_Y : 0;     // odd col only exists if nx>1
function hsw_cx(c, nx)    = c*HSW_PITCH_X - (nx-1)*HSW_PITCH_X/2;
function hsw_cy(c, r, nx, ny) =
    r*HSW_PITCH_Y
    - (ny-1)*HSW_PITCH_Y/2
    + ((c % 2 == 1) ? HSW_STAGGER_Y : 0)            // real alternate-column stagger
    - hsw_max_stag(nx)/2;                            // centre the cluster (cond. on nx>1)

// straight=true strip: every-OTHER column, no stagger (the legacy 40.88 strip).
// Use 2*HSW_PITCH_X (=40.8764), NEVER the rounded 40.88 literal.
function hsw_cx_straight(c, nx) = c*(2*HSW_PITCH_X) - (nx-1)*(2*HSW_PITCH_X)/2;

// ============================================================================
//  CONNECTOR 1 — hsw_peg : bare friction press-peg (the de-facto canonical peg).
//  $fn=6 hex prism, across-flats = HSWX_INSIDE - 2*fit, into -Z. Press fit only.
// ============================================================================
module hsw_peg(fit = PEG_FIT_DEFAULT, len = PEG_LEN_DEFAULT) {
    af = HSWX_INSIDE - 2*fit;                        // flat-to-flat, slightly under 20
    // hex prism from z=+HSW_WELD (buried INTO the plate) down to z=-len (into wall),
    // so the peg fuses with any plate occupying z>=0 into ONE solid (no coincident-face seam).
    translate([0, 0, -len])
        cylinder(h = len + HSW_WELD, d = hsw_af_to_d(af), $fn = 6);
}

// ============================================================================
//  CONNECTOR 1b — hsw_bare_peg : the THIN CORE peg (hex-plug-library hexagon_plug)
//  that plugs into a SEPARATE latch insert pre-snapped in the wall — NOT the grid
//  directly. Verbatim dims: 14.7 across-corners, 13 deep. Into -Z, welds the plate.
// ============================================================================
BAREPEG_D   = 14.7;     // across-corners ($fn=6) — source PLUG_HEXAGON_DIAMETER
BAREPEG_LEN = 13;       // source PLUG_LENGTH
module hsw_bare_peg(fit = 0) {
    translate([0, 0, -BAREPEG_LEN])
        cylinder(h = BAREPEG_LEN + HSW_WELD, d = BAREPEG_D - 2*fit, $fn = 6);
}

// ============================================================================
//  hsw_mount(nx, ny, type, plate_t, fit, straight)
//  ONE back-plate (front face +Z = plate_t) carrying an nx*ny connector lattice
//  on -Z, placed by hsw_cx/hsw_cy. type dispatches the per-cell connector.
// ============================================================================
// straight=true  -> GRID support  : pegs on an aligned rectangular grid
//                                    (40.8764 horiz x 23.6 vert, every-other
//                                    honeycomb column -> all land in real holes).
// straight=false -> HONEYCOMB support: pegs follow the staggered hex lattice
//                                    (20.4382 column pitch, odd columns staggered).
module hsw_mount(nx = 1, ny = 1, type = "peg", plate_t = PLATE_T_DEFAULT,
                 clearance = 0, straight = false, margin = 3, crot = 0) {
    // clamp counts so a user 0 (or negative) never yields an empty / garbage mount
    gnx = max(1, nx);
    gny = max(1, ny);
    // per-type base fit (peg=press 0.35, clip=snap 0.15, latch/barepeg=0 lip-tuned)
    // + the product's single user clearance tweak (+ looser / - tighter).
    pfit = (type == "clip" ? CLIP_FIT_DEFAULT
          : (type == "latch" || type == "barepeg") ? 0
          : PEG_FIT_DEFAULT) + clearance;
    // plate footprint spans the lattice + margin. GRID has no stagger; only the
    // staggered honeycomb extends Y by the odd-column stagger.
    spanX = straight ? (gnx-1)*(2*HSW_PITCH_X) : (gnx-1)*HSW_PITCH_X;
    spanY = (gny-1)*HSW_PITCH_Y;
    w = spanX + HSWX_OUTSIDE + 2*margin;
    d = spanY + HSWX_OUTSIDE + (straight ? 0 : hsw_max_stag(gnx)) + 2*margin;
    // crot rotates the PLUG PATTERN (plate + connectors, together so plugs stay on
    // the plate) about the wall normal so the accessory can match a wall installed
    // rotated 90deg. The body is built separately by the recipe and is NOT rotated
    // (plug layout only — body fixed).
    rotate([0, 0, crot]) {
        translate([0, 0, plate_t/2]) cube([w, d, plate_t], center = true);   // plate
        for (c = [0 : gnx-1])
            for (r = [0 : gny-1]) {
                x = straight ? hsw_cx_straight(c, gnx) : hsw_cx(c, gnx);
                y = straight ? (r*HSW_PITCH_Y - spanY/2) : hsw_cy(c, r, gnx, gny);
                translate([x, y, 0]) hsw_connector(type, pfit);
            }
    }
}

// ============================================================================
//  CONNECTOR 2 — hsw_latch_insert : snap-tab latching insert (vanilla port of
//  hex-plug-library / hsw-custom-insert, sh1-verified). Built front-face(lip) at
//  z=0 with body in +Z, then flipped to -Z and welded into the plate.
// ============================================================================
INSERT_BODY_FLATS = 19.7;   INSERT_LIP_FLATS = 22.5;   INSERT_TOTAL_H = 10;
INSERT_LIP_H = 2.5;         INSERT_SNAP_H = 6.5;       INSERT_TAB_OUT = 0.5;
INSERT_TAB_LEN = 2;         INSERT_SLOT_LEN = 8;       INSERT_SLOT_W = 0.8;
INSERT_SLOT_SIDE = 1;       INSERT_SLOT_RAD = 8.25;

module _hsw_bevel_cut(diameter) {
    h = diameter/2;                                     // tan(45)==1
    difference() { cylinder(d = diameter*2, h = h); cylinder(d1 = diameter, d2 = 0, h = h); }
}
module _hsw_insert_body(fit) {
    bodyD = hsw_af_to_d(INSERT_BODY_FLATS - 2*fit);
    lipD  = hsw_af_to_d(INSERT_LIP_FLATS);
    difference() {
        union() {
            cylinder(d = bodyD, h = INSERT_TOTAL_H, $fn = 6);   // main plug
            cylinder(d = lipD,  h = INSERT_LIP_H,  $fn = 6);    // overhang lip
        }
        translate([0,0,INSERT_TOTAL_H - 0.35]) _hsw_bevel_cut(bodyD);   // soften top edge
    }
}
module hsw_latch_insert(fit = 0) {
    translate([0,0,HSW_WELD]) rotate([180,0,0])
    union() {
        // six snap tabs (non-degenerate tip r=0.2, tops kept below the bevel)
        for (i=[0:5]) rotate([0,0,i*60]) translate([0, INSERT_BODY_FLATS/2, 0])
            hull() {
                translate([0,0,INSERT_SNAP_H + INSERT_SLOT_SIDE + INSERT_TAB_OUT])
                    rotate([0,90,0]) cylinder(r = INSERT_TAB_OUT, h = INSERT_TAB_LEN, center=true, $fn=20);
                translate([0,0,INSERT_TOTAL_H - 0.6])
                    rotate([0,90,0]) cylinder(r = 0.2, h = INSERT_TAB_LEN, center=true, $fn=20);
            }
        // body with flex slots so each tab deflects on insertion
        difference() {
            _hsw_insert_body(fit);
            for (i=[0:5]) rotate([0,0,i*60]) {
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_SLOT_W, INSERT_TOTAL_H]);
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_TOTAL_H, INSERT_SLOT_SIDE]);
            }
        }
    }
}

// ============================================================================
//  CONNECTOR 3 — hsw_clip : spring snap clip (from hsw-lib-core, sh1-verified).
//  Two cantilever arms catch the 1mm lip at 5mm depth. Mouth at z=0 into -Z.
// ============================================================================
CLIP_FIT_DEFAULT = 0.15;
CLIP_AF  = HSWX_INSIDE;      // 20 plug across-flats target
CLIP_LEN = HSWX_DEPTH;       // 8  plug length into the wall
SPRING_WALL = 1.6;           // cantilever arm wall (>=1.4 to flex)
SPRING_SLOT = 2.2;           // central relief slot width
module hsw_clip(fit = CLIP_FIT_DEFAULT) {
    af = CLIP_AF - 2*fit;  L = CLIP_LEN;
    barb = HSWX_LOCK_LIP;  locz = HSWX_LOCK_DEPTH;  cham = HSWX_LOCK_CHAMFER;  halfX = af/2;
    translate([0,0,HSW_WELD])
    difference() {
        union() {
            translate([0,0,-L/2]) linear_extrude(height = L, center = true) hsw_hex2d(af);   // hex plug
            for (sx=[-1,1]) translate([sx*halfX,0,-locz]) rotate([90,0,0])                    // outward barbs
                linear_extrude(height = af*0.62, center = true)
                    polygon([[0,0],[sx*barb,0],[sx*barb,cham],[0,cham+barb]]);
            translate([0,0,0.6/2]) linear_extrude(height = 0.6, center = true) hsw_hex2d(af + 1.2);  // mouth flange
        }
        translate([0,0,-L/2-0.5]) cube([SPRING_SLOT, af+4, L+2-1.2], center = true);          // central relief slot
        for (sx=[-1,1]) translate([sx*(halfX-SPRING_WALL-0.3),0,-L/2-1]) cube([1.4, af*0.5, L], center=true);  // arm hollow
    }
}

// per-cell connector dispatch:
//   peg     = friction peg, jams the bare grid hole (one-part)
//   barepeg = thin core peg, plugs into a SEPARATE latch pre-snapped in the wall
//   latch   = snap-tab insert, snaps into the bare grid hole
//   clip    = spring clip, snaps into the bare grid hole
module hsw_connector(type = "peg", fit = PEG_FIT_DEFAULT) {
    if      (type == "latch")   hsw_latch_insert(fit);
    else if (type == "clip")    hsw_clip(fit);
    else if (type == "barepeg") hsw_bare_peg(fit);
    else                        hsw_peg(fit);
}

// ============================================================================
//  hsw_grid(nx, ny, depth) — the FEMALE wall panel. Holes placed by the SAME
//  hsw_cx/hsw_cy so a hsw_mount(nx,ny) co-registers EXACTLY (proof artifact).
//  Lipped hex socket: 20mm bore, 1mm catch lip at 5mm depth.
// ============================================================================
module hsw_hex2d(af) { rotate([0,0,90]) circle(r = af/sqrt(3), $fn = 6); }

module hsw_hex_hole(depth) {
    afMouth = HSWX_INSIDE + 2*HSWX_LOCK_CHAMFER;
    afFull  = HSWX_INSIDE;
    afLip   = HSWX_INSIDE - 2*HSWX_LOCK_LIP;
    translate([0,0,-HSWX_LOCK_CHAMFER/2 + 0.01])
        linear_extrude(HSWX_LOCK_CHAMFER + 0.02, center=true, scale = afFull/afMouth) hsw_hex2d(afMouth);
    translate([0,0,-HSWX_LOCK_DEPTH/2])
        linear_extrude(HSWX_LOCK_DEPTH + 0.02, center=true) hsw_hex2d(afFull);
    translate([0,0,-HSWX_LOCK_DEPTH])
        linear_extrude(0.6, center=true) hsw_hex2d(afLip);
    backLen = depth - HSWX_LOCK_DEPTH;
    if (backLen > 0.1)
        translate([0,0,-(HSWX_LOCK_DEPTH + backLen/2)])
            linear_extrude(backLen + 0.4, center=true) hsw_hex2d(afFull);
}

module hsw_grid(nx = 3, ny = 3, depth = HSWX_DEPTH) {
    spanX = (nx-1)*HSW_PITCH_X;
    spanY = (ny-1)*HSW_PITCH_Y;
    slabW = spanX + HSWX_OUTSIDE;
    slabD = spanY + HSWX_OUTSIDE + hsw_max_stag(nx);
    difference() {
        translate([0, -hsw_max_stag(nx)/2, -depth/2]) cube([slabW, slabD, depth], center = true);
        for (c = [0 : nx-1])
            for (r = [0 : ny-1])
                translate([hsw_cx(c, nx), hsw_cy(c, r, nx, ny), 0]) hsw_hex_hole(depth);
    }
}

// ============================================================================
//  hsw_display() — canonical AnimBox display orientation. The geometry is built
//  in the OpenSCAD print frame (scad +Z = wall normal, +Y = up the wall). The
//  The OpenSCAD->AnimBox import is IDENTITY (verified by bbox: cube([10,20,40])
//  imports to world [10,20,40]). The wall-frame is already the display frame:
//  up-the-wall (+Y) = world UP, along-the-wall (+X) = world X, wall normal (+Z)
//  = toward the viewer (the body projects out of the wall). So hsw_display() is a
//  pass-through; it stays as the single place to adjust display orientation if the
//  import convention ever changes. Wrap every recipe's top call: hsw_display() my_part();
// ============================================================================
module hsw_display() { children(); }

// ---- product body (hidden internals) ----
eps   = 0.05;
PLATE = PLATE_T_DEFAULT;

module deep_bin() {
    ow = bin_width + 2 * wall;
    od = bin_depth + 2 * wall;
    oh = bin_height + floor_t;
    z0 = PLATE - HSW_WELD;
    y0 = -oh / 2;                       // centre vertically so the back wall covers the plate
    difference() {
        translate([-ow / 2, y0, z0]) cube([ow, oh, od + HSW_WELD]);
        translate([-bin_width / 2, y0 + floor_t, PLATE + wall])
            cube([bin_width, bin_height + eps, bin_depth + eps]);   // cavity, open top
    }
}
module deep_parts_bin() {
    hsw_mount(connectors_x, connectors_y, type = connector_type, clearance = clearance,
              straight = (support_style == "grid"), crot = connector_rotation);
    deep_bin();
}
hsw_display() deep_parts_bin();
`);

Open in editor →

HSW J-Hook

A strong J-hook for hanging cables, bags, headphones, or tools — the arm reaches out and curves up into a cradle so things stay put. Swappable wall plugs.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// HSW J-Hook
//
// Source: honeycomb-wall J-hook
// Generated from the library above, used under its license.

/* [Wall mount] */
// How it attaches to the wall
connector_type = "peg";       // [peg:Friction peg (into wall), barepeg:Bare peg (into a latch), latch:Latch insert (into wall), clip:Spring clip (into wall)]
// Plug support style
support_style = "grid";       // [grid:Grid (aligned rows + columns), honeycomb:Honeycomb (staggered, denser)]
// Rotate the plug pattern (to match a wall mounted sideways)
connector_rotation = 0;       // [0:0 degrees, 90:90 degrees]
// Hex connectors across
connectors_x = 1;             // [1:8]
// Hex connector rows (2 = strong cantilever)
connectors_y = 2;             // [1:4]
// Fit tweak: + looser / - tighter
clearance = 0;                // [-0.3:0.05:0.5]

/* [Hook] */
// Hook rod radius (mm)
rod_r = 5;                    // [2.5:0.5:10]
// How far the hook reaches out (mm)
reach = 34;                   // [15:80]
// Upturned tip height (mm)
rise = 18;                    // [6:40]
// Cradle droop (mm)
droop = 7;                    // [0:20]
// Height up the wall (mm)
hook_y = 0;                   // [-25:30]

// ============================================================================
//  HSW CONNECTOR TEMPLATE — the single canonical, self-contained connector kit
//  every HSW example inlines VERBATIM so plug spacing + sizing stay identical.
//  OpenSCAD 2021.01-safe. Self-contained: no include/use, no external libraries.
//
//  THE ONE RULE: plugs (hsw_mount) and wall holes (hsw_grid) are placed by the
//  SAME lattice functions hsw_cx()/hsw_cy(), so plug(c,r) == hole(c,r) for ANY
//  count by construction — verified 0.0000 mm deviation for 1..5 in each axis.
//
//  Frame: +Z = wall-normal (out of the wall). Connectors point into -Z (into the
//  wall); the back-plate front face sits at +Z = plate_t; accessory bodies build
//  on the +Z face. UP the wall = +Y, X = horizontal.
//
//  CUSTOMIZER: everything below is in the Hidden group so a product recipe that
//  inlines this template exposes ONLY its own dimensions + connectors_x/y +
//  connector_type + one clearance tweak. The HSW internals are NEVER customer-tunable.
// ============================================================================
/* [Hidden] */
$fn = 48;

// ---- Core hex interface (the 20mm hole a connector plugs into) -------------
HSWX_INSIDE       = 20;                              // hex hole flat-to-flat
HSWX_WALL         = 1.8;                             // shared cell wall thickness
HSWX_OUTSIDE      = HSWX_INSIDE + HSWX_WALL*2;       // 23.6  outside flat-to-flat
HSWX_SIDE         = HSWX_OUTSIDE / sqrt(3);          // ~13.6255 outer side length
HSWX_DEPTH        = 8;                               // panel / plug depth (Std Duty)
HSWX_LOCK_DEPTH   = 5;                               // depth where the lock step starts
HSWX_LOCK_LIP     = 1;                               // 1mm internal lip the barb catches
HSWX_LOCK_CHAMFER = HSWX_LOCK_LIP;                   // 1mm @ 45deg lead-in

// ---- Verified honeycomb lattice (flat-topped hexes, column tiling) ---------
HSW_PITCH_X       = 1.5 * HSWX_SIDE;                 // ~20.4382 column-to-column
HSW_PITCH_Y       = HSWX_OUTSIDE;                    // 23.6    row-to-row in a column
HSW_STAGGER_Y     = HSWX_OUTSIDE / 2;               // 11.8    alternate-column offset

// ---- Shared connector tunables ---------------------------------------------
PEG_FIT_DEFAULT   = 0.35;                            // bare-peg friction clearance
PEG_LEN_DEFAULT   = 7;                               // bare-peg depth into wall (< HSWX_DEPTH)
PLATE_T_DEFAULT   = 3;                               // back-plate thickness (welds depend on it)
HSW_WELD          = 0.6;                              // connector overlap INTO the plate (one fused solid)

// Across-flats -> circumscribed diameter (a $fn=6 cylinder lands on those flats).
// af/sqrt(3)*2 is IDENTICAL to af/cos(30); ONE form library-wide.
function hsw_af_to_d(af) = af / sqrt(3) * 2;

// ============================================================================
//  THE LATTICE — the single source of truth for WHERE connectors/holes go.
//  Bounding-box-centred on the origin for ANY nx/ny (incl. the single-column
//  case): the staggered odd columns only exist when nx>1, so the y-centring of
//  the cluster is conditional on nx>1. hsw_mount AND hsw_grid both call these.
// ============================================================================
function hsw_max_stag(nx) = (nx > 1) ? HSW_STAGGER_Y : 0;     // odd col only exists if nx>1
function hsw_cx(c, nx)    = c*HSW_PITCH_X - (nx-1)*HSW_PITCH_X/2;
function hsw_cy(c, r, nx, ny) =
    r*HSW_PITCH_Y
    - (ny-1)*HSW_PITCH_Y/2
    + ((c % 2 == 1) ? HSW_STAGGER_Y : 0)            // real alternate-column stagger
    - hsw_max_stag(nx)/2;                            // centre the cluster (cond. on nx>1)

// straight=true strip: every-OTHER column, no stagger (the legacy 40.88 strip).
// Use 2*HSW_PITCH_X (=40.8764), NEVER the rounded 40.88 literal.
function hsw_cx_straight(c, nx) = c*(2*HSW_PITCH_X) - (nx-1)*(2*HSW_PITCH_X)/2;

// ============================================================================
//  CONNECTOR 1 — hsw_peg : bare friction press-peg (the de-facto canonical peg).
//  $fn=6 hex prism, across-flats = HSWX_INSIDE - 2*fit, into -Z. Press fit only.
// ============================================================================
module hsw_peg(fit = PEG_FIT_DEFAULT, len = PEG_LEN_DEFAULT) {
    af = HSWX_INSIDE - 2*fit;                        // flat-to-flat, slightly under 20
    // hex prism from z=+HSW_WELD (buried INTO the plate) down to z=-len (into wall),
    // so the peg fuses with any plate occupying z>=0 into ONE solid (no coincident-face seam).
    translate([0, 0, -len])
        cylinder(h = len + HSW_WELD, d = hsw_af_to_d(af), $fn = 6);
}

// ============================================================================
//  CONNECTOR 1b — hsw_bare_peg : the THIN CORE peg (hex-plug-library hexagon_plug)
//  that plugs into a SEPARATE latch insert pre-snapped in the wall — NOT the grid
//  directly. Verbatim dims: 14.7 across-corners, 13 deep. Into -Z, welds the plate.
// ============================================================================
BAREPEG_D   = 14.7;     // across-corners ($fn=6) — source PLUG_HEXAGON_DIAMETER
BAREPEG_LEN = 13;       // source PLUG_LENGTH
module hsw_bare_peg(fit = 0) {
    translate([0, 0, -BAREPEG_LEN])
        cylinder(h = BAREPEG_LEN + HSW_WELD, d = BAREPEG_D - 2*fit, $fn = 6);
}

// ============================================================================
//  hsw_mount(nx, ny, type, plate_t, fit, straight)
//  ONE back-plate (front face +Z = plate_t) carrying an nx*ny connector lattice
//  on -Z, placed by hsw_cx/hsw_cy. type dispatches the per-cell connector.
// ============================================================================
// straight=true  -> GRID support  : pegs on an aligned rectangular grid
//                                    (40.8764 horiz x 23.6 vert, every-other
//                                    honeycomb column -> all land in real holes).
// straight=false -> HONEYCOMB support: pegs follow the staggered hex lattice
//                                    (20.4382 column pitch, odd columns staggered).
module hsw_mount(nx = 1, ny = 1, type = "peg", plate_t = PLATE_T_DEFAULT,
                 clearance = 0, straight = false, margin = 3, crot = 0) {
    // clamp counts so a user 0 (or negative) never yields an empty / garbage mount
    gnx = max(1, nx);
    gny = max(1, ny);
    // per-type base fit (peg=press 0.35, clip=snap 0.15, latch/barepeg=0 lip-tuned)
    // + the product's single user clearance tweak (+ looser / - tighter).
    pfit = (type == "clip" ? CLIP_FIT_DEFAULT
          : (type == "latch" || type == "barepeg") ? 0
          : PEG_FIT_DEFAULT) + clearance;
    // plate footprint spans the lattice + margin. GRID has no stagger; only the
    // staggered honeycomb extends Y by the odd-column stagger.
    spanX = straight ? (gnx-1)*(2*HSW_PITCH_X) : (gnx-1)*HSW_PITCH_X;
    spanY = (gny-1)*HSW_PITCH_Y;
    w = spanX + HSWX_OUTSIDE + 2*margin;
    d = spanY + HSWX_OUTSIDE + (straight ? 0 : hsw_max_stag(gnx)) + 2*margin;
    // crot rotates the PLUG PATTERN (plate + connectors, together so plugs stay on
    // the plate) about the wall normal so the accessory can match a wall installed
    // rotated 90deg. The body is built separately by the recipe and is NOT rotated
    // (plug layout only — body fixed).
    rotate([0, 0, crot]) {
        translate([0, 0, plate_t/2]) cube([w, d, plate_t], center = true);   // plate
        for (c = [0 : gnx-1])
            for (r = [0 : gny-1]) {
                x = straight ? hsw_cx_straight(c, gnx) : hsw_cx(c, gnx);
                y = straight ? (r*HSW_PITCH_Y - spanY/2) : hsw_cy(c, r, gnx, gny);
                translate([x, y, 0]) hsw_connector(type, pfit);
            }
    }
}

// ============================================================================
//  CONNECTOR 2 — hsw_latch_insert : snap-tab latching insert (vanilla port of
//  hex-plug-library / hsw-custom-insert, sh1-verified). Built front-face(lip) at
//  z=0 with body in +Z, then flipped to -Z and welded into the plate.
// ============================================================================
INSERT_BODY_FLATS = 19.7;   INSERT_LIP_FLATS = 22.5;   INSERT_TOTAL_H = 10;
INSERT_LIP_H = 2.5;         INSERT_SNAP_H = 6.5;       INSERT_TAB_OUT = 0.5;
INSERT_TAB_LEN = 2;         INSERT_SLOT_LEN = 8;       INSERT_SLOT_W = 0.8;
INSERT_SLOT_SIDE = 1;       INSERT_SLOT_RAD = 8.25;

module _hsw_bevel_cut(diameter) {
    h = diameter/2;                                     // tan(45)==1
    difference() { cylinder(d = diameter*2, h = h); cylinder(d1 = diameter, d2 = 0, h = h); }
}
module _hsw_insert_body(fit) {
    bodyD = hsw_af_to_d(INSERT_BODY_FLATS - 2*fit);
    lipD  = hsw_af_to_d(INSERT_LIP_FLATS);
    difference() {
        union() {
            cylinder(d = bodyD, h = INSERT_TOTAL_H, $fn = 6);   // main plug
            cylinder(d = lipD,  h = INSERT_LIP_H,  $fn = 6);    // overhang lip
        }
        translate([0,0,INSERT_TOTAL_H - 0.35]) _hsw_bevel_cut(bodyD);   // soften top edge
    }
}
module hsw_latch_insert(fit = 0) {
    translate([0,0,HSW_WELD]) rotate([180,0,0])
    union() {
        // six snap tabs (non-degenerate tip r=0.2, tops kept below the bevel)
        for (i=[0:5]) rotate([0,0,i*60]) translate([0, INSERT_BODY_FLATS/2, 0])
            hull() {
                translate([0,0,INSERT_SNAP_H + INSERT_SLOT_SIDE + INSERT_TAB_OUT])
                    rotate([0,90,0]) cylinder(r = INSERT_TAB_OUT, h = INSERT_TAB_LEN, center=true, $fn=20);
                translate([0,0,INSERT_TOTAL_H - 0.6])
                    rotate([0,90,0]) cylinder(r = 0.2, h = INSERT_TAB_LEN, center=true, $fn=20);
            }
        // body with flex slots so each tab deflects on insertion
        difference() {
            _hsw_insert_body(fit);
            for (i=[0:5]) rotate([0,0,i*60]) {
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_SLOT_W, INSERT_TOTAL_H]);
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_TOTAL_H, INSERT_SLOT_SIDE]);
            }
        }
    }
}

// ============================================================================
//  CONNECTOR 3 — hsw_clip : spring snap clip (from hsw-lib-core, sh1-verified).
//  Two cantilever arms catch the 1mm lip at 5mm depth. Mouth at z=0 into -Z.
// ============================================================================
CLIP_FIT_DEFAULT = 0.15;
CLIP_AF  = HSWX_INSIDE;      // 20 plug across-flats target
CLIP_LEN = HSWX_DEPTH;       // 8  plug length into the wall
SPRING_WALL = 1.6;           // cantilever arm wall (>=1.4 to flex)
SPRING_SLOT = 2.2;           // central relief slot width
module hsw_clip(fit = CLIP_FIT_DEFAULT) {
    af = CLIP_AF - 2*fit;  L = CLIP_LEN;
    barb = HSWX_LOCK_LIP;  locz = HSWX_LOCK_DEPTH;  cham = HSWX_LOCK_CHAMFER;  halfX = af/2;
    translate([0,0,HSW_WELD])
    difference() {
        union() {
            translate([0,0,-L/2]) linear_extrude(height = L, center = true) hsw_hex2d(af);   // hex plug
            for (sx=[-1,1]) translate([sx*halfX,0,-locz]) rotate([90,0,0])                    // outward barbs
                linear_extrude(height = af*0.62, center = true)
                    polygon([[0,0],[sx*barb,0],[sx*barb,cham],[0,cham+barb]]);
            translate([0,0,0.6/2]) linear_extrude(height = 0.6, center = true) hsw_hex2d(af + 1.2);  // mouth flange
        }
        translate([0,0,-L/2-0.5]) cube([SPRING_SLOT, af+4, L+2-1.2], center = true);          // central relief slot
        for (sx=[-1,1]) translate([sx*(halfX-SPRING_WALL-0.3),0,-L/2-1]) cube([1.4, af*0.5, L], center=true);  // arm hollow
    }
}

// per-cell connector dispatch:
//   peg     = friction peg, jams the bare grid hole (one-part)
//   barepeg = thin core peg, plugs into a SEPARATE latch pre-snapped in the wall
//   latch   = snap-tab insert, snaps into the bare grid hole
//   clip    = spring clip, snaps into the bare grid hole
module hsw_connector(type = "peg", fit = PEG_FIT_DEFAULT) {
    if      (type == "latch")   hsw_latch_insert(fit);
    else if (type == "clip")    hsw_clip(fit);
    else if (type == "barepeg") hsw_bare_peg(fit);
    else                        hsw_peg(fit);
}

// ============================================================================
//  hsw_grid(nx, ny, depth) — the FEMALE wall panel. Holes placed by the SAME
//  hsw_cx/hsw_cy so a hsw_mount(nx,ny) co-registers EXACTLY (proof artifact).
//  Lipped hex socket: 20mm bore, 1mm catch lip at 5mm depth.
// ============================================================================
module hsw_hex2d(af) { rotate([0,0,90]) circle(r = af/sqrt(3), $fn = 6); }

module hsw_hex_hole(depth) {
    afMouth = HSWX_INSIDE + 2*HSWX_LOCK_CHAMFER;
    afFull  = HSWX_INSIDE;
    afLip   = HSWX_INSIDE - 2*HSWX_LOCK_LIP;
    translate([0,0,-HSWX_LOCK_CHAMFER/2 + 0.01])
        linear_extrude(HSWX_LOCK_CHAMFER + 0.02, center=true, scale = afFull/afMouth) hsw_hex2d(afMouth);
    translate([0,0,-HSWX_LOCK_DEPTH/2])
        linear_extrude(HSWX_LOCK_DEPTH + 0.02, center=true) hsw_hex2d(afFull);
    translate([0,0,-HSWX_LOCK_DEPTH])
        linear_extrude(0.6, center=true) hsw_hex2d(afLip);
    backLen = depth - HSWX_LOCK_DEPTH;
    if (backLen > 0.1)
        translate([0,0,-(HSWX_LOCK_DEPTH + backLen/2)])
            linear_extrude(backLen + 0.4, center=true) hsw_hex2d(afFull);
}

module hsw_grid(nx = 3, ny = 3, depth = HSWX_DEPTH) {
    spanX = (nx-1)*HSW_PITCH_X;
    spanY = (ny-1)*HSW_PITCH_Y;
    slabW = spanX + HSWX_OUTSIDE;
    slabD = spanY + HSWX_OUTSIDE + hsw_max_stag(nx);
    difference() {
        translate([0, -hsw_max_stag(nx)/2, -depth/2]) cube([slabW, slabD, depth], center = true);
        for (c = [0 : nx-1])
            for (r = [0 : ny-1])
                translate([hsw_cx(c, nx), hsw_cy(c, r, nx, ny), 0]) hsw_hex_hole(depth);
    }
}

// ============================================================================
//  hsw_display() — canonical AnimBox display orientation. The geometry is built
//  in the OpenSCAD print frame (scad +Z = wall normal, +Y = up the wall). The
//  The OpenSCAD->AnimBox import is IDENTITY (verified by bbox: cube([10,20,40])
//  imports to world [10,20,40]). The wall-frame is already the display frame:
//  up-the-wall (+Y) = world UP, along-the-wall (+X) = world X, wall normal (+Z)
//  = toward the viewer (the body projects out of the wall). So hsw_display() is a
//  pass-through; it stays as the single place to adjust display orientation if the
//  import convention ever changes. Wrap every recipe's top call: hsw_display() my_part();
// ============================================================================
module hsw_display() { children(); }

// ---- product body (hidden internals) ----
PLATE = PLATE_T_DEFAULT;

module hook_path() {
    // J path in the X=0 plane: out along +Z, droop, then curve up +Y into a cradle.
    pts = [
        [0, hook_y,             PLATE - HSW_WELD],   // embedded in the plate (welds)
        [0, hook_y,             PLATE + 3],
        [0, hook_y - droop * 0.5, PLATE + reach * 0.45],
        [0, hook_y - droop,     PLATE + reach * 0.80],
        [0, hook_y - droop * 0.4, PLATE + reach],
        [0, hook_y + rise * 0.5, PLATE + reach - 1],
        [0, hook_y + rise,      PLATE + reach - 5]    // upturned tip
    ];
    for (i = [0 : len(pts) - 2])
        hull() {
            translate(pts[i])     sphere(r = rod_r, $fn = 28);
            translate(pts[i + 1]) sphere(r = rod_r, $fn = 28);
        }
}
module j_hook() {
    hsw_mount(connectors_x, connectors_y, type = connector_type, clearance = clearance,
              straight = (support_style == "grid"), crot = connector_rotation);
    hook_path();
}
hsw_display() j_hook();
`);

Open in editor →

HSW U-Saddle Holder

A saddle block with a rounded groove that cradles round handles, cans, spray bottles, or power-tool bodies. Swappable wall plugs.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// HSW U-Saddle Holder
//
// Source: honeycomb-wall U saddle holder
// Generated from the library above, used under its license.

/* [Wall mount] */
// How it attaches to the wall
connector_type = "peg";       // [peg:Friction peg (into wall), barepeg:Bare peg (into a latch), latch:Latch insert (into wall), clip:Spring clip (into wall)]
// Plug support style
support_style = "grid";       // [grid:Grid (aligned rows + columns), honeycomb:Honeycomb (staggered, denser)]
// Rotate the plug pattern (to match a wall mounted sideways)
connector_rotation = 0;       // [0:0 degrees, 90:90 degrees]
// Hex connectors across
connectors_x = 2;             // [1:8]
// Hex connector rows (2 = strong cantilever)
connectors_y = 2;             // [1:4]
// Fit tweak: + looser / - tighter
clearance = 0;                // [-0.3:0.05:0.5]

/* [Saddle] */
// Cradle diameter — fits the item (mm)
cradle_d = 32;                // [12:90]
// How far the saddle reaches out (mm)
reach = 38;                   // [18:90]
// Wall thickness around the groove (mm)
wall = 4;                     // [2:0.5:8]
// Front drop — how far the front lip rises to retain the item (mm)
front_lip = 10;              // [0:30]

// ============================================================================
//  HSW CONNECTOR TEMPLATE — the single canonical, self-contained connector kit
//  every HSW example inlines VERBATIM so plug spacing + sizing stay identical.
//  OpenSCAD 2021.01-safe. Self-contained: no include/use, no external libraries.
//
//  THE ONE RULE: plugs (hsw_mount) and wall holes (hsw_grid) are placed by the
//  SAME lattice functions hsw_cx()/hsw_cy(), so plug(c,r) == hole(c,r) for ANY
//  count by construction — verified 0.0000 mm deviation for 1..5 in each axis.
//
//  Frame: +Z = wall-normal (out of the wall). Connectors point into -Z (into the
//  wall); the back-plate front face sits at +Z = plate_t; accessory bodies build
//  on the +Z face. UP the wall = +Y, X = horizontal.
//
//  CUSTOMIZER: everything below is in the Hidden group so a product recipe that
//  inlines this template exposes ONLY its own dimensions + connectors_x/y +
//  connector_type + one clearance tweak. The HSW internals are NEVER customer-tunable.
// ============================================================================
/* [Hidden] */
$fn = 48;

// ---- Core hex interface (the 20mm hole a connector plugs into) -------------
HSWX_INSIDE       = 20;                              // hex hole flat-to-flat
HSWX_WALL         = 1.8;                             // shared cell wall thickness
HSWX_OUTSIDE      = HSWX_INSIDE + HSWX_WALL*2;       // 23.6  outside flat-to-flat
HSWX_SIDE         = HSWX_OUTSIDE / sqrt(3);          // ~13.6255 outer side length
HSWX_DEPTH        = 8;                               // panel / plug depth (Std Duty)
HSWX_LOCK_DEPTH   = 5;                               // depth where the lock step starts
HSWX_LOCK_LIP     = 1;                               // 1mm internal lip the barb catches
HSWX_LOCK_CHAMFER = HSWX_LOCK_LIP;                   // 1mm @ 45deg lead-in

// ---- Verified honeycomb lattice (flat-topped hexes, column tiling) ---------
HSW_PITCH_X       = 1.5 * HSWX_SIDE;                 // ~20.4382 column-to-column
HSW_PITCH_Y       = HSWX_OUTSIDE;                    // 23.6    row-to-row in a column
HSW_STAGGER_Y     = HSWX_OUTSIDE / 2;               // 11.8    alternate-column offset

// ---- Shared connector tunables ---------------------------------------------
PEG_FIT_DEFAULT   = 0.35;                            // bare-peg friction clearance
PEG_LEN_DEFAULT   = 7;                               // bare-peg depth into wall (< HSWX_DEPTH)
PLATE_T_DEFAULT   = 3;                               // back-plate thickness (welds depend on it)
HSW_WELD          = 0.6;                              // connector overlap INTO the plate (one fused solid)

// Across-flats -> circumscribed diameter (a $fn=6 cylinder lands on those flats).
// af/sqrt(3)*2 is IDENTICAL to af/cos(30); ONE form library-wide.
function hsw_af_to_d(af) = af / sqrt(3) * 2;

// ============================================================================
//  THE LATTICE — the single source of truth for WHERE connectors/holes go.
//  Bounding-box-centred on the origin for ANY nx/ny (incl. the single-column
//  case): the staggered odd columns only exist when nx>1, so the y-centring of
//  the cluster is conditional on nx>1. hsw_mount AND hsw_grid both call these.
// ============================================================================
function hsw_max_stag(nx) = (nx > 1) ? HSW_STAGGER_Y : 0;     // odd col only exists if nx>1
function hsw_cx(c, nx)    = c*HSW_PITCH_X - (nx-1)*HSW_PITCH_X/2;
function hsw_cy(c, r, nx, ny) =
    r*HSW_PITCH_Y
    - (ny-1)*HSW_PITCH_Y/2
    + ((c % 2 == 1) ? HSW_STAGGER_Y : 0)            // real alternate-column stagger
    - hsw_max_stag(nx)/2;                            // centre the cluster (cond. on nx>1)

// straight=true strip: every-OTHER column, no stagger (the legacy 40.88 strip).
// Use 2*HSW_PITCH_X (=40.8764), NEVER the rounded 40.88 literal.
function hsw_cx_straight(c, nx) = c*(2*HSW_PITCH_X) - (nx-1)*(2*HSW_PITCH_X)/2;

// ============================================================================
//  CONNECTOR 1 — hsw_peg : bare friction press-peg (the de-facto canonical peg).
//  $fn=6 hex prism, across-flats = HSWX_INSIDE - 2*fit, into -Z. Press fit only.
// ============================================================================
module hsw_peg(fit = PEG_FIT_DEFAULT, len = PEG_LEN_DEFAULT) {
    af = HSWX_INSIDE - 2*fit;                        // flat-to-flat, slightly under 20
    // hex prism from z=+HSW_WELD (buried INTO the plate) down to z=-len (into wall),
    // so the peg fuses with any plate occupying z>=0 into ONE solid (no coincident-face seam).
    translate([0, 0, -len])
        cylinder(h = len + HSW_WELD, d = hsw_af_to_d(af), $fn = 6);
}

// ============================================================================
//  CONNECTOR 1b — hsw_bare_peg : the THIN CORE peg (hex-plug-library hexagon_plug)
//  that plugs into a SEPARATE latch insert pre-snapped in the wall — NOT the grid
//  directly. Verbatim dims: 14.7 across-corners, 13 deep. Into -Z, welds the plate.
// ============================================================================
BAREPEG_D   = 14.7;     // across-corners ($fn=6) — source PLUG_HEXAGON_DIAMETER
BAREPEG_LEN = 13;       // source PLUG_LENGTH
module hsw_bare_peg(fit = 0) {
    translate([0, 0, -BAREPEG_LEN])
        cylinder(h = BAREPEG_LEN + HSW_WELD, d = BAREPEG_D - 2*fit, $fn = 6);
}

// ============================================================================
//  hsw_mount(nx, ny, type, plate_t, fit, straight)
//  ONE back-plate (front face +Z = plate_t) carrying an nx*ny connector lattice
//  on -Z, placed by hsw_cx/hsw_cy. type dispatches the per-cell connector.
// ============================================================================
// straight=true  -> GRID support  : pegs on an aligned rectangular grid
//                                    (40.8764 horiz x 23.6 vert, every-other
//                                    honeycomb column -> all land in real holes).
// straight=false -> HONEYCOMB support: pegs follow the staggered hex lattice
//                                    (20.4382 column pitch, odd columns staggered).
module hsw_mount(nx = 1, ny = 1, type = "peg", plate_t = PLATE_T_DEFAULT,
                 clearance = 0, straight = false, margin = 3, crot = 0) {
    // clamp counts so a user 0 (or negative) never yields an empty / garbage mount
    gnx = max(1, nx);
    gny = max(1, ny);
    // per-type base fit (peg=press 0.35, clip=snap 0.15, latch/barepeg=0 lip-tuned)
    // + the product's single user clearance tweak (+ looser / - tighter).
    pfit = (type == "clip" ? CLIP_FIT_DEFAULT
          : (type == "latch" || type == "barepeg") ? 0
          : PEG_FIT_DEFAULT) + clearance;
    // plate footprint spans the lattice + margin. GRID has no stagger; only the
    // staggered honeycomb extends Y by the odd-column stagger.
    spanX = straight ? (gnx-1)*(2*HSW_PITCH_X) : (gnx-1)*HSW_PITCH_X;
    spanY = (gny-1)*HSW_PITCH_Y;
    w = spanX + HSWX_OUTSIDE + 2*margin;
    d = spanY + HSWX_OUTSIDE + (straight ? 0 : hsw_max_stag(gnx)) + 2*margin;
    // crot rotates the PLUG PATTERN (plate + connectors, together so plugs stay on
    // the plate) about the wall normal so the accessory can match a wall installed
    // rotated 90deg. The body is built separately by the recipe and is NOT rotated
    // (plug layout only — body fixed).
    rotate([0, 0, crot]) {
        translate([0, 0, plate_t/2]) cube([w, d, plate_t], center = true);   // plate
        for (c = [0 : gnx-1])
            for (r = [0 : gny-1]) {
                x = straight ? hsw_cx_straight(c, gnx) : hsw_cx(c, gnx);
                y = straight ? (r*HSW_PITCH_Y - spanY/2) : hsw_cy(c, r, gnx, gny);
                translate([x, y, 0]) hsw_connector(type, pfit);
            }
    }
}

// ============================================================================
//  CONNECTOR 2 — hsw_latch_insert : snap-tab latching insert (vanilla port of
//  hex-plug-library / hsw-custom-insert, sh1-verified). Built front-face(lip) at
//  z=0 with body in +Z, then flipped to -Z and welded into the plate.
// ============================================================================
INSERT_BODY_FLATS = 19.7;   INSERT_LIP_FLATS = 22.5;   INSERT_TOTAL_H = 10;
INSERT_LIP_H = 2.5;         INSERT_SNAP_H = 6.5;       INSERT_TAB_OUT = 0.5;
INSERT_TAB_LEN = 2;         INSERT_SLOT_LEN = 8;       INSERT_SLOT_W = 0.8;
INSERT_SLOT_SIDE = 1;       INSERT_SLOT_RAD = 8.25;

module _hsw_bevel_cut(diameter) {
    h = diameter/2;                                     // tan(45)==1
    difference() { cylinder(d = diameter*2, h = h); cylinder(d1 = diameter, d2 = 0, h = h); }
}
module _hsw_insert_body(fit) {
    bodyD = hsw_af_to_d(INSERT_BODY_FLATS - 2*fit);
    lipD  = hsw_af_to_d(INSERT_LIP_FLATS);
    difference() {
        union() {
            cylinder(d = bodyD, h = INSERT_TOTAL_H, $fn = 6);   // main plug
            cylinder(d = lipD,  h = INSERT_LIP_H,  $fn = 6);    // overhang lip
        }
        translate([0,0,INSERT_TOTAL_H - 0.35]) _hsw_bevel_cut(bodyD);   // soften top edge
    }
}
module hsw_latch_insert(fit = 0) {
    translate([0,0,HSW_WELD]) rotate([180,0,0])
    union() {
        // six snap tabs (non-degenerate tip r=0.2, tops kept below the bevel)
        for (i=[0:5]) rotate([0,0,i*60]) translate([0, INSERT_BODY_FLATS/2, 0])
            hull() {
                translate([0,0,INSERT_SNAP_H + INSERT_SLOT_SIDE + INSERT_TAB_OUT])
                    rotate([0,90,0]) cylinder(r = INSERT_TAB_OUT, h = INSERT_TAB_LEN, center=true, $fn=20);
                translate([0,0,INSERT_TOTAL_H - 0.6])
                    rotate([0,90,0]) cylinder(r = 0.2, h = INSERT_TAB_LEN, center=true, $fn=20);
            }
        // body with flex slots so each tab deflects on insertion
        difference() {
            _hsw_insert_body(fit);
            for (i=[0:5]) rotate([0,0,i*60]) {
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_SLOT_W, INSERT_TOTAL_H]);
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_TOTAL_H, INSERT_SLOT_SIDE]);
            }
        }
    }
}

// ============================================================================
//  CONNECTOR 3 — hsw_clip : spring snap clip (from hsw-lib-core, sh1-verified).
//  Two cantilever arms catch the 1mm lip at 5mm depth. Mouth at z=0 into -Z.
// ============================================================================
CLIP_FIT_DEFAULT = 0.15;
CLIP_AF  = HSWX_INSIDE;      // 20 plug across-flats target
CLIP_LEN = HSWX_DEPTH;       // 8  plug length into the wall
SPRING_WALL = 1.6;           // cantilever arm wall (>=1.4 to flex)
SPRING_SLOT = 2.2;           // central relief slot width
module hsw_clip(fit = CLIP_FIT_DEFAULT) {
    af = CLIP_AF - 2*fit;  L = CLIP_LEN;
    barb = HSWX_LOCK_LIP;  locz = HSWX_LOCK_DEPTH;  cham = HSWX_LOCK_CHAMFER;  halfX = af/2;
    translate([0,0,HSW_WELD])
    difference() {
        union() {
            translate([0,0,-L/2]) linear_extrude(height = L, center = true) hsw_hex2d(af);   // hex plug
            for (sx=[-1,1]) translate([sx*halfX,0,-locz]) rotate([90,0,0])                    // outward barbs
                linear_extrude(height = af*0.62, center = true)
                    polygon([[0,0],[sx*barb,0],[sx*barb,cham],[0,cham+barb]]);
            translate([0,0,0.6/2]) linear_extrude(height = 0.6, center = true) hsw_hex2d(af + 1.2);  // mouth flange
        }
        translate([0,0,-L/2-0.5]) cube([SPRING_SLOT, af+4, L+2-1.2], center = true);          // central relief slot
        for (sx=[-1,1]) translate([sx*(halfX-SPRING_WALL-0.3),0,-L/2-1]) cube([1.4, af*0.5, L], center=true);  // arm hollow
    }
}

// per-cell connector dispatch:
//   peg     = friction peg, jams the bare grid hole (one-part)
//   barepeg = thin core peg, plugs into a SEPARATE latch pre-snapped in the wall
//   latch   = snap-tab insert, snaps into the bare grid hole
//   clip    = spring clip, snaps into the bare grid hole
module hsw_connector(type = "peg", fit = PEG_FIT_DEFAULT) {
    if      (type == "latch")   hsw_latch_insert(fit);
    else if (type == "clip")    hsw_clip(fit);
    else if (type == "barepeg") hsw_bare_peg(fit);
    else                        hsw_peg(fit);
}

// ============================================================================
//  hsw_grid(nx, ny, depth) — the FEMALE wall panel. Holes placed by the SAME
//  hsw_cx/hsw_cy so a hsw_mount(nx,ny) co-registers EXACTLY (proof artifact).
//  Lipped hex socket: 20mm bore, 1mm catch lip at 5mm depth.
// ============================================================================
module hsw_hex2d(af) { rotate([0,0,90]) circle(r = af/sqrt(3), $fn = 6); }

module hsw_hex_hole(depth) {
    afMouth = HSWX_INSIDE + 2*HSWX_LOCK_CHAMFER;
    afFull  = HSWX_INSIDE;
    afLip   = HSWX_INSIDE - 2*HSWX_LOCK_LIP;
    translate([0,0,-HSWX_LOCK_CHAMFER/2 + 0.01])
        linear_extrude(HSWX_LOCK_CHAMFER + 0.02, center=true, scale = afFull/afMouth) hsw_hex2d(afMouth);
    translate([0,0,-HSWX_LOCK_DEPTH/2])
        linear_extrude(HSWX_LOCK_DEPTH + 0.02, center=true) hsw_hex2d(afFull);
    translate([0,0,-HSWX_LOCK_DEPTH])
        linear_extrude(0.6, center=true) hsw_hex2d(afLip);
    backLen = depth - HSWX_LOCK_DEPTH;
    if (backLen > 0.1)
        translate([0,0,-(HSWX_LOCK_DEPTH + backLen/2)])
            linear_extrude(backLen + 0.4, center=true) hsw_hex2d(afFull);
}

module hsw_grid(nx = 3, ny = 3, depth = HSWX_DEPTH) {
    spanX = (nx-1)*HSW_PITCH_X;
    spanY = (ny-1)*HSW_PITCH_Y;
    slabW = spanX + HSWX_OUTSIDE;
    slabD = spanY + HSWX_OUTSIDE + hsw_max_stag(nx);
    difference() {
        translate([0, -hsw_max_stag(nx)/2, -depth/2]) cube([slabW, slabD, depth], center = true);
        for (c = [0 : nx-1])
            for (r = [0 : ny-1])
                translate([hsw_cx(c, nx), hsw_cy(c, r, nx, ny), 0]) hsw_hex_hole(depth);
    }
}

// ============================================================================
//  hsw_display() — canonical AnimBox display orientation. The geometry is built
//  in the OpenSCAD print frame (scad +Z = wall normal, +Y = up the wall). The
//  The OpenSCAD->AnimBox import is IDENTITY (verified by bbox: cube([10,20,40])
//  imports to world [10,20,40]). The wall-frame is already the display frame:
//  up-the-wall (+Y) = world UP, along-the-wall (+X) = world X, wall normal (+Z)
//  = toward the viewer (the body projects out of the wall). So hsw_display() is a
//  pass-through; it stays as the single place to adjust display orientation if the
//  import convention ever changes. Wrap every recipe's top call: hsw_display() my_part();
// ============================================================================
module hsw_display() { children(); }

// ---- product body (hidden internals) ----
eps   = 0.05;
PLATE = PLATE_T_DEFAULT;

module saddle_block() {
    bw  = cradle_d + 2 * wall;             // X width
    bh  = cradle_d + wall + front_lip;     // Y height
    z0  = PLATE - HSW_WELD;
    y0  = -bh / 2;
    ych = y0 + bh - cradle_d / 2 - wall;   // channel centre, near the top
    mouth = cradle_d * 0.62;               // retaining mouth (narrower than the item)
    difference() {
        translate([-bw / 2, y0, z0]) cube([bw, bh, reach + HSW_WELD]);
        // cradle channel: a cylinder along Z (front-to-back) the item rests in
        translate([0, ych, z0 - eps]) cylinder(h = reach + HSW_WELD + 2 * eps, d = cradle_d);
        // top mouth so the item snaps in (narrower than the channel -> retains it)
        translate([-mouth / 2, ych, z0 - eps]) cube([mouth, bh, reach + HSW_WELD + 2 * eps]);
    }
}
module u_hook() {
    hsw_mount(connectors_x, connectors_y, type = connector_type, clearance = clearance,
              straight = (support_style == "grid"), crot = connector_rotation);
    saddle_block();
}
hsw_display() u_hook();
`);

Open in editor →

HSW Insert (rounded, configurable)

A smoothly-rounded honeycomb-wall insert with optional center hole, side latch tabs, front hexagon emboss and a flat-side variant.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Generates insert-empty, insert-full and a flat-sided variation of both, with or without the front hexagon emboss.
// Made to make it easy to include in other OpenSCAD models.

verticalSpacing = 23.6;
horizontalSpacing = 40.88;



module hws_insert(centerHole=false, lateralTabs=true, frontDecoration=false,flatSide=true) {
    //Parameters to change in case you deviated from the standard Honeycomb Wall
    hexHeight = 19.8;
    insideHexHeight = 13.40;
    insertDepth = 7.67;
    //Parameters you should not change unless you know what you're doing.
    frontDepth = 2; 
    frontExtension = 1.5;
    gapVert = 1;
    gapHor = 0.8;
    gapLen = 8;
    gapVertDepth = 3.5;
    gapHorDepth = 1.6;
    bumpHeight = 0.5;
    bumpWidth = 2;
    bumpLen = gapVertDepth - gapHor - bumpHeight*2;
    bumpAng = 20;
    //insert assembly using other modules
    difference() {
        union() {
            insert(hexHeight,insertDepth,frontDepth,frontExtension);
            if(lateralTabs) tabBumps(bumpHeight=bumpHeight,hexHeight=hexHeight,insertDepth=insertDepth,frontDepth=frontDepth,bumpLen=bumpLen,bumpAng=bumpAng);
        }
        if (lateralTabs) tabsCutout(hexHeight=hexHeight,gapHorDepth=gapHorDepth,insertDepth=insertDepth,frontDepth=frontDepth,gapLen=gapLen,gapVert=gapVert,gapVertDepth=gapVertDepth,gapHor=gapHor, flatSide=flatSide);
        if (centerHole) insertHole(insideHexHeight=insideHexHeight,insertDepth=insertDepth,frontDepth=frontDepth);
        if (frontDecoration) hexCutout(innerHexHeight=insideHexHeight+1.55);
        if (flatSide) sideFlattener(hexHeight=hexHeight, fullInsertDepth=insertDepth+frontDepth);
    }
}


module hws_insert_n_vert(centerHole=false, lateralTabs=true, frontDecoration=false,flatSide=false,n=2,blanks=1) {
    ycopies(verticalSpacing*(1+blanks),n=n) hws_insert(centerHole=centerHole, lateralTabs=lateralTabs, frontDecoration=frontDecoration,flatSide=flatSide);
}

module hws_insert_n_hor(centerHole=false, lateralTabs=true, frontDecoration=false,flatSide=false,n=2,blanks=0) {
    xcopies(horizontalSpacing*(1+blanks),n=n) hws_insert(centerHole=centerHole, lateralTabs=lateralTabs, frontDecoration=frontDecoration,flatSide=flatSide);
}

module hws_insert_rail(length=verticalSpacing+20,width=19.7,n=1,depth=2){
    hws_insert_n_hor(centerHole=false, lateralTabs=true, frontDecoration=false,flatSide=false,n=n,blanks=0);
    prismoid(size1=[length,width+3], size2=[length,width], h=depth, anchor=TOP);
}
//Auxiliary modules. Coded separately for readability.
module insert(hexHeight,insertDepth,frontDepth,frontExtension) {
    union() {
        //insert
        rounded_prism(hexagon(d=2/sqrt(3)*hexHeight), h=insertDepth+frontDepth, anchor=BOTTOM, joint_top=0.25, joint_sides=.2, splinesteps=1);
        //insert front edge
        rounded_prism(hexagon(d=2/sqrt(3)*(hexHeight+frontExtension)), h=frontDepth, anchor=BOTTOM, joint_bot=.3, joint_sides=.1, splinesteps=1);
    }
}

module insertHole(insideHexHeight,insertDepth,frontDepth) {
    down(0.05)rounded_prism(hexagon(d=2/sqrt(3)*(insideHexHeight)), h=insertDepth+frontDepth+0.1, anchor=BOTTOM, joint_top=-0.25, joint_bot=-0.25, splinesteps=1);
}

module tabsCutout(hexHeight,gapHorDepth,insertDepth,frontDepth,gapLen=8,gapVert,gapVertDepth,gapHor,flatSide=false) {
    difference() {
        rot_copies(n=6, v=UP, delta=[0,hexHeight/2-gapHorDepth,0]) union() {
            up(insertDepth+frontDepth+.1) cuboid([gapLen, gapVert, gapVertDepth+.1], anchor=TOP-BACK);
            up(insertDepth+frontDepth-gapVertDepth+gapHor) cuboid([gapLen, gapHorDepth+.1, gapHor], anchor=TOP-BACK);
        }
        if(flatSide) back(hexHeight/2-gapHorDepth-.1) up(insertDepth+frontDepth+.2) cuboid([gapLen+1,gapVertDepth,insertDepth], anchor=TOP-BACK);
    }
}

module tabBumps(bumpHeight,hexHeight,insertDepth,frontDepth,bumpLen,bumpAng) {
    leftshift=bumpHeight;
    rot_copies(n= 6, v=UP, delta=[0,hexHeight/2,0]) up(insertDepth+frontDepth-bumpLen) rotate([90,0,90]) right_half() left(leftshift) rounded_prism(teardrop2d(r=bumpHeight*2, ang=bumpAng, cap_h=bumpLen+sqrt((2*bumpHeight)^2-leftshift^2), $fn=36), h=bumpLen);
}
module hexCutout(innerHexHeight,cutDepth=0.4,lineWidth=1) {
    tube(h=cutDepth, od=2/sqrt(3)*(innerHexHeight+lineWidth),id=2/sqrt(3)*(innerHexHeight), anchor=BOTTOM, $fn=6);
}
module sideFlattener(hexHeight, fullInsertDepth) {
    down(0.2) back(hexHeight/2) cuboid([hexHeight*2, hexHeight, fullInsertDepth*1.5], anchor=BOTTOM-BACK);
}




// Component testing lines. Uncomment to view individual element with default size

//insert(hexHeight=20,insertDepth=7.67,frontDepth=2,frontExtension=1);
//tabBumps(bumpHeight=0.5,hexHeight=20,insertDepth=7.67,frontDepth=2,bumpLen=1.7,bumpAng=20);
//tabsCutout(hexHeight=20,gapHorDepth=1.6,insertDepth=7.67,frontDepth=2,gapLen=8,gapVert=1,gapVertDepth=3.5,gapHor=0.8,flatSide=true);
//color("red") insertHole();
//hexCutout(innerHexHeight=13.40+1.55);
//sideFlattener(hexHeight = 20, fullInsertDepth=7.67+2);

// Final module testing lines. Uncomment to view how different options generate different versions of the insert.
//hws_insert();
//hws_insert(flatSide=false);
//hws_insert(flatSide=false, centerHole=true);
//hws_insert(flatSide=false, centerHole=true, frontDecoration=true);

//hws_insert_n_vert(blanks=1);
//hws_insert_n_hor();
//hws_insert_rail();

// ---- render a decorated, center-holed insert ----
hws_insert(centerHole=true, frontDecoration=true, flatSide=false);
`);

Open in editor →

HSW Screwdriver Rack

A wall shelf with a row of graduated holes that hold screwdrivers (or any shaft tool) shaft-down with the handle resting on top. Pick how it clips to the wall: friction peg, bare peg (into a latch), latch insert, or spring clip; grid or honeycomb support.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// HSW Screwdriver Rack
//
// Source: honeycomb-wall screwdriver rack
// Generated from the library above, used under its license.

/* [Wall mount] */
// How it attaches to the wall
connector_type = "peg";       // [peg:Friction peg (into wall), barepeg:Bare peg (into a latch), latch:Latch insert (into wall), clip:Spring clip (into wall)]
// Plug support style
support_style = "grid";       // [grid:Grid (aligned rows + columns), honeycomb:Honeycomb (staggered, denser)]
// Rotate the plug pattern (to match a wall mounted sideways)
connector_rotation = 0;       // [0:0 degrees, 90:90 degrees]
// Hex connectors across (a wide rack wants 3+)
connectors_x = 3;             // [1:8]
// Hex connector rows (1 = single line)
connectors_y = 1;             // [1:4]
// Fit tweak: + looser / - tighter
clearance = 0;                // [-0.3:0.05:0.5]

/* [Rack] */
// Number of tool holes
holes = 5;                    // [1:12]
// Smallest hole diameter (mm)
hole_min_d = 5;               // [3:20]
// Largest hole diameter (mm)
hole_max_d = 11;              // [3:30]
// Spacing between hole centres (mm)
hole_spacing = 22;            // [12:40]
// How far the shelf projects from the wall (mm)
shelf_depth = 28;             // [15:60]
// Shelf thickness (mm)
shelf_t = 7;                  // [4:14]
// Shelf height up the wall (mm)
shelf_y = 0;                  // [-25:30]

// ============================================================================
//  HSW CONNECTOR TEMPLATE — the single canonical, self-contained connector kit
//  every HSW example inlines VERBATIM so plug spacing + sizing stay identical.
//  OpenSCAD 2021.01-safe. Self-contained: no include/use, no external libraries.
//
//  THE ONE RULE: plugs (hsw_mount) and wall holes (hsw_grid) are placed by the
//  SAME lattice functions hsw_cx()/hsw_cy(), so plug(c,r) == hole(c,r) for ANY
//  count by construction — verified 0.0000 mm deviation for 1..5 in each axis.
//
//  Frame: +Z = wall-normal (out of the wall). Connectors point into -Z (into the
//  wall); the back-plate front face sits at +Z = plate_t; accessory bodies build
//  on the +Z face. UP the wall = +Y, X = horizontal.
//
//  CUSTOMIZER: everything below is in the Hidden group so a product recipe that
//  inlines this template exposes ONLY its own dimensions + connectors_x/y +
//  connector_type + one clearance tweak. The HSW internals are NEVER customer-tunable.
// ============================================================================
/* [Hidden] */
$fn = 48;

// ---- Core hex interface (the 20mm hole a connector plugs into) -------------
HSWX_INSIDE       = 20;                              // hex hole flat-to-flat
HSWX_WALL         = 1.8;                             // shared cell wall thickness
HSWX_OUTSIDE      = HSWX_INSIDE + HSWX_WALL*2;       // 23.6  outside flat-to-flat
HSWX_SIDE         = HSWX_OUTSIDE / sqrt(3);          // ~13.6255 outer side length
HSWX_DEPTH        = 8;                               // panel / plug depth (Std Duty)
HSWX_LOCK_DEPTH   = 5;                               // depth where the lock step starts
HSWX_LOCK_LIP     = 1;                               // 1mm internal lip the barb catches
HSWX_LOCK_CHAMFER = HSWX_LOCK_LIP;                   // 1mm @ 45deg lead-in

// ---- Verified honeycomb lattice (flat-topped hexes, column tiling) ---------
HSW_PITCH_X       = 1.5 * HSWX_SIDE;                 // ~20.4382 column-to-column
HSW_PITCH_Y       = HSWX_OUTSIDE;                    // 23.6    row-to-row in a column
HSW_STAGGER_Y     = HSWX_OUTSIDE / 2;               // 11.8    alternate-column offset

// ---- Shared connector tunables ---------------------------------------------
PEG_FIT_DEFAULT   = 0.35;                            // bare-peg friction clearance
PEG_LEN_DEFAULT   = 7;                               // bare-peg depth into wall (< HSWX_DEPTH)
PLATE_T_DEFAULT   = 3;                               // back-plate thickness (welds depend on it)
HSW_WELD          = 0.6;                              // connector overlap INTO the plate (one fused solid)

// Across-flats -> circumscribed diameter (a $fn=6 cylinder lands on those flats).
// af/sqrt(3)*2 is IDENTICAL to af/cos(30); ONE form library-wide.
function hsw_af_to_d(af) = af / sqrt(3) * 2;

// ============================================================================
//  THE LATTICE — the single source of truth for WHERE connectors/holes go.
//  Bounding-box-centred on the origin for ANY nx/ny (incl. the single-column
//  case): the staggered odd columns only exist when nx>1, so the y-centring of
//  the cluster is conditional on nx>1. hsw_mount AND hsw_grid both call these.
// ============================================================================
function hsw_max_stag(nx) = (nx > 1) ? HSW_STAGGER_Y : 0;     // odd col only exists if nx>1
function hsw_cx(c, nx)    = c*HSW_PITCH_X - (nx-1)*HSW_PITCH_X/2;
function hsw_cy(c, r, nx, ny) =
    r*HSW_PITCH_Y
    - (ny-1)*HSW_PITCH_Y/2
    + ((c % 2 == 1) ? HSW_STAGGER_Y : 0)            // real alternate-column stagger
    - hsw_max_stag(nx)/2;                            // centre the cluster (cond. on nx>1)

// straight=true strip: every-OTHER column, no stagger (the legacy 40.88 strip).
// Use 2*HSW_PITCH_X (=40.8764), NEVER the rounded 40.88 literal.
function hsw_cx_straight(c, nx) = c*(2*HSW_PITCH_X) - (nx-1)*(2*HSW_PITCH_X)/2;

// ============================================================================
//  CONNECTOR 1 — hsw_peg : bare friction press-peg (the de-facto canonical peg).
//  $fn=6 hex prism, across-flats = HSWX_INSIDE - 2*fit, into -Z. Press fit only.
// ============================================================================
module hsw_peg(fit = PEG_FIT_DEFAULT, len = PEG_LEN_DEFAULT) {
    af = HSWX_INSIDE - 2*fit;                        // flat-to-flat, slightly under 20
    // hex prism from z=+HSW_WELD (buried INTO the plate) down to z=-len (into wall),
    // so the peg fuses with any plate occupying z>=0 into ONE solid (no coincident-face seam).
    translate([0, 0, -len])
        cylinder(h = len + HSW_WELD, d = hsw_af_to_d(af), $fn = 6);
}

// ============================================================================
//  CONNECTOR 1b — hsw_bare_peg : the THIN CORE peg (hex-plug-library hexagon_plug)
//  that plugs into a SEPARATE latch insert pre-snapped in the wall — NOT the grid
//  directly. Verbatim dims: 14.7 across-corners, 13 deep. Into -Z, welds the plate.
// ============================================================================
BAREPEG_D   = 14.7;     // across-corners ($fn=6) — source PLUG_HEXAGON_DIAMETER
BAREPEG_LEN = 13;       // source PLUG_LENGTH
module hsw_bare_peg(fit = 0) {
    translate([0, 0, -BAREPEG_LEN])
        cylinder(h = BAREPEG_LEN + HSW_WELD, d = BAREPEG_D - 2*fit, $fn = 6);
}

// ============================================================================
//  hsw_mount(nx, ny, type, plate_t, fit, straight)
//  ONE back-plate (front face +Z = plate_t) carrying an nx*ny connector lattice
//  on -Z, placed by hsw_cx/hsw_cy. type dispatches the per-cell connector.
// ============================================================================
// straight=true  -> GRID support  : pegs on an aligned rectangular grid
//                                    (40.8764 horiz x 23.6 vert, every-other
//                                    honeycomb column -> all land in real holes).
// straight=false -> HONEYCOMB support: pegs follow the staggered hex lattice
//                                    (20.4382 column pitch, odd columns staggered).
module hsw_mount(nx = 1, ny = 1, type = "peg", plate_t = PLATE_T_DEFAULT,
                 clearance = 0, straight = false, margin = 3, crot = 0) {
    // clamp counts so a user 0 (or negative) never yields an empty / garbage mount
    gnx = max(1, nx);
    gny = max(1, ny);
    // per-type base fit (peg=press 0.35, clip=snap 0.15, latch/barepeg=0 lip-tuned)
    // + the product's single user clearance tweak (+ looser / - tighter).
    pfit = (type == "clip" ? CLIP_FIT_DEFAULT
          : (type == "latch" || type == "barepeg") ? 0
          : PEG_FIT_DEFAULT) + clearance;
    // plate footprint spans the lattice + margin. GRID has no stagger; only the
    // staggered honeycomb extends Y by the odd-column stagger.
    spanX = straight ? (gnx-1)*(2*HSW_PITCH_X) : (gnx-1)*HSW_PITCH_X;
    spanY = (gny-1)*HSW_PITCH_Y;
    w = spanX + HSWX_OUTSIDE + 2*margin;
    d = spanY + HSWX_OUTSIDE + (straight ? 0 : hsw_max_stag(gnx)) + 2*margin;
    // crot rotates the PLUG PATTERN (plate + connectors, together so plugs stay on
    // the plate) about the wall normal so the accessory can match a wall installed
    // rotated 90deg. The body is built separately by the recipe and is NOT rotated
    // (plug layout only — body fixed).
    rotate([0, 0, crot]) {
        translate([0, 0, plate_t/2]) cube([w, d, plate_t], center = true);   // plate
        for (c = [0 : gnx-1])
            for (r = [0 : gny-1]) {
                x = straight ? hsw_cx_straight(c, gnx) : hsw_cx(c, gnx);
                y = straight ? (r*HSW_PITCH_Y - spanY/2) : hsw_cy(c, r, gnx, gny);
                translate([x, y, 0]) hsw_connector(type, pfit);
            }
    }
}

// ============================================================================
//  CONNECTOR 2 — hsw_latch_insert : snap-tab latching insert (vanilla port of
//  hex-plug-library / hsw-custom-insert, sh1-verified). Built front-face(lip) at
//  z=0 with body in +Z, then flipped to -Z and welded into the plate.
// ============================================================================
INSERT_BODY_FLATS = 19.7;   INSERT_LIP_FLATS = 22.5;   INSERT_TOTAL_H = 10;
INSERT_LIP_H = 2.5;         INSERT_SNAP_H = 6.5;       INSERT_TAB_OUT = 0.5;
INSERT_TAB_LEN = 2;         INSERT_SLOT_LEN = 8;       INSERT_SLOT_W = 0.8;
INSERT_SLOT_SIDE = 1;       INSERT_SLOT_RAD = 8.25;

module _hsw_bevel_cut(diameter) {
    h = diameter/2;                                     // tan(45)==1
    difference() { cylinder(d = diameter*2, h = h); cylinder(d1 = diameter, d2 = 0, h = h); }
}
module _hsw_insert_body(fit) {
    bodyD = hsw_af_to_d(INSERT_BODY_FLATS - 2*fit);
    lipD  = hsw_af_to_d(INSERT_LIP_FLATS);
    difference() {
        union() {
            cylinder(d = bodyD, h = INSERT_TOTAL_H, $fn = 6);   // main plug
            cylinder(d = lipD,  h = INSERT_LIP_H,  $fn = 6);    // overhang lip
        }
        translate([0,0,INSERT_TOTAL_H - 0.35]) _hsw_bevel_cut(bodyD);   // soften top edge
    }
}
module hsw_latch_insert(fit = 0) {
    translate([0,0,HSW_WELD]) rotate([180,0,0])
    union() {
        // six snap tabs (non-degenerate tip r=0.2, tops kept below the bevel)
        for (i=[0:5]) rotate([0,0,i*60]) translate([0, INSERT_BODY_FLATS/2, 0])
            hull() {
                translate([0,0,INSERT_SNAP_H + INSERT_SLOT_SIDE + INSERT_TAB_OUT])
                    rotate([0,90,0]) cylinder(r = INSERT_TAB_OUT, h = INSERT_TAB_LEN, center=true, $fn=20);
                translate([0,0,INSERT_TOTAL_H - 0.6])
                    rotate([0,90,0]) cylinder(r = 0.2, h = INSERT_TAB_LEN, center=true, $fn=20);
            }
        // body with flex slots so each tab deflects on insertion
        difference() {
            _hsw_insert_body(fit);
            for (i=[0:5]) rotate([0,0,i*60]) {
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_SLOT_W, INSERT_TOTAL_H]);
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_TOTAL_H, INSERT_SLOT_SIDE]);
            }
        }
    }
}

// ============================================================================
//  CONNECTOR 3 — hsw_clip : spring snap clip (from hsw-lib-core, sh1-verified).
//  Two cantilever arms catch the 1mm lip at 5mm depth. Mouth at z=0 into -Z.
// ============================================================================
CLIP_FIT_DEFAULT = 0.15;
CLIP_AF  = HSWX_INSIDE;      // 20 plug across-flats target
CLIP_LEN = HSWX_DEPTH;       // 8  plug length into the wall
SPRING_WALL = 1.6;           // cantilever arm wall (>=1.4 to flex)
SPRING_SLOT = 2.2;           // central relief slot width
module hsw_clip(fit = CLIP_FIT_DEFAULT) {
    af = CLIP_AF - 2*fit;  L = CLIP_LEN;
    barb = HSWX_LOCK_LIP;  locz = HSWX_LOCK_DEPTH;  cham = HSWX_LOCK_CHAMFER;  halfX = af/2;
    translate([0,0,HSW_WELD])
    difference() {
        union() {
            translate([0,0,-L/2]) linear_extrude(height = L, center = true) hsw_hex2d(af);   // hex plug
            for (sx=[-1,1]) translate([sx*halfX,0,-locz]) rotate([90,0,0])                    // outward barbs
                linear_extrude(height = af*0.62, center = true)
                    polygon([[0,0],[sx*barb,0],[sx*barb,cham],[0,cham+barb]]);
            translate([0,0,0.6/2]) linear_extrude(height = 0.6, center = true) hsw_hex2d(af + 1.2);  // mouth flange
        }
        translate([0,0,-L/2-0.5]) cube([SPRING_SLOT, af+4, L+2-1.2], center = true);          // central relief slot
        for (sx=[-1,1]) translate([sx*(halfX-SPRING_WALL-0.3),0,-L/2-1]) cube([1.4, af*0.5, L], center=true);  // arm hollow
    }
}

// per-cell connector dispatch:
//   peg     = friction peg, jams the bare grid hole (one-part)
//   barepeg = thin core peg, plugs into a SEPARATE latch pre-snapped in the wall
//   latch   = snap-tab insert, snaps into the bare grid hole
//   clip    = spring clip, snaps into the bare grid hole
module hsw_connector(type = "peg", fit = PEG_FIT_DEFAULT) {
    if      (type == "latch")   hsw_latch_insert(fit);
    else if (type == "clip")    hsw_clip(fit);
    else if (type == "barepeg") hsw_bare_peg(fit);
    else                        hsw_peg(fit);
}

// ============================================================================
//  hsw_grid(nx, ny, depth) — the FEMALE wall panel. Holes placed by the SAME
//  hsw_cx/hsw_cy so a hsw_mount(nx,ny) co-registers EXACTLY (proof artifact).
//  Lipped hex socket: 20mm bore, 1mm catch lip at 5mm depth.
// ============================================================================
module hsw_hex2d(af) { rotate([0,0,90]) circle(r = af/sqrt(3), $fn = 6); }

module hsw_hex_hole(depth) {
    afMouth = HSWX_INSIDE + 2*HSWX_LOCK_CHAMFER;
    afFull  = HSWX_INSIDE;
    afLip   = HSWX_INSIDE - 2*HSWX_LOCK_LIP;
    translate([0,0,-HSWX_LOCK_CHAMFER/2 + 0.01])
        linear_extrude(HSWX_LOCK_CHAMFER + 0.02, center=true, scale = afFull/afMouth) hsw_hex2d(afMouth);
    translate([0,0,-HSWX_LOCK_DEPTH/2])
        linear_extrude(HSWX_LOCK_DEPTH + 0.02, center=true) hsw_hex2d(afFull);
    translate([0,0,-HSWX_LOCK_DEPTH])
        linear_extrude(0.6, center=true) hsw_hex2d(afLip);
    backLen = depth - HSWX_LOCK_DEPTH;
    if (backLen > 0.1)
        translate([0,0,-(HSWX_LOCK_DEPTH + backLen/2)])
            linear_extrude(backLen + 0.4, center=true) hsw_hex2d(afFull);
}

module hsw_grid(nx = 3, ny = 3, depth = HSWX_DEPTH) {
    spanX = (nx-1)*HSW_PITCH_X;
    spanY = (ny-1)*HSW_PITCH_Y;
    slabW = spanX + HSWX_OUTSIDE;
    slabD = spanY + HSWX_OUTSIDE + hsw_max_stag(nx);
    difference() {
        translate([0, -hsw_max_stag(nx)/2, -depth/2]) cube([slabW, slabD, depth], center = true);
        for (c = [0 : nx-1])
            for (r = [0 : ny-1])
                translate([hsw_cx(c, nx), hsw_cy(c, r, nx, ny), 0]) hsw_hex_hole(depth);
    }
}

// ============================================================================
//  hsw_display() — canonical AnimBox display orientation. The geometry is built
//  in the OpenSCAD print frame (scad +Z = wall normal, +Y = up the wall). The
//  The OpenSCAD->AnimBox import is IDENTITY (verified by bbox: cube([10,20,40])
//  imports to world [10,20,40]). The wall-frame is already the display frame:
//  up-the-wall (+Y) = world UP, along-the-wall (+X) = world X, wall normal (+Z)
//  = toward the viewer (the body projects out of the wall). So hsw_display() is a
//  pass-through; it stays as the single place to adjust display orientation if the
//  import convention ever changes. Wrap every recipe's top call: hsw_display() my_part();
// ============================================================================
module hsw_display() { children(); }

// ---- product body (hidden internals) ----
eps   = 0.05;
PLATE = PLATE_T_DEFAULT;

module rack_shelf() {
    span = (holes - 1) * hole_spacing;
    w    = span + hole_max_d + 8;
    difference() {
        // flat shelf: wide in X, deep in +Z, thin in Y, welded back into the plate
        translate([-w / 2, shelf_y - shelf_t / 2, PLATE - HSW_WELD])
            cube([w, shelf_t, shelf_depth + HSW_WELD]);
        // graduated vertical bores (along Y), front-biased so a handle rests on top
        for (i = [0 : holes - 1]) {
            d = hole_min_d + (holes > 1 ? (hole_max_d - hole_min_d) * i / (holes - 1) : 0);
            translate([-span / 2 + i * hole_spacing, shelf_y + shelf_t / 2 + eps, PLATE + shelf_depth * 0.55])
                rotate([90, 0, 0])
                    cylinder(h = shelf_t + 2 * eps, d = d);
        }
    }
}
module screwdriver_rack() {
    hsw_mount(connectors_x, connectors_y, type = connector_type, clearance = clearance,
              straight = (support_style == "grid"), crot = connector_rotation);
    rack_shelf();
}
hsw_display() screwdriver_rack();
`);

Open in editor →

HSW Wide Tool Cup

A wide, flat-based cup for pliers, brushes, markers, or shop tools, held out from the wall on swappable plugs. Optional drain hole in the base.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// HSW Wide Tool Cup
//
// Source: honeycomb-wall wide tool cup
// Generated from the library above, used under its license.

/* [Wall mount] */
// How it attaches to the wall
connector_type = "peg";       // [peg:Friction peg (into wall), barepeg:Bare peg (into a latch), latch:Latch insert (into wall), clip:Spring clip (into wall)]
// Plug support style
support_style = "grid";       // [grid:Grid (aligned rows + columns), honeycomb:Honeycomb (staggered, denser)]
// Rotate the plug pattern (to match a wall mounted sideways)
connector_rotation = 0;       // [0:0 degrees, 90:90 degrees]
// Hex connectors across
connectors_x = 2;             // [1:8]
// Hex connector rows (2 = better for a heavy cup)
connectors_y = 2;             // [1:4]
// Fit tweak: + looser / - tighter
clearance = 0;                // [-0.3:0.05:0.5]

/* [Cup] */
// Inner bore diameter (mm)
cup_inner_d = 60;             // [25:120]
// Side wall thickness (mm)
cup_wall = 2.6;               // [1.2:0.2:4]
// Cup height (mm)
cup_height = 55;              // [25:120]
// Base thickness (mm)
cup_base_t = 2.6;             // [1.2:0.2:5]
// Drain hole through the base
drain = true;
// Drain hole diameter (mm)
drain_d = 8;                  // [3:20]

// ============================================================================
//  HSW CONNECTOR TEMPLATE — the single canonical, self-contained connector kit
//  every HSW example inlines VERBATIM so plug spacing + sizing stay identical.
//  OpenSCAD 2021.01-safe. Self-contained: no include/use, no external libraries.
//
//  THE ONE RULE: plugs (hsw_mount) and wall holes (hsw_grid) are placed by the
//  SAME lattice functions hsw_cx()/hsw_cy(), so plug(c,r) == hole(c,r) for ANY
//  count by construction — verified 0.0000 mm deviation for 1..5 in each axis.
//
//  Frame: +Z = wall-normal (out of the wall). Connectors point into -Z (into the
//  wall); the back-plate front face sits at +Z = plate_t; accessory bodies build
//  on the +Z face. UP the wall = +Y, X = horizontal.
//
//  CUSTOMIZER: everything below is in the Hidden group so a product recipe that
//  inlines this template exposes ONLY its own dimensions + connectors_x/y +
//  connector_type + one clearance tweak. The HSW internals are NEVER customer-tunable.
// ============================================================================
/* [Hidden] */
$fn = 48;

// ---- Core hex interface (the 20mm hole a connector plugs into) -------------
HSWX_INSIDE       = 20;                              // hex hole flat-to-flat
HSWX_WALL         = 1.8;                             // shared cell wall thickness
HSWX_OUTSIDE      = HSWX_INSIDE + HSWX_WALL*2;       // 23.6  outside flat-to-flat
HSWX_SIDE         = HSWX_OUTSIDE / sqrt(3);          // ~13.6255 outer side length
HSWX_DEPTH        = 8;                               // panel / plug depth (Std Duty)
HSWX_LOCK_DEPTH   = 5;                               // depth where the lock step starts
HSWX_LOCK_LIP     = 1;                               // 1mm internal lip the barb catches
HSWX_LOCK_CHAMFER = HSWX_LOCK_LIP;                   // 1mm @ 45deg lead-in

// ---- Verified honeycomb lattice (flat-topped hexes, column tiling) ---------
HSW_PITCH_X       = 1.5 * HSWX_SIDE;                 // ~20.4382 column-to-column
HSW_PITCH_Y       = HSWX_OUTSIDE;                    // 23.6    row-to-row in a column
HSW_STAGGER_Y     = HSWX_OUTSIDE / 2;               // 11.8    alternate-column offset

// ---- Shared connector tunables ---------------------------------------------
PEG_FIT_DEFAULT   = 0.35;                            // bare-peg friction clearance
PEG_LEN_DEFAULT   = 7;                               // bare-peg depth into wall (< HSWX_DEPTH)
PLATE_T_DEFAULT   = 3;                               // back-plate thickness (welds depend on it)
HSW_WELD          = 0.6;                              // connector overlap INTO the plate (one fused solid)

// Across-flats -> circumscribed diameter (a $fn=6 cylinder lands on those flats).
// af/sqrt(3)*2 is IDENTICAL to af/cos(30); ONE form library-wide.
function hsw_af_to_d(af) = af / sqrt(3) * 2;

// ============================================================================
//  THE LATTICE — the single source of truth for WHERE connectors/holes go.
//  Bounding-box-centred on the origin for ANY nx/ny (incl. the single-column
//  case): the staggered odd columns only exist when nx>1, so the y-centring of
//  the cluster is conditional on nx>1. hsw_mount AND hsw_grid both call these.
// ============================================================================
function hsw_max_stag(nx) = (nx > 1) ? HSW_STAGGER_Y : 0;     // odd col only exists if nx>1
function hsw_cx(c, nx)    = c*HSW_PITCH_X - (nx-1)*HSW_PITCH_X/2;
function hsw_cy(c, r, nx, ny) =
    r*HSW_PITCH_Y
    - (ny-1)*HSW_PITCH_Y/2
    + ((c % 2 == 1) ? HSW_STAGGER_Y : 0)            // real alternate-column stagger
    - hsw_max_stag(nx)/2;                            // centre the cluster (cond. on nx>1)

// straight=true strip: every-OTHER column, no stagger (the legacy 40.88 strip).
// Use 2*HSW_PITCH_X (=40.8764), NEVER the rounded 40.88 literal.
function hsw_cx_straight(c, nx) = c*(2*HSW_PITCH_X) - (nx-1)*(2*HSW_PITCH_X)/2;

// ============================================================================
//  CONNECTOR 1 — hsw_peg : bare friction press-peg (the de-facto canonical peg).
//  $fn=6 hex prism, across-flats = HSWX_INSIDE - 2*fit, into -Z. Press fit only.
// ============================================================================
module hsw_peg(fit = PEG_FIT_DEFAULT, len = PEG_LEN_DEFAULT) {
    af = HSWX_INSIDE - 2*fit;                        // flat-to-flat, slightly under 20
    // hex prism from z=+HSW_WELD (buried INTO the plate) down to z=-len (into wall),
    // so the peg fuses with any plate occupying z>=0 into ONE solid (no coincident-face seam).
    translate([0, 0, -len])
        cylinder(h = len + HSW_WELD, d = hsw_af_to_d(af), $fn = 6);
}

// ============================================================================
//  CONNECTOR 1b — hsw_bare_peg : the THIN CORE peg (hex-plug-library hexagon_plug)
//  that plugs into a SEPARATE latch insert pre-snapped in the wall — NOT the grid
//  directly. Verbatim dims: 14.7 across-corners, 13 deep. Into -Z, welds the plate.
// ============================================================================
BAREPEG_D   = 14.7;     // across-corners ($fn=6) — source PLUG_HEXAGON_DIAMETER
BAREPEG_LEN = 13;       // source PLUG_LENGTH
module hsw_bare_peg(fit = 0) {
    translate([0, 0, -BAREPEG_LEN])
        cylinder(h = BAREPEG_LEN + HSW_WELD, d = BAREPEG_D - 2*fit, $fn = 6);
}

// ============================================================================
//  hsw_mount(nx, ny, type, plate_t, fit, straight)
//  ONE back-plate (front face +Z = plate_t) carrying an nx*ny connector lattice
//  on -Z, placed by hsw_cx/hsw_cy. type dispatches the per-cell connector.
// ============================================================================
// straight=true  -> GRID support  : pegs on an aligned rectangular grid
//                                    (40.8764 horiz x 23.6 vert, every-other
//                                    honeycomb column -> all land in real holes).
// straight=false -> HONEYCOMB support: pegs follow the staggered hex lattice
//                                    (20.4382 column pitch, odd columns staggered).
module hsw_mount(nx = 1, ny = 1, type = "peg", plate_t = PLATE_T_DEFAULT,
                 clearance = 0, straight = false, margin = 3, crot = 0) {
    // clamp counts so a user 0 (or negative) never yields an empty / garbage mount
    gnx = max(1, nx);
    gny = max(1, ny);
    // per-type base fit (peg=press 0.35, clip=snap 0.15, latch/barepeg=0 lip-tuned)
    // + the product's single user clearance tweak (+ looser / - tighter).
    pfit = (type == "clip" ? CLIP_FIT_DEFAULT
          : (type == "latch" || type == "barepeg") ? 0
          : PEG_FIT_DEFAULT) + clearance;
    // plate footprint spans the lattice + margin. GRID has no stagger; only the
    // staggered honeycomb extends Y by the odd-column stagger.
    spanX = straight ? (gnx-1)*(2*HSW_PITCH_X) : (gnx-1)*HSW_PITCH_X;
    spanY = (gny-1)*HSW_PITCH_Y;
    w = spanX + HSWX_OUTSIDE + 2*margin;
    d = spanY + HSWX_OUTSIDE + (straight ? 0 : hsw_max_stag(gnx)) + 2*margin;
    // crot rotates the PLUG PATTERN (plate + connectors, together so plugs stay on
    // the plate) about the wall normal so the accessory can match a wall installed
    // rotated 90deg. The body is built separately by the recipe and is NOT rotated
    // (plug layout only — body fixed).
    rotate([0, 0, crot]) {
        translate([0, 0, plate_t/2]) cube([w, d, plate_t], center = true);   // plate
        for (c = [0 : gnx-1])
            for (r = [0 : gny-1]) {
                x = straight ? hsw_cx_straight(c, gnx) : hsw_cx(c, gnx);
                y = straight ? (r*HSW_PITCH_Y - spanY/2) : hsw_cy(c, r, gnx, gny);
                translate([x, y, 0]) hsw_connector(type, pfit);
            }
    }
}

// ============================================================================
//  CONNECTOR 2 — hsw_latch_insert : snap-tab latching insert (vanilla port of
//  hex-plug-library / hsw-custom-insert, sh1-verified). Built front-face(lip) at
//  z=0 with body in +Z, then flipped to -Z and welded into the plate.
// ============================================================================
INSERT_BODY_FLATS = 19.7;   INSERT_LIP_FLATS = 22.5;   INSERT_TOTAL_H = 10;
INSERT_LIP_H = 2.5;         INSERT_SNAP_H = 6.5;       INSERT_TAB_OUT = 0.5;
INSERT_TAB_LEN = 2;         INSERT_SLOT_LEN = 8;       INSERT_SLOT_W = 0.8;
INSERT_SLOT_SIDE = 1;       INSERT_SLOT_RAD = 8.25;

module _hsw_bevel_cut(diameter) {
    h = diameter/2;                                     // tan(45)==1
    difference() { cylinder(d = diameter*2, h = h); cylinder(d1 = diameter, d2 = 0, h = h); }
}
module _hsw_insert_body(fit) {
    bodyD = hsw_af_to_d(INSERT_BODY_FLATS - 2*fit);
    lipD  = hsw_af_to_d(INSERT_LIP_FLATS);
    difference() {
        union() {
            cylinder(d = bodyD, h = INSERT_TOTAL_H, $fn = 6);   // main plug
            cylinder(d = lipD,  h = INSERT_LIP_H,  $fn = 6);    // overhang lip
        }
        translate([0,0,INSERT_TOTAL_H - 0.35]) _hsw_bevel_cut(bodyD);   // soften top edge
    }
}
module hsw_latch_insert(fit = 0) {
    translate([0,0,HSW_WELD]) rotate([180,0,0])
    union() {
        // six snap tabs (non-degenerate tip r=0.2, tops kept below the bevel)
        for (i=[0:5]) rotate([0,0,i*60]) translate([0, INSERT_BODY_FLATS/2, 0])
            hull() {
                translate([0,0,INSERT_SNAP_H + INSERT_SLOT_SIDE + INSERT_TAB_OUT])
                    rotate([0,90,0]) cylinder(r = INSERT_TAB_OUT, h = INSERT_TAB_LEN, center=true, $fn=20);
                translate([0,0,INSERT_TOTAL_H - 0.6])
                    rotate([0,90,0]) cylinder(r = 0.2, h = INSERT_TAB_LEN, center=true, $fn=20);
            }
        // body with flex slots so each tab deflects on insertion
        difference() {
            _hsw_insert_body(fit);
            for (i=[0:5]) rotate([0,0,i*60]) {
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_SLOT_W, INSERT_TOTAL_H]);
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_TOTAL_H, INSERT_SLOT_SIDE]);
            }
        }
    }
}

// ============================================================================
//  CONNECTOR 3 — hsw_clip : spring snap clip (from hsw-lib-core, sh1-verified).
//  Two cantilever arms catch the 1mm lip at 5mm depth. Mouth at z=0 into -Z.
// ============================================================================
CLIP_FIT_DEFAULT = 0.15;
CLIP_AF  = HSWX_INSIDE;      // 20 plug across-flats target
CLIP_LEN = HSWX_DEPTH;       // 8  plug length into the wall
SPRING_WALL = 1.6;           // cantilever arm wall (>=1.4 to flex)
SPRING_SLOT = 2.2;           // central relief slot width
module hsw_clip(fit = CLIP_FIT_DEFAULT) {
    af = CLIP_AF - 2*fit;  L = CLIP_LEN;
    barb = HSWX_LOCK_LIP;  locz = HSWX_LOCK_DEPTH;  cham = HSWX_LOCK_CHAMFER;  halfX = af/2;
    translate([0,0,HSW_WELD])
    difference() {
        union() {
            translate([0,0,-L/2]) linear_extrude(height = L, center = true) hsw_hex2d(af);   // hex plug
            for (sx=[-1,1]) translate([sx*halfX,0,-locz]) rotate([90,0,0])                    // outward barbs
                linear_extrude(height = af*0.62, center = true)
                    polygon([[0,0],[sx*barb,0],[sx*barb,cham],[0,cham+barb]]);
            translate([0,0,0.6/2]) linear_extrude(height = 0.6, center = true) hsw_hex2d(af + 1.2);  // mouth flange
        }
        translate([0,0,-L/2-0.5]) cube([SPRING_SLOT, af+4, L+2-1.2], center = true);          // central relief slot
        for (sx=[-1,1]) translate([sx*(halfX-SPRING_WALL-0.3),0,-L/2-1]) cube([1.4, af*0.5, L], center=true);  // arm hollow
    }
}

// per-cell connector dispatch:
//   peg     = friction peg, jams the bare grid hole (one-part)
//   barepeg = thin core peg, plugs into a SEPARATE latch pre-snapped in the wall
//   latch   = snap-tab insert, snaps into the bare grid hole
//   clip    = spring clip, snaps into the bare grid hole
module hsw_connector(type = "peg", fit = PEG_FIT_DEFAULT) {
    if      (type == "latch")   hsw_latch_insert(fit);
    else if (type == "clip")    hsw_clip(fit);
    else if (type == "barepeg") hsw_bare_peg(fit);
    else                        hsw_peg(fit);
}

// ============================================================================
//  hsw_grid(nx, ny, depth) — the FEMALE wall panel. Holes placed by the SAME
//  hsw_cx/hsw_cy so a hsw_mount(nx,ny) co-registers EXACTLY (proof artifact).
//  Lipped hex socket: 20mm bore, 1mm catch lip at 5mm depth.
// ============================================================================
module hsw_hex2d(af) { rotate([0,0,90]) circle(r = af/sqrt(3), $fn = 6); }

module hsw_hex_hole(depth) {
    afMouth = HSWX_INSIDE + 2*HSWX_LOCK_CHAMFER;
    afFull  = HSWX_INSIDE;
    afLip   = HSWX_INSIDE - 2*HSWX_LOCK_LIP;
    translate([0,0,-HSWX_LOCK_CHAMFER/2 + 0.01])
        linear_extrude(HSWX_LOCK_CHAMFER + 0.02, center=true, scale = afFull/afMouth) hsw_hex2d(afMouth);
    translate([0,0,-HSWX_LOCK_DEPTH/2])
        linear_extrude(HSWX_LOCK_DEPTH + 0.02, center=true) hsw_hex2d(afFull);
    translate([0,0,-HSWX_LOCK_DEPTH])
        linear_extrude(0.6, center=true) hsw_hex2d(afLip);
    backLen = depth - HSWX_LOCK_DEPTH;
    if (backLen > 0.1)
        translate([0,0,-(HSWX_LOCK_DEPTH + backLen/2)])
            linear_extrude(backLen + 0.4, center=true) hsw_hex2d(afFull);
}

module hsw_grid(nx = 3, ny = 3, depth = HSWX_DEPTH) {
    spanX = (nx-1)*HSW_PITCH_X;
    spanY = (ny-1)*HSW_PITCH_Y;
    slabW = spanX + HSWX_OUTSIDE;
    slabD = spanY + HSWX_OUTSIDE + hsw_max_stag(nx);
    difference() {
        translate([0, -hsw_max_stag(nx)/2, -depth/2]) cube([slabW, slabD, depth], center = true);
        for (c = [0 : nx-1])
            for (r = [0 : ny-1])
                translate([hsw_cx(c, nx), hsw_cy(c, r, nx, ny), 0]) hsw_hex_hole(depth);
    }
}

// ============================================================================
//  hsw_display() — canonical AnimBox display orientation. The geometry is built
//  in the OpenSCAD print frame (scad +Z = wall normal, +Y = up the wall). The
//  The OpenSCAD->AnimBox import is IDENTITY (verified by bbox: cube([10,20,40])
//  imports to world [10,20,40]). The wall-frame is already the display frame:
//  up-the-wall (+Y) = world UP, along-the-wall (+X) = world X, wall normal (+Z)
//  = toward the viewer (the body projects out of the wall). So hsw_display() is a
//  pass-through; it stays as the single place to adjust display orientation if the
//  import convention ever changes. Wrap every recipe's top call: hsw_display() my_part();
// ============================================================================
module hsw_display() { children(); }

// ---- product body (hidden internals) ----
eps   = 0.05;
PLATE = PLATE_T_DEFAULT;

module tool_cup_body() {
    cup_outer_d = cup_inner_d + 2 * cup_wall;
    cup_outer_r = cup_outer_d / 2;
    // the cup is a vertical tube (opens up +Y), lifted so it rests just off the plate
    translate([0, 0, PLATE + cup_outer_r]) {
        difference() {
            rotate([-90, 0, 0]) cylinder(h = cup_height, d = cup_outer_d);
            translate([0, cup_base_t, 0]) rotate([-90, 0, 0])
                cylinder(h = cup_height - cup_base_t + eps, d = cup_inner_d);
            if (drain)
                translate([0, -eps, 0]) rotate([-90, 0, 0])
                    cylinder(h = cup_base_t + 2 * eps, d = drain_d);
        }
    }
    // web welding the cup back to the plate face (one fused shell)
    web_w = cup_outer_d - 2;
    web_h = cup_height * 0.55;
    translate([-web_w / 2, 0, PLATE - HSW_WELD])
        cube([web_w, web_h, cup_outer_r + HSW_WELD]);
}
module tool_cup() {
    hsw_mount(connectors_x, connectors_y, type = connector_type, clearance = clearance,
              straight = (support_style == "grid"), crot = connector_rotation);
    tool_cup_body();
}
hsw_display() tool_cup();
`);

Open in editor →

HSW Drill-Bit Block

A block with a grid of graduated holes to organise drill bits, end mills, or small round tools by size. Swappable wall plugs.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// HSW Drill-Bit Block
//
// Source: honeycomb-wall drill-bit block
// Generated from the library above, used under its license.

/* [Wall mount] */
// How it attaches to the wall
connector_type = "peg";       // [peg:Friction peg (into wall), barepeg:Bare peg (into a latch), latch:Latch insert (into wall), clip:Spring clip (into wall)]
// Plug support style
support_style = "grid";       // [grid:Grid (aligned rows + columns), honeycomb:Honeycomb (staggered, denser)]
// Rotate the plug pattern (to match a wall mounted sideways)
connector_rotation = 0;       // [0:0 degrees, 90:90 degrees]
// Hex connectors across
connectors_x = 2;             // [1:8]
// Hex connector rows
connectors_y = 1;             // [1:4]
// Fit tweak: + looser / - tighter
clearance = 0;                // [-0.3:0.05:0.5]

/* [Block] */
// Holes across (X)
cols = 6;                     // [1:12]
// Hole rows (depth)
rows = 3;                     // [1:6]
// Smallest bore diameter (mm)
bore_min = 3;                 // [1:10]
// Largest bore diameter (mm)
bore_max = 9;                 // [2:16]
// Spacing between holes (mm)
pitch = 13;                   // [6:25]
// Bore depth (mm)
bore_depth = 22;             // [6:55]
// Solid base under the bores (mm)
base_t = 5;                  // [2:15]

// ============================================================================
//  HSW CONNECTOR TEMPLATE — the single canonical, self-contained connector kit
//  every HSW example inlines VERBATIM so plug spacing + sizing stay identical.
//  OpenSCAD 2021.01-safe. Self-contained: no include/use, no external libraries.
//
//  THE ONE RULE: plugs (hsw_mount) and wall holes (hsw_grid) are placed by the
//  SAME lattice functions hsw_cx()/hsw_cy(), so plug(c,r) == hole(c,r) for ANY
//  count by construction — verified 0.0000 mm deviation for 1..5 in each axis.
//
//  Frame: +Z = wall-normal (out of the wall). Connectors point into -Z (into the
//  wall); the back-plate front face sits at +Z = plate_t; accessory bodies build
//  on the +Z face. UP the wall = +Y, X = horizontal.
//
//  CUSTOMIZER: everything below is in the Hidden group so a product recipe that
//  inlines this template exposes ONLY its own dimensions + connectors_x/y +
//  connector_type + one clearance tweak. The HSW internals are NEVER customer-tunable.
// ============================================================================
/* [Hidden] */
$fn = 48;

// ---- Core hex interface (the 20mm hole a connector plugs into) -------------
HSWX_INSIDE       = 20;                              // hex hole flat-to-flat
HSWX_WALL         = 1.8;                             // shared cell wall thickness
HSWX_OUTSIDE      = HSWX_INSIDE + HSWX_WALL*2;       // 23.6  outside flat-to-flat
HSWX_SIDE         = HSWX_OUTSIDE / sqrt(3);          // ~13.6255 outer side length
HSWX_DEPTH        = 8;                               // panel / plug depth (Std Duty)
HSWX_LOCK_DEPTH   = 5;                               // depth where the lock step starts
HSWX_LOCK_LIP     = 1;                               // 1mm internal lip the barb catches
HSWX_LOCK_CHAMFER = HSWX_LOCK_LIP;                   // 1mm @ 45deg lead-in

// ---- Verified honeycomb lattice (flat-topped hexes, column tiling) ---------
HSW_PITCH_X       = 1.5 * HSWX_SIDE;                 // ~20.4382 column-to-column
HSW_PITCH_Y       = HSWX_OUTSIDE;                    // 23.6    row-to-row in a column
HSW_STAGGER_Y     = HSWX_OUTSIDE / 2;               // 11.8    alternate-column offset

// ---- Shared connector tunables ---------------------------------------------
PEG_FIT_DEFAULT   = 0.35;                            // bare-peg friction clearance
PEG_LEN_DEFAULT   = 7;                               // bare-peg depth into wall (< HSWX_DEPTH)
PLATE_T_DEFAULT   = 3;                               // back-plate thickness (welds depend on it)
HSW_WELD          = 0.6;                              // connector overlap INTO the plate (one fused solid)

// Across-flats -> circumscribed diameter (a $fn=6 cylinder lands on those flats).
// af/sqrt(3)*2 is IDENTICAL to af/cos(30); ONE form library-wide.
function hsw_af_to_d(af) = af / sqrt(3) * 2;

// ============================================================================
//  THE LATTICE — the single source of truth for WHERE connectors/holes go.
//  Bounding-box-centred on the origin for ANY nx/ny (incl. the single-column
//  case): the staggered odd columns only exist when nx>1, so the y-centring of
//  the cluster is conditional on nx>1. hsw_mount AND hsw_grid both call these.
// ============================================================================
function hsw_max_stag(nx) = (nx > 1) ? HSW_STAGGER_Y : 0;     // odd col only exists if nx>1
function hsw_cx(c, nx)    = c*HSW_PITCH_X - (nx-1)*HSW_PITCH_X/2;
function hsw_cy(c, r, nx, ny) =
    r*HSW_PITCH_Y
    - (ny-1)*HSW_PITCH_Y/2
    + ((c % 2 == 1) ? HSW_STAGGER_Y : 0)            // real alternate-column stagger
    - hsw_max_stag(nx)/2;                            // centre the cluster (cond. on nx>1)

// straight=true strip: every-OTHER column, no stagger (the legacy 40.88 strip).
// Use 2*HSW_PITCH_X (=40.8764), NEVER the rounded 40.88 literal.
function hsw_cx_straight(c, nx) = c*(2*HSW_PITCH_X) - (nx-1)*(2*HSW_PITCH_X)/2;

// ============================================================================
//  CONNECTOR 1 — hsw_peg : bare friction press-peg (the de-facto canonical peg).
//  $fn=6 hex prism, across-flats = HSWX_INSIDE - 2*fit, into -Z. Press fit only.
// ============================================================================
module hsw_peg(fit = PEG_FIT_DEFAULT, len = PEG_LEN_DEFAULT) {
    af = HSWX_INSIDE - 2*fit;                        // flat-to-flat, slightly under 20
    // hex prism from z=+HSW_WELD (buried INTO the plate) down to z=-len (into wall),
    // so the peg fuses with any plate occupying z>=0 into ONE solid (no coincident-face seam).
    translate([0, 0, -len])
        cylinder(h = len + HSW_WELD, d = hsw_af_to_d(af), $fn = 6);
}

// ============================================================================
//  CONNECTOR 1b — hsw_bare_peg : the THIN CORE peg (hex-plug-library hexagon_plug)
//  that plugs into a SEPARATE latch insert pre-snapped in the wall — NOT the grid
//  directly. Verbatim dims: 14.7 across-corners, 13 deep. Into -Z, welds the plate.
// ============================================================================
BAREPEG_D   = 14.7;     // across-corners ($fn=6) — source PLUG_HEXAGON_DIAMETER
BAREPEG_LEN = 13;       // source PLUG_LENGTH
module hsw_bare_peg(fit = 0) {
    translate([0, 0, -BAREPEG_LEN])
        cylinder(h = BAREPEG_LEN + HSW_WELD, d = BAREPEG_D - 2*fit, $fn = 6);
}

// ============================================================================
//  hsw_mount(nx, ny, type, plate_t, fit, straight)
//  ONE back-plate (front face +Z = plate_t) carrying an nx*ny connector lattice
//  on -Z, placed by hsw_cx/hsw_cy. type dispatches the per-cell connector.
// ============================================================================
// straight=true  -> GRID support  : pegs on an aligned rectangular grid
//                                    (40.8764 horiz x 23.6 vert, every-other
//                                    honeycomb column -> all land in real holes).
// straight=false -> HONEYCOMB support: pegs follow the staggered hex lattice
//                                    (20.4382 column pitch, odd columns staggered).
module hsw_mount(nx = 1, ny = 1, type = "peg", plate_t = PLATE_T_DEFAULT,
                 clearance = 0, straight = false, margin = 3, crot = 0) {
    // clamp counts so a user 0 (or negative) never yields an empty / garbage mount
    gnx = max(1, nx);
    gny = max(1, ny);
    // per-type base fit (peg=press 0.35, clip=snap 0.15, latch/barepeg=0 lip-tuned)
    // + the product's single user clearance tweak (+ looser / - tighter).
    pfit = (type == "clip" ? CLIP_FIT_DEFAULT
          : (type == "latch" || type == "barepeg") ? 0
          : PEG_FIT_DEFAULT) + clearance;
    // plate footprint spans the lattice + margin. GRID has no stagger; only the
    // staggered honeycomb extends Y by the odd-column stagger.
    spanX = straight ? (gnx-1)*(2*HSW_PITCH_X) : (gnx-1)*HSW_PITCH_X;
    spanY = (gny-1)*HSW_PITCH_Y;
    w = spanX + HSWX_OUTSIDE + 2*margin;
    d = spanY + HSWX_OUTSIDE + (straight ? 0 : hsw_max_stag(gnx)) + 2*margin;
    // crot rotates the PLUG PATTERN (plate + connectors, together so plugs stay on
    // the plate) about the wall normal so the accessory can match a wall installed
    // rotated 90deg. The body is built separately by the recipe and is NOT rotated
    // (plug layout only — body fixed).
    rotate([0, 0, crot]) {
        translate([0, 0, plate_t/2]) cube([w, d, plate_t], center = true);   // plate
        for (c = [0 : gnx-1])
            for (r = [0 : gny-1]) {
                x = straight ? hsw_cx_straight(c, gnx) : hsw_cx(c, gnx);
                y = straight ? (r*HSW_PITCH_Y - spanY/2) : hsw_cy(c, r, gnx, gny);
                translate([x, y, 0]) hsw_connector(type, pfit);
            }
    }
}

// ============================================================================
//  CONNECTOR 2 — hsw_latch_insert : snap-tab latching insert (vanilla port of
//  hex-plug-library / hsw-custom-insert, sh1-verified). Built front-face(lip) at
//  z=0 with body in +Z, then flipped to -Z and welded into the plate.
// ============================================================================
INSERT_BODY_FLATS = 19.7;   INSERT_LIP_FLATS = 22.5;   INSERT_TOTAL_H = 10;
INSERT_LIP_H = 2.5;         INSERT_SNAP_H = 6.5;       INSERT_TAB_OUT = 0.5;
INSERT_TAB_LEN = 2;         INSERT_SLOT_LEN = 8;       INSERT_SLOT_W = 0.8;
INSERT_SLOT_SIDE = 1;       INSERT_SLOT_RAD = 8.25;

module _hsw_bevel_cut(diameter) {
    h = diameter/2;                                     // tan(45)==1
    difference() { cylinder(d = diameter*2, h = h); cylinder(d1 = diameter, d2 = 0, h = h); }
}
module _hsw_insert_body(fit) {
    bodyD = hsw_af_to_d(INSERT_BODY_FLATS - 2*fit);
    lipD  = hsw_af_to_d(INSERT_LIP_FLATS);
    difference() {
        union() {
            cylinder(d = bodyD, h = INSERT_TOTAL_H, $fn = 6);   // main plug
            cylinder(d = lipD,  h = INSERT_LIP_H,  $fn = 6);    // overhang lip
        }
        translate([0,0,INSERT_TOTAL_H - 0.35]) _hsw_bevel_cut(bodyD);   // soften top edge
    }
}
module hsw_latch_insert(fit = 0) {
    translate([0,0,HSW_WELD]) rotate([180,0,0])
    union() {
        // six snap tabs (non-degenerate tip r=0.2, tops kept below the bevel)
        for (i=[0:5]) rotate([0,0,i*60]) translate([0, INSERT_BODY_FLATS/2, 0])
            hull() {
                translate([0,0,INSERT_SNAP_H + INSERT_SLOT_SIDE + INSERT_TAB_OUT])
                    rotate([0,90,0]) cylinder(r = INSERT_TAB_OUT, h = INSERT_TAB_LEN, center=true, $fn=20);
                translate([0,0,INSERT_TOTAL_H - 0.6])
                    rotate([0,90,0]) cylinder(r = 0.2, h = INSERT_TAB_LEN, center=true, $fn=20);
            }
        // body with flex slots so each tab deflects on insertion
        difference() {
            _hsw_insert_body(fit);
            for (i=[0:5]) rotate([0,0,i*60]) {
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_SLOT_W, INSERT_TOTAL_H]);
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_TOTAL_H, INSERT_SLOT_SIDE]);
            }
        }
    }
}

// ============================================================================
//  CONNECTOR 3 — hsw_clip : spring snap clip (from hsw-lib-core, sh1-verified).
//  Two cantilever arms catch the 1mm lip at 5mm depth. Mouth at z=0 into -Z.
// ============================================================================
CLIP_FIT_DEFAULT = 0.15;
CLIP_AF  = HSWX_INSIDE;      // 20 plug across-flats target
CLIP_LEN = HSWX_DEPTH;       // 8  plug length into the wall
SPRING_WALL = 1.6;           // cantilever arm wall (>=1.4 to flex)
SPRING_SLOT = 2.2;           // central relief slot width
module hsw_clip(fit = CLIP_FIT_DEFAULT) {
    af = CLIP_AF - 2*fit;  L = CLIP_LEN;
    barb = HSWX_LOCK_LIP;  locz = HSWX_LOCK_DEPTH;  cham = HSWX_LOCK_CHAMFER;  halfX = af/2;
    translate([0,0,HSW_WELD])
    difference() {
        union() {
            translate([0,0,-L/2]) linear_extrude(height = L, center = true) hsw_hex2d(af);   // hex plug
            for (sx=[-1,1]) translate([sx*halfX,0,-locz]) rotate([90,0,0])                    // outward barbs
                linear_extrude(height = af*0.62, center = true)
                    polygon([[0,0],[sx*barb,0],[sx*barb,cham],[0,cham+barb]]);
            translate([0,0,0.6/2]) linear_extrude(height = 0.6, center = true) hsw_hex2d(af + 1.2);  // mouth flange
        }
        translate([0,0,-L/2-0.5]) cube([SPRING_SLOT, af+4, L+2-1.2], center = true);          // central relief slot
        for (sx=[-1,1]) translate([sx*(halfX-SPRING_WALL-0.3),0,-L/2-1]) cube([1.4, af*0.5, L], center=true);  // arm hollow
    }
}

// per-cell connector dispatch:
//   peg     = friction peg, jams the bare grid hole (one-part)
//   barepeg = thin core peg, plugs into a SEPARATE latch pre-snapped in the wall
//   latch   = snap-tab insert, snaps into the bare grid hole
//   clip    = spring clip, snaps into the bare grid hole
module hsw_connector(type = "peg", fit = PEG_FIT_DEFAULT) {
    if      (type == "latch")   hsw_latch_insert(fit);
    else if (type == "clip")    hsw_clip(fit);
    else if (type == "barepeg") hsw_bare_peg(fit);
    else                        hsw_peg(fit);
}

// ============================================================================
//  hsw_grid(nx, ny, depth) — the FEMALE wall panel. Holes placed by the SAME
//  hsw_cx/hsw_cy so a hsw_mount(nx,ny) co-registers EXACTLY (proof artifact).
//  Lipped hex socket: 20mm bore, 1mm catch lip at 5mm depth.
// ============================================================================
module hsw_hex2d(af) { rotate([0,0,90]) circle(r = af/sqrt(3), $fn = 6); }

module hsw_hex_hole(depth) {
    afMouth = HSWX_INSIDE + 2*HSWX_LOCK_CHAMFER;
    afFull  = HSWX_INSIDE;
    afLip   = HSWX_INSIDE - 2*HSWX_LOCK_LIP;
    translate([0,0,-HSWX_LOCK_CHAMFER/2 + 0.01])
        linear_extrude(HSWX_LOCK_CHAMFER + 0.02, center=true, scale = afFull/afMouth) hsw_hex2d(afMouth);
    translate([0,0,-HSWX_LOCK_DEPTH/2])
        linear_extrude(HSWX_LOCK_DEPTH + 0.02, center=true) hsw_hex2d(afFull);
    translate([0,0,-HSWX_LOCK_DEPTH])
        linear_extrude(0.6, center=true) hsw_hex2d(afLip);
    backLen = depth - HSWX_LOCK_DEPTH;
    if (backLen > 0.1)
        translate([0,0,-(HSWX_LOCK_DEPTH + backLen/2)])
            linear_extrude(backLen + 0.4, center=true) hsw_hex2d(afFull);
}

module hsw_grid(nx = 3, ny = 3, depth = HSWX_DEPTH) {
    spanX = (nx-1)*HSW_PITCH_X;
    spanY = (ny-1)*HSW_PITCH_Y;
    slabW = spanX + HSWX_OUTSIDE;
    slabD = spanY + HSWX_OUTSIDE + hsw_max_stag(nx);
    difference() {
        translate([0, -hsw_max_stag(nx)/2, -depth/2]) cube([slabW, slabD, depth], center = true);
        for (c = [0 : nx-1])
            for (r = [0 : ny-1])
                translate([hsw_cx(c, nx), hsw_cy(c, r, nx, ny), 0]) hsw_hex_hole(depth);
    }
}

// ============================================================================
//  hsw_display() — canonical AnimBox display orientation. The geometry is built
//  in the OpenSCAD print frame (scad +Z = wall normal, +Y = up the wall). The
//  The OpenSCAD->AnimBox import is IDENTITY (verified by bbox: cube([10,20,40])
//  imports to world [10,20,40]). The wall-frame is already the display frame:
//  up-the-wall (+Y) = world UP, along-the-wall (+X) = world X, wall normal (+Z)
//  = toward the viewer (the body projects out of the wall). So hsw_display() is a
//  pass-through; it stays as the single place to adjust display orientation if the
//  import convention ever changes. Wrap every recipe's top call: hsw_display() my_part();
// ============================================================================
module hsw_display() { children(); }

// ---- product body (hidden internals) ----
eps   = 0.05;
PLATE = PLATE_T_DEFAULT;

module drill_block() {
    spanx = (cols - 1) * pitch;
    spany = (rows - 1) * pitch;
    bw = spanx + bore_max + 8;        // X width
    bd = spany + bore_max + 8;        // Z depth out from wall
    bh = bore_depth + base_t;         // Y height
    z0 = PLATE - HSW_WELD;
    y0 = -bh / 2;                     // centre on the plate
    zc = PLATE + (bd - spany) / 2;    // front margin for the first row
    difference() {
        translate([-bw / 2, y0, z0]) cube([bw, bh, bd + HSW_WELD]);
        for (cx = [0 : cols - 1])
            for (cy = [0 : rows - 1]) {
                d = bore_min + (cols > 1 ? (bore_max - bore_min) * cx / (cols - 1) : 0);
                translate([-spanx / 2 + cx * pitch, y0 + bh + eps, zc + cy * pitch])
                    rotate([90, 0, 0]) cylinder(h = bore_depth, d = d);   // vertical bore, open top
            }
    }
}
module drill_bit_block() {
    hsw_mount(connectors_x, connectors_y, type = connector_type, clearance = clearance,
              straight = (support_style == "grid"), crot = connector_rotation);
    drill_block();
}
hsw_display() drill_bit_block();
`);

Open in editor →

HSW Shelf

A flat shelf with a raised front lip to stop things sliding off, plus an angled support gusset underneath. Swappable wall plugs.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// HSW Shelf
//
// Source: honeycomb-wall shelf
// Generated from the library above, used under its license.

/* [Wall mount] */
// How it attaches to the wall
connector_type = "peg";       // [peg:Friction peg (into wall), barepeg:Bare peg (into a latch), latch:Latch insert (into wall), clip:Spring clip (into wall)]
// Plug support style
support_style = "grid";       // [grid:Grid (aligned rows + columns), honeycomb:Honeycomb (staggered, denser)]
// Rotate the plug pattern (to match a wall mounted sideways)
connector_rotation = 0;       // [0:0 degrees, 90:90 degrees]
// Hex connectors across (a wide shelf wants 3+)
connectors_x = 3;             // [1:8]
// Hex connector rows
connectors_y = 2;             // [1:4]
// Fit tweak: + looser / - tighter
clearance = 0;                // [-0.3:0.05:0.5]

/* [Shelf] */
// Shelf width (mm)
shelf_width = 120;            // [40:250]
// Shelf depth out from the wall (mm)
shelf_depth = 45;             // [20:100]
// Shelf thickness (mm)
shelf_t = 4;                  // [2:10]
// Front lip height (mm)
lip_h = 9;                    // [0:25]
// Front lip thickness (mm)
lip_t = 3;                    // [2:6]
// Support gusset depth (mm)
gusset = 28;                  // [0:80]

// ============================================================================
//  HSW CONNECTOR TEMPLATE — the single canonical, self-contained connector kit
//  every HSW example inlines VERBATIM so plug spacing + sizing stay identical.
//  OpenSCAD 2021.01-safe. Self-contained: no include/use, no external libraries.
//
//  THE ONE RULE: plugs (hsw_mount) and wall holes (hsw_grid) are placed by the
//  SAME lattice functions hsw_cx()/hsw_cy(), so plug(c,r) == hole(c,r) for ANY
//  count by construction — verified 0.0000 mm deviation for 1..5 in each axis.
//
//  Frame: +Z = wall-normal (out of the wall). Connectors point into -Z (into the
//  wall); the back-plate front face sits at +Z = plate_t; accessory bodies build
//  on the +Z face. UP the wall = +Y, X = horizontal.
//
//  CUSTOMIZER: everything below is in the Hidden group so a product recipe that
//  inlines this template exposes ONLY its own dimensions + connectors_x/y +
//  connector_type + one clearance tweak. The HSW internals are NEVER customer-tunable.
// ============================================================================
/* [Hidden] */
$fn = 48;

// ---- Core hex interface (the 20mm hole a connector plugs into) -------------
HSWX_INSIDE       = 20;                              // hex hole flat-to-flat
HSWX_WALL         = 1.8;                             // shared cell wall thickness
HSWX_OUTSIDE      = HSWX_INSIDE + HSWX_WALL*2;       // 23.6  outside flat-to-flat
HSWX_SIDE         = HSWX_OUTSIDE / sqrt(3);          // ~13.6255 outer side length
HSWX_DEPTH        = 8;                               // panel / plug depth (Std Duty)
HSWX_LOCK_DEPTH   = 5;                               // depth where the lock step starts
HSWX_LOCK_LIP     = 1;                               // 1mm internal lip the barb catches
HSWX_LOCK_CHAMFER = HSWX_LOCK_LIP;                   // 1mm @ 45deg lead-in

// ---- Verified honeycomb lattice (flat-topped hexes, column tiling) ---------
HSW_PITCH_X       = 1.5 * HSWX_SIDE;                 // ~20.4382 column-to-column
HSW_PITCH_Y       = HSWX_OUTSIDE;                    // 23.6    row-to-row in a column
HSW_STAGGER_Y     = HSWX_OUTSIDE / 2;               // 11.8    alternate-column offset

// ---- Shared connector tunables ---------------------------------------------
PEG_FIT_DEFAULT   = 0.35;                            // bare-peg friction clearance
PEG_LEN_DEFAULT   = 7;                               // bare-peg depth into wall (< HSWX_DEPTH)
PLATE_T_DEFAULT   = 3;                               // back-plate thickness (welds depend on it)
HSW_WELD          = 0.6;                              // connector overlap INTO the plate (one fused solid)

// Across-flats -> circumscribed diameter (a $fn=6 cylinder lands on those flats).
// af/sqrt(3)*2 is IDENTICAL to af/cos(30); ONE form library-wide.
function hsw_af_to_d(af) = af / sqrt(3) * 2;

// ============================================================================
//  THE LATTICE — the single source of truth for WHERE connectors/holes go.
//  Bounding-box-centred on the origin for ANY nx/ny (incl. the single-column
//  case): the staggered odd columns only exist when nx>1, so the y-centring of
//  the cluster is conditional on nx>1. hsw_mount AND hsw_grid both call these.
// ============================================================================
function hsw_max_stag(nx) = (nx > 1) ? HSW_STAGGER_Y : 0;     // odd col only exists if nx>1
function hsw_cx(c, nx)    = c*HSW_PITCH_X - (nx-1)*HSW_PITCH_X/2;
function hsw_cy(c, r, nx, ny) =
    r*HSW_PITCH_Y
    - (ny-1)*HSW_PITCH_Y/2
    + ((c % 2 == 1) ? HSW_STAGGER_Y : 0)            // real alternate-column stagger
    - hsw_max_stag(nx)/2;                            // centre the cluster (cond. on nx>1)

// straight=true strip: every-OTHER column, no stagger (the legacy 40.88 strip).
// Use 2*HSW_PITCH_X (=40.8764), NEVER the rounded 40.88 literal.
function hsw_cx_straight(c, nx) = c*(2*HSW_PITCH_X) - (nx-1)*(2*HSW_PITCH_X)/2;

// ============================================================================
//  CONNECTOR 1 — hsw_peg : bare friction press-peg (the de-facto canonical peg).
//  $fn=6 hex prism, across-flats = HSWX_INSIDE - 2*fit, into -Z. Press fit only.
// ============================================================================
module hsw_peg(fit = PEG_FIT_DEFAULT, len = PEG_LEN_DEFAULT) {
    af = HSWX_INSIDE - 2*fit;                        // flat-to-flat, slightly under 20
    // hex prism from z=+HSW_WELD (buried INTO the plate) down to z=-len (into wall),
    // so the peg fuses with any plate occupying z>=0 into ONE solid (no coincident-face seam).
    translate([0, 0, -len])
        cylinder(h = len + HSW_WELD, d = hsw_af_to_d(af), $fn = 6);
}

// ============================================================================
//  CONNECTOR 1b — hsw_bare_peg : the THIN CORE peg (hex-plug-library hexagon_plug)
//  that plugs into a SEPARATE latch insert pre-snapped in the wall — NOT the grid
//  directly. Verbatim dims: 14.7 across-corners, 13 deep. Into -Z, welds the plate.
// ============================================================================
BAREPEG_D   = 14.7;     // across-corners ($fn=6) — source PLUG_HEXAGON_DIAMETER
BAREPEG_LEN = 13;       // source PLUG_LENGTH
module hsw_bare_peg(fit = 0) {
    translate([0, 0, -BAREPEG_LEN])
        cylinder(h = BAREPEG_LEN + HSW_WELD, d = BAREPEG_D - 2*fit, $fn = 6);
}

// ============================================================================
//  hsw_mount(nx, ny, type, plate_t, fit, straight)
//  ONE back-plate (front face +Z = plate_t) carrying an nx*ny connector lattice
//  on -Z, placed by hsw_cx/hsw_cy. type dispatches the per-cell connector.
// ============================================================================
// straight=true  -> GRID support  : pegs on an aligned rectangular grid
//                                    (40.8764 horiz x 23.6 vert, every-other
//                                    honeycomb column -> all land in real holes).
// straight=false -> HONEYCOMB support: pegs follow the staggered hex lattice
//                                    (20.4382 column pitch, odd columns staggered).
module hsw_mount(nx = 1, ny = 1, type = "peg", plate_t = PLATE_T_DEFAULT,
                 clearance = 0, straight = false, margin = 3, crot = 0) {
    // clamp counts so a user 0 (or negative) never yields an empty / garbage mount
    gnx = max(1, nx);
    gny = max(1, ny);
    // per-type base fit (peg=press 0.35, clip=snap 0.15, latch/barepeg=0 lip-tuned)
    // + the product's single user clearance tweak (+ looser / - tighter).
    pfit = (type == "clip" ? CLIP_FIT_DEFAULT
          : (type == "latch" || type == "barepeg") ? 0
          : PEG_FIT_DEFAULT) + clearance;
    // plate footprint spans the lattice + margin. GRID has no stagger; only the
    // staggered honeycomb extends Y by the odd-column stagger.
    spanX = straight ? (gnx-1)*(2*HSW_PITCH_X) : (gnx-1)*HSW_PITCH_X;
    spanY = (gny-1)*HSW_PITCH_Y;
    w = spanX + HSWX_OUTSIDE + 2*margin;
    d = spanY + HSWX_OUTSIDE + (straight ? 0 : hsw_max_stag(gnx)) + 2*margin;
    // crot rotates the PLUG PATTERN (plate + connectors, together so plugs stay on
    // the plate) about the wall normal so the accessory can match a wall installed
    // rotated 90deg. The body is built separately by the recipe and is NOT rotated
    // (plug layout only — body fixed).
    rotate([0, 0, crot]) {
        translate([0, 0, plate_t/2]) cube([w, d, plate_t], center = true);   // plate
        for (c = [0 : gnx-1])
            for (r = [0 : gny-1]) {
                x = straight ? hsw_cx_straight(c, gnx) : hsw_cx(c, gnx);
                y = straight ? (r*HSW_PITCH_Y - spanY/2) : hsw_cy(c, r, gnx, gny);
                translate([x, y, 0]) hsw_connector(type, pfit);
            }
    }
}

// ============================================================================
//  CONNECTOR 2 — hsw_latch_insert : snap-tab latching insert (vanilla port of
//  hex-plug-library / hsw-custom-insert, sh1-verified). Built front-face(lip) at
//  z=0 with body in +Z, then flipped to -Z and welded into the plate.
// ============================================================================
INSERT_BODY_FLATS = 19.7;   INSERT_LIP_FLATS = 22.5;   INSERT_TOTAL_H = 10;
INSERT_LIP_H = 2.5;         INSERT_SNAP_H = 6.5;       INSERT_TAB_OUT = 0.5;
INSERT_TAB_LEN = 2;         INSERT_SLOT_LEN = 8;       INSERT_SLOT_W = 0.8;
INSERT_SLOT_SIDE = 1;       INSERT_SLOT_RAD = 8.25;

module _hsw_bevel_cut(diameter) {
    h = diameter/2;                                     // tan(45)==1
    difference() { cylinder(d = diameter*2, h = h); cylinder(d1 = diameter, d2 = 0, h = h); }
}
module _hsw_insert_body(fit) {
    bodyD = hsw_af_to_d(INSERT_BODY_FLATS - 2*fit);
    lipD  = hsw_af_to_d(INSERT_LIP_FLATS);
    difference() {
        union() {
            cylinder(d = bodyD, h = INSERT_TOTAL_H, $fn = 6);   // main plug
            cylinder(d = lipD,  h = INSERT_LIP_H,  $fn = 6);    // overhang lip
        }
        translate([0,0,INSERT_TOTAL_H - 0.35]) _hsw_bevel_cut(bodyD);   // soften top edge
    }
}
module hsw_latch_insert(fit = 0) {
    translate([0,0,HSW_WELD]) rotate([180,0,0])
    union() {
        // six snap tabs (non-degenerate tip r=0.2, tops kept below the bevel)
        for (i=[0:5]) rotate([0,0,i*60]) translate([0, INSERT_BODY_FLATS/2, 0])
            hull() {
                translate([0,0,INSERT_SNAP_H + INSERT_SLOT_SIDE + INSERT_TAB_OUT])
                    rotate([0,90,0]) cylinder(r = INSERT_TAB_OUT, h = INSERT_TAB_LEN, center=true, $fn=20);
                translate([0,0,INSERT_TOTAL_H - 0.6])
                    rotate([0,90,0]) cylinder(r = 0.2, h = INSERT_TAB_LEN, center=true, $fn=20);
            }
        // body with flex slots so each tab deflects on insertion
        difference() {
            _hsw_insert_body(fit);
            for (i=[0:5]) rotate([0,0,i*60]) {
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_SLOT_W, INSERT_TOTAL_H]);
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_TOTAL_H, INSERT_SLOT_SIDE]);
            }
        }
    }
}

// ============================================================================
//  CONNECTOR 3 — hsw_clip : spring snap clip (from hsw-lib-core, sh1-verified).
//  Two cantilever arms catch the 1mm lip at 5mm depth. Mouth at z=0 into -Z.
// ============================================================================
CLIP_FIT_DEFAULT = 0.15;
CLIP_AF  = HSWX_INSIDE;      // 20 plug across-flats target
CLIP_LEN = HSWX_DEPTH;       // 8  plug length into the wall
SPRING_WALL = 1.6;           // cantilever arm wall (>=1.4 to flex)
SPRING_SLOT = 2.2;           // central relief slot width
module hsw_clip(fit = CLIP_FIT_DEFAULT) {
    af = CLIP_AF - 2*fit;  L = CLIP_LEN;
    barb = HSWX_LOCK_LIP;  locz = HSWX_LOCK_DEPTH;  cham = HSWX_LOCK_CHAMFER;  halfX = af/2;
    translate([0,0,HSW_WELD])
    difference() {
        union() {
            translate([0,0,-L/2]) linear_extrude(height = L, center = true) hsw_hex2d(af);   // hex plug
            for (sx=[-1,1]) translate([sx*halfX,0,-locz]) rotate([90,0,0])                    // outward barbs
                linear_extrude(height = af*0.62, center = true)
                    polygon([[0,0],[sx*barb,0],[sx*barb,cham],[0,cham+barb]]);
            translate([0,0,0.6/2]) linear_extrude(height = 0.6, center = true) hsw_hex2d(af + 1.2);  // mouth flange
        }
        translate([0,0,-L/2-0.5]) cube([SPRING_SLOT, af+4, L+2-1.2], center = true);          // central relief slot
        for (sx=[-1,1]) translate([sx*(halfX-SPRING_WALL-0.3),0,-L/2-1]) cube([1.4, af*0.5, L], center=true);  // arm hollow
    }
}

// per-cell connector dispatch:
//   peg     = friction peg, jams the bare grid hole (one-part)
//   barepeg = thin core peg, plugs into a SEPARATE latch pre-snapped in the wall
//   latch   = snap-tab insert, snaps into the bare grid hole
//   clip    = spring clip, snaps into the bare grid hole
module hsw_connector(type = "peg", fit = PEG_FIT_DEFAULT) {
    if      (type == "latch")   hsw_latch_insert(fit);
    else if (type == "clip")    hsw_clip(fit);
    else if (type == "barepeg") hsw_bare_peg(fit);
    else                        hsw_peg(fit);
}

// ============================================================================
//  hsw_grid(nx, ny, depth) — the FEMALE wall panel. Holes placed by the SAME
//  hsw_cx/hsw_cy so a hsw_mount(nx,ny) co-registers EXACTLY (proof artifact).
//  Lipped hex socket: 20mm bore, 1mm catch lip at 5mm depth.
// ============================================================================
module hsw_hex2d(af) { rotate([0,0,90]) circle(r = af/sqrt(3), $fn = 6); }

module hsw_hex_hole(depth) {
    afMouth = HSWX_INSIDE + 2*HSWX_LOCK_CHAMFER;
    afFull  = HSWX_INSIDE;
    afLip   = HSWX_INSIDE - 2*HSWX_LOCK_LIP;
    translate([0,0,-HSWX_LOCK_CHAMFER/2 + 0.01])
        linear_extrude(HSWX_LOCK_CHAMFER + 0.02, center=true, scale = afFull/afMouth) hsw_hex2d(afMouth);
    translate([0,0,-HSWX_LOCK_DEPTH/2])
        linear_extrude(HSWX_LOCK_DEPTH + 0.02, center=true) hsw_hex2d(afFull);
    translate([0,0,-HSWX_LOCK_DEPTH])
        linear_extrude(0.6, center=true) hsw_hex2d(afLip);
    backLen = depth - HSWX_LOCK_DEPTH;
    if (backLen > 0.1)
        translate([0,0,-(HSWX_LOCK_DEPTH + backLen/2)])
            linear_extrude(backLen + 0.4, center=true) hsw_hex2d(afFull);
}

module hsw_grid(nx = 3, ny = 3, depth = HSWX_DEPTH) {
    spanX = (nx-1)*HSW_PITCH_X;
    spanY = (ny-1)*HSW_PITCH_Y;
    slabW = spanX + HSWX_OUTSIDE;
    slabD = spanY + HSWX_OUTSIDE + hsw_max_stag(nx);
    difference() {
        translate([0, -hsw_max_stag(nx)/2, -depth/2]) cube([slabW, slabD, depth], center = true);
        for (c = [0 : nx-1])
            for (r = [0 : ny-1])
                translate([hsw_cx(c, nx), hsw_cy(c, r, nx, ny), 0]) hsw_hex_hole(depth);
    }
}

// ============================================================================
//  hsw_display() — canonical AnimBox display orientation. The geometry is built
//  in the OpenSCAD print frame (scad +Z = wall normal, +Y = up the wall). The
//  The OpenSCAD->AnimBox import is IDENTITY (verified by bbox: cube([10,20,40])
//  imports to world [10,20,40]). The wall-frame is already the display frame:
//  up-the-wall (+Y) = world UP, along-the-wall (+X) = world X, wall normal (+Z)
//  = toward the viewer (the body projects out of the wall). So hsw_display() is a
//  pass-through; it stays as the single place to adjust display orientation if the
//  import convention ever changes. Wrap every recipe's top call: hsw_display() my_part();
// ============================================================================
module hsw_display() { children(); }

// ---- product body (hidden internals) ----
PLATE = PLATE_T_DEFAULT;

module shelf_body() {
    z0 = PLATE - HSW_WELD;
    // flat deck: wide X, thin Y, deep +Z. Top surface at Y=0.
    translate([-shelf_width / 2, -shelf_t, z0])
        cube([shelf_width, shelf_t, shelf_depth + HSW_WELD]);
    // raised front lip at the far +Z edge
    if (lip_h > 0)
        translate([-shelf_width / 2, -shelf_t, PLATE + shelf_depth - lip_t])
            cube([shelf_width, shelf_t + lip_h, lip_t]);
    // angled support gusset under the deck (triangular prism spanning the width).
    // +0.5 in Y overlaps it into the deck so the union is one clean shell.
    if (gusset > 0)
        translate([shelf_width / 2, -shelf_t + 0.5, z0])
            rotate([0, -90, 0])
                linear_extrude(height = shelf_width)
                    polygon([[0, 0], [0, -gusset], [shelf_depth + HSW_WELD, 0]]);
}
module shelf() {
    hsw_mount(connectors_x, connectors_y, type = connector_type, clearance = clearance,
              straight = (support_style == "grid"), crot = connector_rotation);
    shelf_body();
}
hsw_display() shelf();
`);

Open in editor →

HSW Test-Tube / Marker Rack

A row of equal round bores to hold test tubes, markers, pens, or small bottles upright. Swappable wall plugs.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// HSW Test-Tube / Marker Rack
//
// Source: honeycomb-wall test-tube rack
// Generated from the library above, used under its license.

/* [Wall mount] */
// How it attaches to the wall
connector_type = "peg";       // [peg:Friction peg (into wall), barepeg:Bare peg (into a latch), latch:Latch insert (into wall), clip:Spring clip (into wall)]
// Plug support style
support_style = "grid";       // [grid:Grid (aligned rows + columns), honeycomb:Honeycomb (staggered, denser)]
// Rotate the plug pattern (to match a wall mounted sideways)
connector_rotation = 0;       // [0:0 degrees, 90:90 degrees]
// Hex connectors across (wider = more)
connectors_x = 3;             // [1:8]
// Hex connector rows
connectors_y = 1;             // [1:4]
// Fit tweak: + looser / - tighter
clearance = 0;                // [-0.3:0.05:0.5]

/* [Rack] */
// Number of bores
bores = 5;                    // [1:12]
// Bore diameter (mm)
bore_d = 18;                  // [6:40]
// Spacing between bores (mm)
spacing = 26;                 // [12:50]
// Bore depth (mm)
bore_depth = 30;             // [10:80]
// Solid base under the bores (mm)
base_t = 4;                  // [2:12]
// Wall thickness around bores (mm)
wall = 3;                    // [1.5:0.5:6]

// ============================================================================
//  HSW CONNECTOR TEMPLATE — the single canonical, self-contained connector kit
//  every HSW example inlines VERBATIM so plug spacing + sizing stay identical.
//  OpenSCAD 2021.01-safe. Self-contained: no include/use, no external libraries.
//
//  THE ONE RULE: plugs (hsw_mount) and wall holes (hsw_grid) are placed by the
//  SAME lattice functions hsw_cx()/hsw_cy(), so plug(c,r) == hole(c,r) for ANY
//  count by construction — verified 0.0000 mm deviation for 1..5 in each axis.
//
//  Frame: +Z = wall-normal (out of the wall). Connectors point into -Z (into the
//  wall); the back-plate front face sits at +Z = plate_t; accessory bodies build
//  on the +Z face. UP the wall = +Y, X = horizontal.
//
//  CUSTOMIZER: everything below is in the Hidden group so a product recipe that
//  inlines this template exposes ONLY its own dimensions + connectors_x/y +
//  connector_type + one clearance tweak. The HSW internals are NEVER customer-tunable.
// ============================================================================
/* [Hidden] */
$fn = 48;

// ---- Core hex interface (the 20mm hole a connector plugs into) -------------
HSWX_INSIDE       = 20;                              // hex hole flat-to-flat
HSWX_WALL         = 1.8;                             // shared cell wall thickness
HSWX_OUTSIDE      = HSWX_INSIDE + HSWX_WALL*2;       // 23.6  outside flat-to-flat
HSWX_SIDE         = HSWX_OUTSIDE / sqrt(3);          // ~13.6255 outer side length
HSWX_DEPTH        = 8;                               // panel / plug depth (Std Duty)
HSWX_LOCK_DEPTH   = 5;                               // depth where the lock step starts
HSWX_LOCK_LIP     = 1;                               // 1mm internal lip the barb catches
HSWX_LOCK_CHAMFER = HSWX_LOCK_LIP;                   // 1mm @ 45deg lead-in

// ---- Verified honeycomb lattice (flat-topped hexes, column tiling) ---------
HSW_PITCH_X       = 1.5 * HSWX_SIDE;                 // ~20.4382 column-to-column
HSW_PITCH_Y       = HSWX_OUTSIDE;                    // 23.6    row-to-row in a column
HSW_STAGGER_Y     = HSWX_OUTSIDE / 2;               // 11.8    alternate-column offset

// ---- Shared connector tunables ---------------------------------------------
PEG_FIT_DEFAULT   = 0.35;                            // bare-peg friction clearance
PEG_LEN_DEFAULT   = 7;                               // bare-peg depth into wall (< HSWX_DEPTH)
PLATE_T_DEFAULT   = 3;                               // back-plate thickness (welds depend on it)
HSW_WELD          = 0.6;                              // connector overlap INTO the plate (one fused solid)

// Across-flats -> circumscribed diameter (a $fn=6 cylinder lands on those flats).
// af/sqrt(3)*2 is IDENTICAL to af/cos(30); ONE form library-wide.
function hsw_af_to_d(af) = af / sqrt(3) * 2;

// ============================================================================
//  THE LATTICE — the single source of truth for WHERE connectors/holes go.
//  Bounding-box-centred on the origin for ANY nx/ny (incl. the single-column
//  case): the staggered odd columns only exist when nx>1, so the y-centring of
//  the cluster is conditional on nx>1. hsw_mount AND hsw_grid both call these.
// ============================================================================
function hsw_max_stag(nx) = (nx > 1) ? HSW_STAGGER_Y : 0;     // odd col only exists if nx>1
function hsw_cx(c, nx)    = c*HSW_PITCH_X - (nx-1)*HSW_PITCH_X/2;
function hsw_cy(c, r, nx, ny) =
    r*HSW_PITCH_Y
    - (ny-1)*HSW_PITCH_Y/2
    + ((c % 2 == 1) ? HSW_STAGGER_Y : 0)            // real alternate-column stagger
    - hsw_max_stag(nx)/2;                            // centre the cluster (cond. on nx>1)

// straight=true strip: every-OTHER column, no stagger (the legacy 40.88 strip).
// Use 2*HSW_PITCH_X (=40.8764), NEVER the rounded 40.88 literal.
function hsw_cx_straight(c, nx) = c*(2*HSW_PITCH_X) - (nx-1)*(2*HSW_PITCH_X)/2;

// ============================================================================
//  CONNECTOR 1 — hsw_peg : bare friction press-peg (the de-facto canonical peg).
//  $fn=6 hex prism, across-flats = HSWX_INSIDE - 2*fit, into -Z. Press fit only.
// ============================================================================
module hsw_peg(fit = PEG_FIT_DEFAULT, len = PEG_LEN_DEFAULT) {
    af = HSWX_INSIDE - 2*fit;                        // flat-to-flat, slightly under 20
    // hex prism from z=+HSW_WELD (buried INTO the plate) down to z=-len (into wall),
    // so the peg fuses with any plate occupying z>=0 into ONE solid (no coincident-face seam).
    translate([0, 0, -len])
        cylinder(h = len + HSW_WELD, d = hsw_af_to_d(af), $fn = 6);
}

// ============================================================================
//  CONNECTOR 1b — hsw_bare_peg : the THIN CORE peg (hex-plug-library hexagon_plug)
//  that plugs into a SEPARATE latch insert pre-snapped in the wall — NOT the grid
//  directly. Verbatim dims: 14.7 across-corners, 13 deep. Into -Z, welds the plate.
// ============================================================================
BAREPEG_D   = 14.7;     // across-corners ($fn=6) — source PLUG_HEXAGON_DIAMETER
BAREPEG_LEN = 13;       // source PLUG_LENGTH
module hsw_bare_peg(fit = 0) {
    translate([0, 0, -BAREPEG_LEN])
        cylinder(h = BAREPEG_LEN + HSW_WELD, d = BAREPEG_D - 2*fit, $fn = 6);
}

// ============================================================================
//  hsw_mount(nx, ny, type, plate_t, fit, straight)
//  ONE back-plate (front face +Z = plate_t) carrying an nx*ny connector lattice
//  on -Z, placed by hsw_cx/hsw_cy. type dispatches the per-cell connector.
// ============================================================================
// straight=true  -> GRID support  : pegs on an aligned rectangular grid
//                                    (40.8764 horiz x 23.6 vert, every-other
//                                    honeycomb column -> all land in real holes).
// straight=false -> HONEYCOMB support: pegs follow the staggered hex lattice
//                                    (20.4382 column pitch, odd columns staggered).
module hsw_mount(nx = 1, ny = 1, type = "peg", plate_t = PLATE_T_DEFAULT,
                 clearance = 0, straight = false, margin = 3, crot = 0) {
    // clamp counts so a user 0 (or negative) never yields an empty / garbage mount
    gnx = max(1, nx);
    gny = max(1, ny);
    // per-type base fit (peg=press 0.35, clip=snap 0.15, latch/barepeg=0 lip-tuned)
    // + the product's single user clearance tweak (+ looser / - tighter).
    pfit = (type == "clip" ? CLIP_FIT_DEFAULT
          : (type == "latch" || type == "barepeg") ? 0
          : PEG_FIT_DEFAULT) + clearance;
    // plate footprint spans the lattice + margin. GRID has no stagger; only the
    // staggered honeycomb extends Y by the odd-column stagger.
    spanX = straight ? (gnx-1)*(2*HSW_PITCH_X) : (gnx-1)*HSW_PITCH_X;
    spanY = (gny-1)*HSW_PITCH_Y;
    w = spanX + HSWX_OUTSIDE + 2*margin;
    d = spanY + HSWX_OUTSIDE + (straight ? 0 : hsw_max_stag(gnx)) + 2*margin;
    // crot rotates the PLUG PATTERN (plate + connectors, together so plugs stay on
    // the plate) about the wall normal so the accessory can match a wall installed
    // rotated 90deg. The body is built separately by the recipe and is NOT rotated
    // (plug layout only — body fixed).
    rotate([0, 0, crot]) {
        translate([0, 0, plate_t/2]) cube([w, d, plate_t], center = true);   // plate
        for (c = [0 : gnx-1])
            for (r = [0 : gny-1]) {
                x = straight ? hsw_cx_straight(c, gnx) : hsw_cx(c, gnx);
                y = straight ? (r*HSW_PITCH_Y - spanY/2) : hsw_cy(c, r, gnx, gny);
                translate([x, y, 0]) hsw_connector(type, pfit);
            }
    }
}

// ============================================================================
//  CONNECTOR 2 — hsw_latch_insert : snap-tab latching insert (vanilla port of
//  hex-plug-library / hsw-custom-insert, sh1-verified). Built front-face(lip) at
//  z=0 with body in +Z, then flipped to -Z and welded into the plate.
// ============================================================================
INSERT_BODY_FLATS = 19.7;   INSERT_LIP_FLATS = 22.5;   INSERT_TOTAL_H = 10;
INSERT_LIP_H = 2.5;         INSERT_SNAP_H = 6.5;       INSERT_TAB_OUT = 0.5;
INSERT_TAB_LEN = 2;         INSERT_SLOT_LEN = 8;       INSERT_SLOT_W = 0.8;
INSERT_SLOT_SIDE = 1;       INSERT_SLOT_RAD = 8.25;

module _hsw_bevel_cut(diameter) {
    h = diameter/2;                                     // tan(45)==1
    difference() { cylinder(d = diameter*2, h = h); cylinder(d1 = diameter, d2 = 0, h = h); }
}
module _hsw_insert_body(fit) {
    bodyD = hsw_af_to_d(INSERT_BODY_FLATS - 2*fit);
    lipD  = hsw_af_to_d(INSERT_LIP_FLATS);
    difference() {
        union() {
            cylinder(d = bodyD, h = INSERT_TOTAL_H, $fn = 6);   // main plug
            cylinder(d = lipD,  h = INSERT_LIP_H,  $fn = 6);    // overhang lip
        }
        translate([0,0,INSERT_TOTAL_H - 0.35]) _hsw_bevel_cut(bodyD);   // soften top edge
    }
}
module hsw_latch_insert(fit = 0) {
    translate([0,0,HSW_WELD]) rotate([180,0,0])
    union() {
        // six snap tabs (non-degenerate tip r=0.2, tops kept below the bevel)
        for (i=[0:5]) rotate([0,0,i*60]) translate([0, INSERT_BODY_FLATS/2, 0])
            hull() {
                translate([0,0,INSERT_SNAP_H + INSERT_SLOT_SIDE + INSERT_TAB_OUT])
                    rotate([0,90,0]) cylinder(r = INSERT_TAB_OUT, h = INSERT_TAB_LEN, center=true, $fn=20);
                translate([0,0,INSERT_TOTAL_H - 0.6])
                    rotate([0,90,0]) cylinder(r = 0.2, h = INSERT_TAB_LEN, center=true, $fn=20);
            }
        // body with flex slots so each tab deflects on insertion
        difference() {
            _hsw_insert_body(fit);
            for (i=[0:5]) rotate([0,0,i*60]) {
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_SLOT_W, INSERT_TOTAL_H]);
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_TOTAL_H, INSERT_SLOT_SIDE]);
            }
        }
    }
}

// ============================================================================
//  CONNECTOR 3 — hsw_clip : spring snap clip (from hsw-lib-core, sh1-verified).
//  Two cantilever arms catch the 1mm lip at 5mm depth. Mouth at z=0 into -Z.
// ============================================================================
CLIP_FIT_DEFAULT = 0.15;
CLIP_AF  = HSWX_INSIDE;      // 20 plug across-flats target
CLIP_LEN = HSWX_DEPTH;       // 8  plug length into the wall
SPRING_WALL = 1.6;           // cantilever arm wall (>=1.4 to flex)
SPRING_SLOT = 2.2;           // central relief slot width
module hsw_clip(fit = CLIP_FIT_DEFAULT) {
    af = CLIP_AF - 2*fit;  L = CLIP_LEN;
    barb = HSWX_LOCK_LIP;  locz = HSWX_LOCK_DEPTH;  cham = HSWX_LOCK_CHAMFER;  halfX = af/2;
    translate([0,0,HSW_WELD])
    difference() {
        union() {
            translate([0,0,-L/2]) linear_extrude(height = L, center = true) hsw_hex2d(af);   // hex plug
            for (sx=[-1,1]) translate([sx*halfX,0,-locz]) rotate([90,0,0])                    // outward barbs
                linear_extrude(height = af*0.62, center = true)
                    polygon([[0,0],[sx*barb,0],[sx*barb,cham],[0,cham+barb]]);
            translate([0,0,0.6/2]) linear_extrude(height = 0.6, center = true) hsw_hex2d(af + 1.2);  // mouth flange
        }
        translate([0,0,-L/2-0.5]) cube([SPRING_SLOT, af+4, L+2-1.2], center = true);          // central relief slot
        for (sx=[-1,1]) translate([sx*(halfX-SPRING_WALL-0.3),0,-L/2-1]) cube([1.4, af*0.5, L], center=true);  // arm hollow
    }
}

// per-cell connector dispatch:
//   peg     = friction peg, jams the bare grid hole (one-part)
//   barepeg = thin core peg, plugs into a SEPARATE latch pre-snapped in the wall
//   latch   = snap-tab insert, snaps into the bare grid hole
//   clip    = spring clip, snaps into the bare grid hole
module hsw_connector(type = "peg", fit = PEG_FIT_DEFAULT) {
    if      (type == "latch")   hsw_latch_insert(fit);
    else if (type == "clip")    hsw_clip(fit);
    else if (type == "barepeg") hsw_bare_peg(fit);
    else                        hsw_peg(fit);
}

// ============================================================================
//  hsw_grid(nx, ny, depth) — the FEMALE wall panel. Holes placed by the SAME
//  hsw_cx/hsw_cy so a hsw_mount(nx,ny) co-registers EXACTLY (proof artifact).
//  Lipped hex socket: 20mm bore, 1mm catch lip at 5mm depth.
// ============================================================================
module hsw_hex2d(af) { rotate([0,0,90]) circle(r = af/sqrt(3), $fn = 6); }

module hsw_hex_hole(depth) {
    afMouth = HSWX_INSIDE + 2*HSWX_LOCK_CHAMFER;
    afFull  = HSWX_INSIDE;
    afLip   = HSWX_INSIDE - 2*HSWX_LOCK_LIP;
    translate([0,0,-HSWX_LOCK_CHAMFER/2 + 0.01])
        linear_extrude(HSWX_LOCK_CHAMFER + 0.02, center=true, scale = afFull/afMouth) hsw_hex2d(afMouth);
    translate([0,0,-HSWX_LOCK_DEPTH/2])
        linear_extrude(HSWX_LOCK_DEPTH + 0.02, center=true) hsw_hex2d(afFull);
    translate([0,0,-HSWX_LOCK_DEPTH])
        linear_extrude(0.6, center=true) hsw_hex2d(afLip);
    backLen = depth - HSWX_LOCK_DEPTH;
    if (backLen > 0.1)
        translate([0,0,-(HSWX_LOCK_DEPTH + backLen/2)])
            linear_extrude(backLen + 0.4, center=true) hsw_hex2d(afFull);
}

module hsw_grid(nx = 3, ny = 3, depth = HSWX_DEPTH) {
    spanX = (nx-1)*HSW_PITCH_X;
    spanY = (ny-1)*HSW_PITCH_Y;
    slabW = spanX + HSWX_OUTSIDE;
    slabD = spanY + HSWX_OUTSIDE + hsw_max_stag(nx);
    difference() {
        translate([0, -hsw_max_stag(nx)/2, -depth/2]) cube([slabW, slabD, depth], center = true);
        for (c = [0 : nx-1])
            for (r = [0 : ny-1])
                translate([hsw_cx(c, nx), hsw_cy(c, r, nx, ny), 0]) hsw_hex_hole(depth);
    }
}

// ============================================================================
//  hsw_display() — canonical AnimBox display orientation. The geometry is built
//  in the OpenSCAD print frame (scad +Z = wall normal, +Y = up the wall). The
//  The OpenSCAD->AnimBox import is IDENTITY (verified by bbox: cube([10,20,40])
//  imports to world [10,20,40]). The wall-frame is already the display frame:
//  up-the-wall (+Y) = world UP, along-the-wall (+X) = world X, wall normal (+Z)
//  = toward the viewer (the body projects out of the wall). So hsw_display() is a
//  pass-through; it stays as the single place to adjust display orientation if the
//  import convention ever changes. Wrap every recipe's top call: hsw_display() my_part();
// ============================================================================
module hsw_display() { children(); }

// ---- product body (hidden internals) ----
eps   = 0.05;
PLATE = PLATE_T_DEFAULT;

module tube_rack() {
    span = (bores - 1) * spacing;
    bw = span + bore_d + 2 * wall;
    bd = bore_d + 2 * wall;           // Z depth out from wall
    bh = bore_depth + base_t;         // Y height
    z0 = PLATE - HSW_WELD;
    y0 = -bh / 2;
    difference() {
        translate([-bw / 2, y0, z0]) cube([bw, bh, bd + HSW_WELD]);
        for (i = [0 : bores - 1])
            translate([-span / 2 + i * spacing, y0 + bh + eps, PLATE + bd / 2])
                rotate([90, 0, 0]) cylinder(h = bore_depth, d = bore_d);   // vertical bore, open top
    }
}
module test_tube_rack() {
    hsw_mount(connectors_x, connectors_y, type = connector_type, clearance = clearance,
              straight = (support_style == "grid"), crot = connector_rotation);
    tube_rack();
}
hsw_display() test_tube_rack();
`);

Open in editor →

HSW Cable Hook

A wide-throat hook for coiled cables, extension leads, lanyards, or straps — the broad rounded curve is gentle on cable jackets. Swappable wall plugs.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// HSW Cable Hook
//
// Source: honeycomb-wall cable hook
// Generated from the library above, used under its license.

/* [Wall mount] */
// How it attaches to the wall
connector_type = "peg";       // [peg:Friction peg (into wall), barepeg:Bare peg (into a latch), latch:Latch insert (into wall), clip:Spring clip (into wall)]
// Plug support style
support_style = "grid";       // [grid:Grid (aligned rows + columns), honeycomb:Honeycomb (staggered, denser)]
// Rotate the plug pattern (to match a wall mounted sideways)
connector_rotation = 0;       // [0:0 degrees, 90:90 degrees]
// Hex connectors across
connectors_x = 1;             // [1:8]
// Hex connector rows (2 = strong cantilever)
connectors_y = 2;             // [1:4]
// Fit tweak: + looser / - tighter
clearance = 0;                // [-0.3:0.05:0.5]

/* [Hook] */
// Hook rod radius (mm)
rod_r = 6;                    // [3:0.5:12]
// How far the hook reaches out (mm)
reach = 30;                   // [15:80]
// Throat opening height (mm)
throat = 26;                  // [12:60]
// Upturned tip rise (mm)
rise = 12;                    // [4:30]

// ============================================================================
//  HSW CONNECTOR TEMPLATE — the single canonical, self-contained connector kit
//  every HSW example inlines VERBATIM so plug spacing + sizing stay identical.
//  OpenSCAD 2021.01-safe. Self-contained: no include/use, no external libraries.
//
//  THE ONE RULE: plugs (hsw_mount) and wall holes (hsw_grid) are placed by the
//  SAME lattice functions hsw_cx()/hsw_cy(), so plug(c,r) == hole(c,r) for ANY
//  count by construction — verified 0.0000 mm deviation for 1..5 in each axis.
//
//  Frame: +Z = wall-normal (out of the wall). Connectors point into -Z (into the
//  wall); the back-plate front face sits at +Z = plate_t; accessory bodies build
//  on the +Z face. UP the wall = +Y, X = horizontal.
//
//  CUSTOMIZER: everything below is in the Hidden group so a product recipe that
//  inlines this template exposes ONLY its own dimensions + connectors_x/y +
//  connector_type + one clearance tweak. The HSW internals are NEVER customer-tunable.
// ============================================================================
/* [Hidden] */
$fn = 48;

// ---- Core hex interface (the 20mm hole a connector plugs into) -------------
HSWX_INSIDE       = 20;                              // hex hole flat-to-flat
HSWX_WALL         = 1.8;                             // shared cell wall thickness
HSWX_OUTSIDE      = HSWX_INSIDE + HSWX_WALL*2;       // 23.6  outside flat-to-flat
HSWX_SIDE         = HSWX_OUTSIDE / sqrt(3);          // ~13.6255 outer side length
HSWX_DEPTH        = 8;                               // panel / plug depth (Std Duty)
HSWX_LOCK_DEPTH   = 5;                               // depth where the lock step starts
HSWX_LOCK_LIP     = 1;                               // 1mm internal lip the barb catches
HSWX_LOCK_CHAMFER = HSWX_LOCK_LIP;                   // 1mm @ 45deg lead-in

// ---- Verified honeycomb lattice (flat-topped hexes, column tiling) ---------
HSW_PITCH_X       = 1.5 * HSWX_SIDE;                 // ~20.4382 column-to-column
HSW_PITCH_Y       = HSWX_OUTSIDE;                    // 23.6    row-to-row in a column
HSW_STAGGER_Y     = HSWX_OUTSIDE / 2;               // 11.8    alternate-column offset

// ---- Shared connector tunables ---------------------------------------------
PEG_FIT_DEFAULT   = 0.35;                            // bare-peg friction clearance
PEG_LEN_DEFAULT   = 7;                               // bare-peg depth into wall (< HSWX_DEPTH)
PLATE_T_DEFAULT   = 3;                               // back-plate thickness (welds depend on it)
HSW_WELD          = 0.6;                              // connector overlap INTO the plate (one fused solid)

// Across-flats -> circumscribed diameter (a $fn=6 cylinder lands on those flats).
// af/sqrt(3)*2 is IDENTICAL to af/cos(30); ONE form library-wide.
function hsw_af_to_d(af) = af / sqrt(3) * 2;

// ============================================================================
//  THE LATTICE — the single source of truth for WHERE connectors/holes go.
//  Bounding-box-centred on the origin for ANY nx/ny (incl. the single-column
//  case): the staggered odd columns only exist when nx>1, so the y-centring of
//  the cluster is conditional on nx>1. hsw_mount AND hsw_grid both call these.
// ============================================================================
function hsw_max_stag(nx) = (nx > 1) ? HSW_STAGGER_Y : 0;     // odd col only exists if nx>1
function hsw_cx(c, nx)    = c*HSW_PITCH_X - (nx-1)*HSW_PITCH_X/2;
function hsw_cy(c, r, nx, ny) =
    r*HSW_PITCH_Y
    - (ny-1)*HSW_PITCH_Y/2
    + ((c % 2 == 1) ? HSW_STAGGER_Y : 0)            // real alternate-column stagger
    - hsw_max_stag(nx)/2;                            // centre the cluster (cond. on nx>1)

// straight=true strip: every-OTHER column, no stagger (the legacy 40.88 strip).
// Use 2*HSW_PITCH_X (=40.8764), NEVER the rounded 40.88 literal.
function hsw_cx_straight(c, nx) = c*(2*HSW_PITCH_X) - (nx-1)*(2*HSW_PITCH_X)/2;

// ============================================================================
//  CONNECTOR 1 — hsw_peg : bare friction press-peg (the de-facto canonical peg).
//  $fn=6 hex prism, across-flats = HSWX_INSIDE - 2*fit, into -Z. Press fit only.
// ============================================================================
module hsw_peg(fit = PEG_FIT_DEFAULT, len = PEG_LEN_DEFAULT) {
    af = HSWX_INSIDE - 2*fit;                        // flat-to-flat, slightly under 20
    // hex prism from z=+HSW_WELD (buried INTO the plate) down to z=-len (into wall),
    // so the peg fuses with any plate occupying z>=0 into ONE solid (no coincident-face seam).
    translate([0, 0, -len])
        cylinder(h = len + HSW_WELD, d = hsw_af_to_d(af), $fn = 6);
}

// ============================================================================
//  CONNECTOR 1b — hsw_bare_peg : the THIN CORE peg (hex-plug-library hexagon_plug)
//  that plugs into a SEPARATE latch insert pre-snapped in the wall — NOT the grid
//  directly. Verbatim dims: 14.7 across-corners, 13 deep. Into -Z, welds the plate.
// ============================================================================
BAREPEG_D   = 14.7;     // across-corners ($fn=6) — source PLUG_HEXAGON_DIAMETER
BAREPEG_LEN = 13;       // source PLUG_LENGTH
module hsw_bare_peg(fit = 0) {
    translate([0, 0, -BAREPEG_LEN])
        cylinder(h = BAREPEG_LEN + HSW_WELD, d = BAREPEG_D - 2*fit, $fn = 6);
}

// ============================================================================
//  hsw_mount(nx, ny, type, plate_t, fit, straight)
//  ONE back-plate (front face +Z = plate_t) carrying an nx*ny connector lattice
//  on -Z, placed by hsw_cx/hsw_cy. type dispatches the per-cell connector.
// ============================================================================
// straight=true  -> GRID support  : pegs on an aligned rectangular grid
//                                    (40.8764 horiz x 23.6 vert, every-other
//                                    honeycomb column -> all land in real holes).
// straight=false -> HONEYCOMB support: pegs follow the staggered hex lattice
//                                    (20.4382 column pitch, odd columns staggered).
module hsw_mount(nx = 1, ny = 1, type = "peg", plate_t = PLATE_T_DEFAULT,
                 clearance = 0, straight = false, margin = 3, crot = 0) {
    // clamp counts so a user 0 (or negative) never yields an empty / garbage mount
    gnx = max(1, nx);
    gny = max(1, ny);
    // per-type base fit (peg=press 0.35, clip=snap 0.15, latch/barepeg=0 lip-tuned)
    // + the product's single user clearance tweak (+ looser / - tighter).
    pfit = (type == "clip" ? CLIP_FIT_DEFAULT
          : (type == "latch" || type == "barepeg") ? 0
          : PEG_FIT_DEFAULT) + clearance;
    // plate footprint spans the lattice + margin. GRID has no stagger; only the
    // staggered honeycomb extends Y by the odd-column stagger.
    spanX = straight ? (gnx-1)*(2*HSW_PITCH_X) : (gnx-1)*HSW_PITCH_X;
    spanY = (gny-1)*HSW_PITCH_Y;
    w = spanX + HSWX_OUTSIDE + 2*margin;
    d = spanY + HSWX_OUTSIDE + (straight ? 0 : hsw_max_stag(gnx)) + 2*margin;
    // crot rotates the PLUG PATTERN (plate + connectors, together so plugs stay on
    // the plate) about the wall normal so the accessory can match a wall installed
    // rotated 90deg. The body is built separately by the recipe and is NOT rotated
    // (plug layout only — body fixed).
    rotate([0, 0, crot]) {
        translate([0, 0, plate_t/2]) cube([w, d, plate_t], center = true);   // plate
        for (c = [0 : gnx-1])
            for (r = [0 : gny-1]) {
                x = straight ? hsw_cx_straight(c, gnx) : hsw_cx(c, gnx);
                y = straight ? (r*HSW_PITCH_Y - spanY/2) : hsw_cy(c, r, gnx, gny);
                translate([x, y, 0]) hsw_connector(type, pfit);
            }
    }
}

// ============================================================================
//  CONNECTOR 2 — hsw_latch_insert : snap-tab latching insert (vanilla port of
//  hex-plug-library / hsw-custom-insert, sh1-verified). Built front-face(lip) at
//  z=0 with body in +Z, then flipped to -Z and welded into the plate.
// ============================================================================
INSERT_BODY_FLATS = 19.7;   INSERT_LIP_FLATS = 22.5;   INSERT_TOTAL_H = 10;
INSERT_LIP_H = 2.5;         INSERT_SNAP_H = 6.5;       INSERT_TAB_OUT = 0.5;
INSERT_TAB_LEN = 2;         INSERT_SLOT_LEN = 8;       INSERT_SLOT_W = 0.8;
INSERT_SLOT_SIDE = 1;       INSERT_SLOT_RAD = 8.25;

module _hsw_bevel_cut(diameter) {
    h = diameter/2;                                     // tan(45)==1
    difference() { cylinder(d = diameter*2, h = h); cylinder(d1 = diameter, d2 = 0, h = h); }
}
module _hsw_insert_body(fit) {
    bodyD = hsw_af_to_d(INSERT_BODY_FLATS - 2*fit);
    lipD  = hsw_af_to_d(INSERT_LIP_FLATS);
    difference() {
        union() {
            cylinder(d = bodyD, h = INSERT_TOTAL_H, $fn = 6);   // main plug
            cylinder(d = lipD,  h = INSERT_LIP_H,  $fn = 6);    // overhang lip
        }
        translate([0,0,INSERT_TOTAL_H - 0.35]) _hsw_bevel_cut(bodyD);   // soften top edge
    }
}
module hsw_latch_insert(fit = 0) {
    translate([0,0,HSW_WELD]) rotate([180,0,0])
    union() {
        // six snap tabs (non-degenerate tip r=0.2, tops kept below the bevel)
        for (i=[0:5]) rotate([0,0,i*60]) translate([0, INSERT_BODY_FLATS/2, 0])
            hull() {
                translate([0,0,INSERT_SNAP_H + INSERT_SLOT_SIDE + INSERT_TAB_OUT])
                    rotate([0,90,0]) cylinder(r = INSERT_TAB_OUT, h = INSERT_TAB_LEN, center=true, $fn=20);
                translate([0,0,INSERT_TOTAL_H - 0.6])
                    rotate([0,90,0]) cylinder(r = 0.2, h = INSERT_TAB_LEN, center=true, $fn=20);
            }
        // body with flex slots so each tab deflects on insertion
        difference() {
            _hsw_insert_body(fit);
            for (i=[0:5]) rotate([0,0,i*60]) {
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_SLOT_W, INSERT_TOTAL_H]);
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_TOTAL_H, INSERT_SLOT_SIDE]);
            }
        }
    }
}

// ============================================================================
//  CONNECTOR 3 — hsw_clip : spring snap clip (from hsw-lib-core, sh1-verified).
//  Two cantilever arms catch the 1mm lip at 5mm depth. Mouth at z=0 into -Z.
// ============================================================================
CLIP_FIT_DEFAULT = 0.15;
CLIP_AF  = HSWX_INSIDE;      // 20 plug across-flats target
CLIP_LEN = HSWX_DEPTH;       // 8  plug length into the wall
SPRING_WALL = 1.6;           // cantilever arm wall (>=1.4 to flex)
SPRING_SLOT = 2.2;           // central relief slot width
module hsw_clip(fit = CLIP_FIT_DEFAULT) {
    af = CLIP_AF - 2*fit;  L = CLIP_LEN;
    barb = HSWX_LOCK_LIP;  locz = HSWX_LOCK_DEPTH;  cham = HSWX_LOCK_CHAMFER;  halfX = af/2;
    translate([0,0,HSW_WELD])
    difference() {
        union() {
            translate([0,0,-L/2]) linear_extrude(height = L, center = true) hsw_hex2d(af);   // hex plug
            for (sx=[-1,1]) translate([sx*halfX,0,-locz]) rotate([90,0,0])                    // outward barbs
                linear_extrude(height = af*0.62, center = true)
                    polygon([[0,0],[sx*barb,0],[sx*barb,cham],[0,cham+barb]]);
            translate([0,0,0.6/2]) linear_extrude(height = 0.6, center = true) hsw_hex2d(af + 1.2);  // mouth flange
        }
        translate([0,0,-L/2-0.5]) cube([SPRING_SLOT, af+4, L+2-1.2], center = true);          // central relief slot
        for (sx=[-1,1]) translate([sx*(halfX-SPRING_WALL-0.3),0,-L/2-1]) cube([1.4, af*0.5, L], center=true);  // arm hollow
    }
}

// per-cell connector dispatch:
//   peg     = friction peg, jams the bare grid hole (one-part)
//   barepeg = thin core peg, plugs into a SEPARATE latch pre-snapped in the wall
//   latch   = snap-tab insert, snaps into the bare grid hole
//   clip    = spring clip, snaps into the bare grid hole
module hsw_connector(type = "peg", fit = PEG_FIT_DEFAULT) {
    if      (type == "latch")   hsw_latch_insert(fit);
    else if (type == "clip")    hsw_clip(fit);
    else if (type == "barepeg") hsw_bare_peg(fit);
    else                        hsw_peg(fit);
}

// ============================================================================
//  hsw_grid(nx, ny, depth) — the FEMALE wall panel. Holes placed by the SAME
//  hsw_cx/hsw_cy so a hsw_mount(nx,ny) co-registers EXACTLY (proof artifact).
//  Lipped hex socket: 20mm bore, 1mm catch lip at 5mm depth.
// ============================================================================
module hsw_hex2d(af) { rotate([0,0,90]) circle(r = af/sqrt(3), $fn = 6); }

module hsw_hex_hole(depth) {
    afMouth = HSWX_INSIDE + 2*HSWX_LOCK_CHAMFER;
    afFull  = HSWX_INSIDE;
    afLip   = HSWX_INSIDE - 2*HSWX_LOCK_LIP;
    translate([0,0,-HSWX_LOCK_CHAMFER/2 + 0.01])
        linear_extrude(HSWX_LOCK_CHAMFER + 0.02, center=true, scale = afFull/afMouth) hsw_hex2d(afMouth);
    translate([0,0,-HSWX_LOCK_DEPTH/2])
        linear_extrude(HSWX_LOCK_DEPTH + 0.02, center=true) hsw_hex2d(afFull);
    translate([0,0,-HSWX_LOCK_DEPTH])
        linear_extrude(0.6, center=true) hsw_hex2d(afLip);
    backLen = depth - HSWX_LOCK_DEPTH;
    if (backLen > 0.1)
        translate([0,0,-(HSWX_LOCK_DEPTH + backLen/2)])
            linear_extrude(backLen + 0.4, center=true) hsw_hex2d(afFull);
}

module hsw_grid(nx = 3, ny = 3, depth = HSWX_DEPTH) {
    spanX = (nx-1)*HSW_PITCH_X;
    spanY = (ny-1)*HSW_PITCH_Y;
    slabW = spanX + HSWX_OUTSIDE;
    slabD = spanY + HSWX_OUTSIDE + hsw_max_stag(nx);
    difference() {
        translate([0, -hsw_max_stag(nx)/2, -depth/2]) cube([slabW, slabD, depth], center = true);
        for (c = [0 : nx-1])
            for (r = [0 : ny-1])
                translate([hsw_cx(c, nx), hsw_cy(c, r, nx, ny), 0]) hsw_hex_hole(depth);
    }
}

// ============================================================================
//  hsw_display() — canonical AnimBox display orientation. The geometry is built
//  in the OpenSCAD print frame (scad +Z = wall normal, +Y = up the wall). The
//  The OpenSCAD->AnimBox import is IDENTITY (verified by bbox: cube([10,20,40])
//  imports to world [10,20,40]). The wall-frame is already the display frame:
//  up-the-wall (+Y) = world UP, along-the-wall (+X) = world X, wall normal (+Z)
//  = toward the viewer (the body projects out of the wall). So hsw_display() is a
//  pass-through; it stays as the single place to adjust display orientation if the
//  import convention ever changes. Wrap every recipe's top call: hsw_display() my_part();
// ============================================================================
module hsw_display() { children(); }

// ---- product body (hidden internals) ----
PLATE = PLATE_T_DEFAULT;

module hook_path() {
    // wide gentle throat: out, sweep down to the throat bottom, finish with an upturn
    yb = -throat;                                  // throat bottom depth
    pts = [
        [0, 0,        PLATE - HSW_WELD],           // embedded in the plate
        [0, 0,        PLATE + 5],                  // out from the wall
        [0, yb * 0.4, PLATE + reach * 0.55],       // descend
        [0, yb,       PLATE + reach * 0.88],       // throat bottom
        [0, yb,       PLATE + reach],              // along the bottom
        [0, yb + rise, PLATE + reach - 2]          // upturned tip (retains the cable)
    ];
    for (i = [0 : len(pts) - 2])
        hull() {
            translate(pts[i])     sphere(r = rod_r, $fn = 28);
            translate(pts[i + 1]) sphere(r = rod_r, $fn = 28);
        }
}
module cable_hook() {
    hsw_mount(connectors_x, connectors_y, type = connector_type, clearance = clearance,
              straight = (support_style == "grid"), crot = connector_rotation);
    hook_path();
}
hsw_display() cable_hook();
`);

Open in editor →

HSW Divided Tray

A shallow tray split into a grid of compartments for sorting screws, beads, SMD parts, or findings. Choose the number of columns and rows. Swappable wall plugs.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// HSW Divided Tray
//
// Source: honeycomb-wall divided sorting tray
// Generated from the library above, used under its license.

/* [Wall mount] */
// How it attaches to the wall
connector_type = "peg";       // [peg:Friction peg (into wall), barepeg:Bare peg (into a latch), latch:Latch insert (into wall), clip:Spring clip (into wall)]
// Plug support style
support_style = "grid";       // [grid:Grid (aligned rows + columns), honeycomb:Honeycomb (staggered, denser)]
// Rotate the plug pattern (to match a wall mounted sideways)
connector_rotation = 0;       // [0:0 degrees, 90:90 degrees]
// Hex connectors across (a wide tray wants 3+)
connectors_x = 3;             // [1:8]
// Hex connector rows
connectors_y = 2;             // [1:4]
// Fit tweak: + looser / - tighter
clearance = 0;                // [-0.3:0.05:0.5]

/* [Tray] */
// Inside width (mm)
tray_width = 130;             // [40:250]
// Inside depth out from the wall (mm)
tray_depth = 55;              // [25:120]
// Inside height (mm)
tray_height = 28;             // [12:80]
// Compartment columns
cols = 4;                     // [1:10]
// Compartment rows
rows = 2;                     // [1:6]
// Outer wall thickness (mm)
wall = 2.4;                   // [1.2:0.2:4]
// Divider thickness (mm)
divider_t = 1.6;             // [1:0.2:3]
// Floor thickness (mm)
floor_t = 2.4;               // [1.2:0.2:5]

// ============================================================================
//  HSW CONNECTOR TEMPLATE — the single canonical, self-contained connector kit
//  every HSW example inlines VERBATIM so plug spacing + sizing stay identical.
//  OpenSCAD 2021.01-safe. Self-contained: no include/use, no external libraries.
//
//  THE ONE RULE: plugs (hsw_mount) and wall holes (hsw_grid) are placed by the
//  SAME lattice functions hsw_cx()/hsw_cy(), so plug(c,r) == hole(c,r) for ANY
//  count by construction — verified 0.0000 mm deviation for 1..5 in each axis.
//
//  Frame: +Z = wall-normal (out of the wall). Connectors point into -Z (into the
//  wall); the back-plate front face sits at +Z = plate_t; accessory bodies build
//  on the +Z face. UP the wall = +Y, X = horizontal.
//
//  CUSTOMIZER: everything below is in the Hidden group so a product recipe that
//  inlines this template exposes ONLY its own dimensions + connectors_x/y +
//  connector_type + one clearance tweak. The HSW internals are NEVER customer-tunable.
// ============================================================================
/* [Hidden] */
$fn = 48;

// ---- Core hex interface (the 20mm hole a connector plugs into) -------------
HSWX_INSIDE       = 20;                              // hex hole flat-to-flat
HSWX_WALL         = 1.8;                             // shared cell wall thickness
HSWX_OUTSIDE      = HSWX_INSIDE + HSWX_WALL*2;       // 23.6  outside flat-to-flat
HSWX_SIDE         = HSWX_OUTSIDE / sqrt(3);          // ~13.6255 outer side length
HSWX_DEPTH        = 8;                               // panel / plug depth (Std Duty)
HSWX_LOCK_DEPTH   = 5;                               // depth where the lock step starts
HSWX_LOCK_LIP     = 1;                               // 1mm internal lip the barb catches
HSWX_LOCK_CHAMFER = HSWX_LOCK_LIP;                   // 1mm @ 45deg lead-in

// ---- Verified honeycomb lattice (flat-topped hexes, column tiling) ---------
HSW_PITCH_X       = 1.5 * HSWX_SIDE;                 // ~20.4382 column-to-column
HSW_PITCH_Y       = HSWX_OUTSIDE;                    // 23.6    row-to-row in a column
HSW_STAGGER_Y     = HSWX_OUTSIDE / 2;               // 11.8    alternate-column offset

// ---- Shared connector tunables ---------------------------------------------
PEG_FIT_DEFAULT   = 0.35;                            // bare-peg friction clearance
PEG_LEN_DEFAULT   = 7;                               // bare-peg depth into wall (< HSWX_DEPTH)
PLATE_T_DEFAULT   = 3;                               // back-plate thickness (welds depend on it)
HSW_WELD          = 0.6;                              // connector overlap INTO the plate (one fused solid)

// Across-flats -> circumscribed diameter (a $fn=6 cylinder lands on those flats).
// af/sqrt(3)*2 is IDENTICAL to af/cos(30); ONE form library-wide.
function hsw_af_to_d(af) = af / sqrt(3) * 2;

// ============================================================================
//  THE LATTICE — the single source of truth for WHERE connectors/holes go.
//  Bounding-box-centred on the origin for ANY nx/ny (incl. the single-column
//  case): the staggered odd columns only exist when nx>1, so the y-centring of
//  the cluster is conditional on nx>1. hsw_mount AND hsw_grid both call these.
// ============================================================================
function hsw_max_stag(nx) = (nx > 1) ? HSW_STAGGER_Y : 0;     // odd col only exists if nx>1
function hsw_cx(c, nx)    = c*HSW_PITCH_X - (nx-1)*HSW_PITCH_X/2;
function hsw_cy(c, r, nx, ny) =
    r*HSW_PITCH_Y
    - (ny-1)*HSW_PITCH_Y/2
    + ((c % 2 == 1) ? HSW_STAGGER_Y : 0)            // real alternate-column stagger
    - hsw_max_stag(nx)/2;                            // centre the cluster (cond. on nx>1)

// straight=true strip: every-OTHER column, no stagger (the legacy 40.88 strip).
// Use 2*HSW_PITCH_X (=40.8764), NEVER the rounded 40.88 literal.
function hsw_cx_straight(c, nx) = c*(2*HSW_PITCH_X) - (nx-1)*(2*HSW_PITCH_X)/2;

// ============================================================================
//  CONNECTOR 1 — hsw_peg : bare friction press-peg (the de-facto canonical peg).
//  $fn=6 hex prism, across-flats = HSWX_INSIDE - 2*fit, into -Z. Press fit only.
// ============================================================================
module hsw_peg(fit = PEG_FIT_DEFAULT, len = PEG_LEN_DEFAULT) {
    af = HSWX_INSIDE - 2*fit;                        // flat-to-flat, slightly under 20
    // hex prism from z=+HSW_WELD (buried INTO the plate) down to z=-len (into wall),
    // so the peg fuses with any plate occupying z>=0 into ONE solid (no coincident-face seam).
    translate([0, 0, -len])
        cylinder(h = len + HSW_WELD, d = hsw_af_to_d(af), $fn = 6);
}

// ============================================================================
//  CONNECTOR 1b — hsw_bare_peg : the THIN CORE peg (hex-plug-library hexagon_plug)
//  that plugs into a SEPARATE latch insert pre-snapped in the wall — NOT the grid
//  directly. Verbatim dims: 14.7 across-corners, 13 deep. Into -Z, welds the plate.
// ============================================================================
BAREPEG_D   = 14.7;     // across-corners ($fn=6) — source PLUG_HEXAGON_DIAMETER
BAREPEG_LEN = 13;       // source PLUG_LENGTH
module hsw_bare_peg(fit = 0) {
    translate([0, 0, -BAREPEG_LEN])
        cylinder(h = BAREPEG_LEN + HSW_WELD, d = BAREPEG_D - 2*fit, $fn = 6);
}

// ============================================================================
//  hsw_mount(nx, ny, type, plate_t, fit, straight)
//  ONE back-plate (front face +Z = plate_t) carrying an nx*ny connector lattice
//  on -Z, placed by hsw_cx/hsw_cy. type dispatches the per-cell connector.
// ============================================================================
// straight=true  -> GRID support  : pegs on an aligned rectangular grid
//                                    (40.8764 horiz x 23.6 vert, every-other
//                                    honeycomb column -> all land in real holes).
// straight=false -> HONEYCOMB support: pegs follow the staggered hex lattice
//                                    (20.4382 column pitch, odd columns staggered).
module hsw_mount(nx = 1, ny = 1, type = "peg", plate_t = PLATE_T_DEFAULT,
                 clearance = 0, straight = false, margin = 3, crot = 0) {
    // clamp counts so a user 0 (or negative) never yields an empty / garbage mount
    gnx = max(1, nx);
    gny = max(1, ny);
    // per-type base fit (peg=press 0.35, clip=snap 0.15, latch/barepeg=0 lip-tuned)
    // + the product's single user clearance tweak (+ looser / - tighter).
    pfit = (type == "clip" ? CLIP_FIT_DEFAULT
          : (type == "latch" || type == "barepeg") ? 0
          : PEG_FIT_DEFAULT) + clearance;
    // plate footprint spans the lattice + margin. GRID has no stagger; only the
    // staggered honeycomb extends Y by the odd-column stagger.
    spanX = straight ? (gnx-1)*(2*HSW_PITCH_X) : (gnx-1)*HSW_PITCH_X;
    spanY = (gny-1)*HSW_PITCH_Y;
    w = spanX + HSWX_OUTSIDE + 2*margin;
    d = spanY + HSWX_OUTSIDE + (straight ? 0 : hsw_max_stag(gnx)) + 2*margin;
    // crot rotates the PLUG PATTERN (plate + connectors, together so plugs stay on
    // the plate) about the wall normal so the accessory can match a wall installed
    // rotated 90deg. The body is built separately by the recipe and is NOT rotated
    // (plug layout only — body fixed).
    rotate([0, 0, crot]) {
        translate([0, 0, plate_t/2]) cube([w, d, plate_t], center = true);   // plate
        for (c = [0 : gnx-1])
            for (r = [0 : gny-1]) {
                x = straight ? hsw_cx_straight(c, gnx) : hsw_cx(c, gnx);
                y = straight ? (r*HSW_PITCH_Y - spanY/2) : hsw_cy(c, r, gnx, gny);
                translate([x, y, 0]) hsw_connector(type, pfit);
            }
    }
}

// ============================================================================
//  CONNECTOR 2 — hsw_latch_insert : snap-tab latching insert (vanilla port of
//  hex-plug-library / hsw-custom-insert, sh1-verified). Built front-face(lip) at
//  z=0 with body in +Z, then flipped to -Z and welded into the plate.
// ============================================================================
INSERT_BODY_FLATS = 19.7;   INSERT_LIP_FLATS = 22.5;   INSERT_TOTAL_H = 10;
INSERT_LIP_H = 2.5;         INSERT_SNAP_H = 6.5;       INSERT_TAB_OUT = 0.5;
INSERT_TAB_LEN = 2;         INSERT_SLOT_LEN = 8;       INSERT_SLOT_W = 0.8;
INSERT_SLOT_SIDE = 1;       INSERT_SLOT_RAD = 8.25;

module _hsw_bevel_cut(diameter) {
    h = diameter/2;                                     // tan(45)==1
    difference() { cylinder(d = diameter*2, h = h); cylinder(d1 = diameter, d2 = 0, h = h); }
}
module _hsw_insert_body(fit) {
    bodyD = hsw_af_to_d(INSERT_BODY_FLATS - 2*fit);
    lipD  = hsw_af_to_d(INSERT_LIP_FLATS);
    difference() {
        union() {
            cylinder(d = bodyD, h = INSERT_TOTAL_H, $fn = 6);   // main plug
            cylinder(d = lipD,  h = INSERT_LIP_H,  $fn = 6);    // overhang lip
        }
        translate([0,0,INSERT_TOTAL_H - 0.35]) _hsw_bevel_cut(bodyD);   // soften top edge
    }
}
module hsw_latch_insert(fit = 0) {
    translate([0,0,HSW_WELD]) rotate([180,0,0])
    union() {
        // six snap tabs (non-degenerate tip r=0.2, tops kept below the bevel)
        for (i=[0:5]) rotate([0,0,i*60]) translate([0, INSERT_BODY_FLATS/2, 0])
            hull() {
                translate([0,0,INSERT_SNAP_H + INSERT_SLOT_SIDE + INSERT_TAB_OUT])
                    rotate([0,90,0]) cylinder(r = INSERT_TAB_OUT, h = INSERT_TAB_LEN, center=true, $fn=20);
                translate([0,0,INSERT_TOTAL_H - 0.6])
                    rotate([0,90,0]) cylinder(r = 0.2, h = INSERT_TAB_LEN, center=true, $fn=20);
            }
        // body with flex slots so each tab deflects on insertion
        difference() {
            _hsw_insert_body(fit);
            for (i=[0:5]) rotate([0,0,i*60]) {
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_SLOT_W, INSERT_TOTAL_H]);
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_TOTAL_H, INSERT_SLOT_SIDE]);
            }
        }
    }
}

// ============================================================================
//  CONNECTOR 3 — hsw_clip : spring snap clip (from hsw-lib-core, sh1-verified).
//  Two cantilever arms catch the 1mm lip at 5mm depth. Mouth at z=0 into -Z.
// ============================================================================
CLIP_FIT_DEFAULT = 0.15;
CLIP_AF  = HSWX_INSIDE;      // 20 plug across-flats target
CLIP_LEN = HSWX_DEPTH;       // 8  plug length into the wall
SPRING_WALL = 1.6;           // cantilever arm wall (>=1.4 to flex)
SPRING_SLOT = 2.2;           // central relief slot width
module hsw_clip(fit = CLIP_FIT_DEFAULT) {
    af = CLIP_AF - 2*fit;  L = CLIP_LEN;
    barb = HSWX_LOCK_LIP;  locz = HSWX_LOCK_DEPTH;  cham = HSWX_LOCK_CHAMFER;  halfX = af/2;
    translate([0,0,HSW_WELD])
    difference() {
        union() {
            translate([0,0,-L/2]) linear_extrude(height = L, center = true) hsw_hex2d(af);   // hex plug
            for (sx=[-1,1]) translate([sx*halfX,0,-locz]) rotate([90,0,0])                    // outward barbs
                linear_extrude(height = af*0.62, center = true)
                    polygon([[0,0],[sx*barb,0],[sx*barb,cham],[0,cham+barb]]);
            translate([0,0,0.6/2]) linear_extrude(height = 0.6, center = true) hsw_hex2d(af + 1.2);  // mouth flange
        }
        translate([0,0,-L/2-0.5]) cube([SPRING_SLOT, af+4, L+2-1.2], center = true);          // central relief slot
        for (sx=[-1,1]) translate([sx*(halfX-SPRING_WALL-0.3),0,-L/2-1]) cube([1.4, af*0.5, L], center=true);  // arm hollow
    }
}

// per-cell connector dispatch:
//   peg     = friction peg, jams the bare grid hole (one-part)
//   barepeg = thin core peg, plugs into a SEPARATE latch pre-snapped in the wall
//   latch   = snap-tab insert, snaps into the bare grid hole
//   clip    = spring clip, snaps into the bare grid hole
module hsw_connector(type = "peg", fit = PEG_FIT_DEFAULT) {
    if      (type == "latch")   hsw_latch_insert(fit);
    else if (type == "clip")    hsw_clip(fit);
    else if (type == "barepeg") hsw_bare_peg(fit);
    else                        hsw_peg(fit);
}

// ============================================================================
//  hsw_grid(nx, ny, depth) — the FEMALE wall panel. Holes placed by the SAME
//  hsw_cx/hsw_cy so a hsw_mount(nx,ny) co-registers EXACTLY (proof artifact).
//  Lipped hex socket: 20mm bore, 1mm catch lip at 5mm depth.
// ============================================================================
module hsw_hex2d(af) { rotate([0,0,90]) circle(r = af/sqrt(3), $fn = 6); }

module hsw_hex_hole(depth) {
    afMouth = HSWX_INSIDE + 2*HSWX_LOCK_CHAMFER;
    afFull  = HSWX_INSIDE;
    afLip   = HSWX_INSIDE - 2*HSWX_LOCK_LIP;
    translate([0,0,-HSWX_LOCK_CHAMFER/2 + 0.01])
        linear_extrude(HSWX_LOCK_CHAMFER + 0.02, center=true, scale = afFull/afMouth) hsw_hex2d(afMouth);
    translate([0,0,-HSWX_LOCK_DEPTH/2])
        linear_extrude(HSWX_LOCK_DEPTH + 0.02, center=true) hsw_hex2d(afFull);
    translate([0,0,-HSWX_LOCK_DEPTH])
        linear_extrude(0.6, center=true) hsw_hex2d(afLip);
    backLen = depth - HSWX_LOCK_DEPTH;
    if (backLen > 0.1)
        translate([0,0,-(HSWX_LOCK_DEPTH + backLen/2)])
            linear_extrude(backLen + 0.4, center=true) hsw_hex2d(afFull);
}

module hsw_grid(nx = 3, ny = 3, depth = HSWX_DEPTH) {
    spanX = (nx-1)*HSW_PITCH_X;
    spanY = (ny-1)*HSW_PITCH_Y;
    slabW = spanX + HSWX_OUTSIDE;
    slabD = spanY + HSWX_OUTSIDE + hsw_max_stag(nx);
    difference() {
        translate([0, -hsw_max_stag(nx)/2, -depth/2]) cube([slabW, slabD, depth], center = true);
        for (c = [0 : nx-1])
            for (r = [0 : ny-1])
                translate([hsw_cx(c, nx), hsw_cy(c, r, nx, ny), 0]) hsw_hex_hole(depth);
    }
}

// ============================================================================
//  hsw_display() — canonical AnimBox display orientation. The geometry is built
//  in the OpenSCAD print frame (scad +Z = wall normal, +Y = up the wall). The
//  The OpenSCAD->AnimBox import is IDENTITY (verified by bbox: cube([10,20,40])
//  imports to world [10,20,40]). The wall-frame is already the display frame:
//  up-the-wall (+Y) = world UP, along-the-wall (+X) = world X, wall normal (+Z)
//  = toward the viewer (the body projects out of the wall). So hsw_display() is a
//  pass-through; it stays as the single place to adjust display orientation if the
//  import convention ever changes. Wrap every recipe's top call: hsw_display() my_part();
// ============================================================================
module hsw_display() { children(); }

// ---- product body (hidden internals) ----
eps   = 0.05;
PLATE = PLATE_T_DEFAULT;

module divided_tray() {
    ow = tray_width + 2 * wall;
    od = tray_depth + 2 * wall;
    oh = tray_height + floor_t;
    z0 = PLATE - HSW_WELD;
    y0 = -oh / 2;
    difference() {
        translate([-ow / 2, y0, z0]) cube([ow, oh, od + HSW_WELD]);
        // hollow the inside (open top)
        translate([-tray_width / 2, y0 + floor_t, PLATE + wall])
            cube([tray_width, tray_height + eps, tray_depth + eps]);
    }
    // dividers (thin walls) rising from the floor, welded to the side walls
    for (c = [1 : cols - 1])
        translate([-tray_width / 2 + c * tray_width / cols - divider_t / 2, y0 + floor_t - eps, PLATE + wall])
            cube([divider_t, tray_height, tray_depth]);
    for (r = [1 : rows - 1])
        translate([-tray_width / 2, y0 + floor_t - eps, PLATE + wall + r * tray_depth / rows - divider_t / 2])
            cube([tray_width, tray_height, divider_t]);
}
module divided_tray_part() {
    hsw_mount(connectors_x, connectors_y, type = connector_type, clearance = clearance,
              straight = (support_style == "grid"), crot = connector_rotation);
    divided_tray();
}
hsw_display() divided_tray_part();
`);

Open in editor →

HSW Hex-Key Holder

A slim block with a row of slots that hold Allen / hex keys (or small flat tools) upright and sorted by size. Swappable wall plugs.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// HSW Hex-Key Holder
//
// Source: honeycomb-wall hex key holder
// Generated from the library above, used under its license.

/* [Wall mount] */
// How it attaches to the wall
connector_type = "peg";       // [peg:Friction peg (into wall), barepeg:Bare peg (into a latch), latch:Latch insert (into wall), clip:Spring clip (into wall)]
// Plug support style
support_style = "grid";       // [grid:Grid (aligned rows + columns), honeycomb:Honeycomb (staggered, denser)]
// Rotate the plug pattern (to match a wall mounted sideways)
connector_rotation = 0;       // [0:0 degrees, 90:90 degrees]
// Hex connectors across
connectors_x = 2;             // [1:8]
// Hex connector rows
connectors_y = 1;             // [1:4]
// Fit tweak: + looser / - tighter
clearance = 0;                // [-0.3:0.05:0.5]

/* [Holder] */
// Number of slots
slots = 8;                    // [1:16]
// Slot width (mm)
slot_w = 3;                   // [1.5:0.5:8]
// Slot length across the block (mm)
slot_len = 14;               // [6:30]
// Spacing between slots (mm)
spacing = 8;                 // [5:20]
// Slot depth down into the block (mm)
slot_depth = 16;             // [6:40]
// Solid base under the slots (mm)
base_t = 5;                  // [2:14]

// ============================================================================
//  HSW CONNECTOR TEMPLATE — the single canonical, self-contained connector kit
//  every HSW example inlines VERBATIM so plug spacing + sizing stay identical.
//  OpenSCAD 2021.01-safe. Self-contained: no include/use, no external libraries.
//
//  THE ONE RULE: plugs (hsw_mount) and wall holes (hsw_grid) are placed by the
//  SAME lattice functions hsw_cx()/hsw_cy(), so plug(c,r) == hole(c,r) for ANY
//  count by construction — verified 0.0000 mm deviation for 1..5 in each axis.
//
//  Frame: +Z = wall-normal (out of the wall). Connectors point into -Z (into the
//  wall); the back-plate front face sits at +Z = plate_t; accessory bodies build
//  on the +Z face. UP the wall = +Y, X = horizontal.
//
//  CUSTOMIZER: everything below is in the Hidden group so a product recipe that
//  inlines this template exposes ONLY its own dimensions + connectors_x/y +
//  connector_type + one clearance tweak. The HSW internals are NEVER customer-tunable.
// ============================================================================
/* [Hidden] */
$fn = 48;

// ---- Core hex interface (the 20mm hole a connector plugs into) -------------
HSWX_INSIDE       = 20;                              // hex hole flat-to-flat
HSWX_WALL         = 1.8;                             // shared cell wall thickness
HSWX_OUTSIDE      = HSWX_INSIDE + HSWX_WALL*2;       // 23.6  outside flat-to-flat
HSWX_SIDE         = HSWX_OUTSIDE / sqrt(3);          // ~13.6255 outer side length
HSWX_DEPTH        = 8;                               // panel / plug depth (Std Duty)
HSWX_LOCK_DEPTH   = 5;                               // depth where the lock step starts
HSWX_LOCK_LIP     = 1;                               // 1mm internal lip the barb catches
HSWX_LOCK_CHAMFER = HSWX_LOCK_LIP;                   // 1mm @ 45deg lead-in

// ---- Verified honeycomb lattice (flat-topped hexes, column tiling) ---------
HSW_PITCH_X       = 1.5 * HSWX_SIDE;                 // ~20.4382 column-to-column
HSW_PITCH_Y       = HSWX_OUTSIDE;                    // 23.6    row-to-row in a column
HSW_STAGGER_Y     = HSWX_OUTSIDE / 2;               // 11.8    alternate-column offset

// ---- Shared connector tunables ---------------------------------------------
PEG_FIT_DEFAULT   = 0.35;                            // bare-peg friction clearance
PEG_LEN_DEFAULT   = 7;                               // bare-peg depth into wall (< HSWX_DEPTH)
PLATE_T_DEFAULT   = 3;                               // back-plate thickness (welds depend on it)
HSW_WELD          = 0.6;                              // connector overlap INTO the plate (one fused solid)

// Across-flats -> circumscribed diameter (a $fn=6 cylinder lands on those flats).
// af/sqrt(3)*2 is IDENTICAL to af/cos(30); ONE form library-wide.
function hsw_af_to_d(af) = af / sqrt(3) * 2;

// ============================================================================
//  THE LATTICE — the single source of truth for WHERE connectors/holes go.
//  Bounding-box-centred on the origin for ANY nx/ny (incl. the single-column
//  case): the staggered odd columns only exist when nx>1, so the y-centring of
//  the cluster is conditional on nx>1. hsw_mount AND hsw_grid both call these.
// ============================================================================
function hsw_max_stag(nx) = (nx > 1) ? HSW_STAGGER_Y : 0;     // odd col only exists if nx>1
function hsw_cx(c, nx)    = c*HSW_PITCH_X - (nx-1)*HSW_PITCH_X/2;
function hsw_cy(c, r, nx, ny) =
    r*HSW_PITCH_Y
    - (ny-1)*HSW_PITCH_Y/2
    + ((c % 2 == 1) ? HSW_STAGGER_Y : 0)            // real alternate-column stagger
    - hsw_max_stag(nx)/2;                            // centre the cluster (cond. on nx>1)

// straight=true strip: every-OTHER column, no stagger (the legacy 40.88 strip).
// Use 2*HSW_PITCH_X (=40.8764), NEVER the rounded 40.88 literal.
function hsw_cx_straight(c, nx) = c*(2*HSW_PITCH_X) - (nx-1)*(2*HSW_PITCH_X)/2;

// ============================================================================
//  CONNECTOR 1 — hsw_peg : bare friction press-peg (the de-facto canonical peg).
//  $fn=6 hex prism, across-flats = HSWX_INSIDE - 2*fit, into -Z. Press fit only.
// ============================================================================
module hsw_peg(fit = PEG_FIT_DEFAULT, len = PEG_LEN_DEFAULT) {
    af = HSWX_INSIDE - 2*fit;                        // flat-to-flat, slightly under 20
    // hex prism from z=+HSW_WELD (buried INTO the plate) down to z=-len (into wall),
    // so the peg fuses with any plate occupying z>=0 into ONE solid (no coincident-face seam).
    translate([0, 0, -len])
        cylinder(h = len + HSW_WELD, d = hsw_af_to_d(af), $fn = 6);
}

// ============================================================================
//  CONNECTOR 1b — hsw_bare_peg : the THIN CORE peg (hex-plug-library hexagon_plug)
//  that plugs into a SEPARATE latch insert pre-snapped in the wall — NOT the grid
//  directly. Verbatim dims: 14.7 across-corners, 13 deep. Into -Z, welds the plate.
// ============================================================================
BAREPEG_D   = 14.7;     // across-corners ($fn=6) — source PLUG_HEXAGON_DIAMETER
BAREPEG_LEN = 13;       // source PLUG_LENGTH
module hsw_bare_peg(fit = 0) {
    translate([0, 0, -BAREPEG_LEN])
        cylinder(h = BAREPEG_LEN + HSW_WELD, d = BAREPEG_D - 2*fit, $fn = 6);
}

// ============================================================================
//  hsw_mount(nx, ny, type, plate_t, fit, straight)
//  ONE back-plate (front face +Z = plate_t) carrying an nx*ny connector lattice
//  on -Z, placed by hsw_cx/hsw_cy. type dispatches the per-cell connector.
// ============================================================================
// straight=true  -> GRID support  : pegs on an aligned rectangular grid
//                                    (40.8764 horiz x 23.6 vert, every-other
//                                    honeycomb column -> all land in real holes).
// straight=false -> HONEYCOMB support: pegs follow the staggered hex lattice
//                                    (20.4382 column pitch, odd columns staggered).
module hsw_mount(nx = 1, ny = 1, type = "peg", plate_t = PLATE_T_DEFAULT,
                 clearance = 0, straight = false, margin = 3, crot = 0) {
    // clamp counts so a user 0 (or negative) never yields an empty / garbage mount
    gnx = max(1, nx);
    gny = max(1, ny);
    // per-type base fit (peg=press 0.35, clip=snap 0.15, latch/barepeg=0 lip-tuned)
    // + the product's single user clearance tweak (+ looser / - tighter).
    pfit = (type == "clip" ? CLIP_FIT_DEFAULT
          : (type == "latch" || type == "barepeg") ? 0
          : PEG_FIT_DEFAULT) + clearance;
    // plate footprint spans the lattice + margin. GRID has no stagger; only the
    // staggered honeycomb extends Y by the odd-column stagger.
    spanX = straight ? (gnx-1)*(2*HSW_PITCH_X) : (gnx-1)*HSW_PITCH_X;
    spanY = (gny-1)*HSW_PITCH_Y;
    w = spanX + HSWX_OUTSIDE + 2*margin;
    d = spanY + HSWX_OUTSIDE + (straight ? 0 : hsw_max_stag(gnx)) + 2*margin;
    // crot rotates the PLUG PATTERN (plate + connectors, together so plugs stay on
    // the plate) about the wall normal so the accessory can match a wall installed
    // rotated 90deg. The body is built separately by the recipe and is NOT rotated
    // (plug layout only — body fixed).
    rotate([0, 0, crot]) {
        translate([0, 0, plate_t/2]) cube([w, d, plate_t], center = true);   // plate
        for (c = [0 : gnx-1])
            for (r = [0 : gny-1]) {
                x = straight ? hsw_cx_straight(c, gnx) : hsw_cx(c, gnx);
                y = straight ? (r*HSW_PITCH_Y - spanY/2) : hsw_cy(c, r, gnx, gny);
                translate([x, y, 0]) hsw_connector(type, pfit);
            }
    }
}

// ============================================================================
//  CONNECTOR 2 — hsw_latch_insert : snap-tab latching insert (vanilla port of
//  hex-plug-library / hsw-custom-insert, sh1-verified). Built front-face(lip) at
//  z=0 with body in +Z, then flipped to -Z and welded into the plate.
// ============================================================================
INSERT_BODY_FLATS = 19.7;   INSERT_LIP_FLATS = 22.5;   INSERT_TOTAL_H = 10;
INSERT_LIP_H = 2.5;         INSERT_SNAP_H = 6.5;       INSERT_TAB_OUT = 0.5;
INSERT_TAB_LEN = 2;         INSERT_SLOT_LEN = 8;       INSERT_SLOT_W = 0.8;
INSERT_SLOT_SIDE = 1;       INSERT_SLOT_RAD = 8.25;

module _hsw_bevel_cut(diameter) {
    h = diameter/2;                                     // tan(45)==1
    difference() { cylinder(d = diameter*2, h = h); cylinder(d1 = diameter, d2 = 0, h = h); }
}
module _hsw_insert_body(fit) {
    bodyD = hsw_af_to_d(INSERT_BODY_FLATS - 2*fit);
    lipD  = hsw_af_to_d(INSERT_LIP_FLATS);
    difference() {
        union() {
            cylinder(d = bodyD, h = INSERT_TOTAL_H, $fn = 6);   // main plug
            cylinder(d = lipD,  h = INSERT_LIP_H,  $fn = 6);    // overhang lip
        }
        translate([0,0,INSERT_TOTAL_H - 0.35]) _hsw_bevel_cut(bodyD);   // soften top edge
    }
}
module hsw_latch_insert(fit = 0) {
    translate([0,0,HSW_WELD]) rotate([180,0,0])
    union() {
        // six snap tabs (non-degenerate tip r=0.2, tops kept below the bevel)
        for (i=[0:5]) rotate([0,0,i*60]) translate([0, INSERT_BODY_FLATS/2, 0])
            hull() {
                translate([0,0,INSERT_SNAP_H + INSERT_SLOT_SIDE + INSERT_TAB_OUT])
                    rotate([0,90,0]) cylinder(r = INSERT_TAB_OUT, h = INSERT_TAB_LEN, center=true, $fn=20);
                translate([0,0,INSERT_TOTAL_H - 0.6])
                    rotate([0,90,0]) cylinder(r = 0.2, h = INSERT_TAB_LEN, center=true, $fn=20);
            }
        // body with flex slots so each tab deflects on insertion
        difference() {
            _hsw_insert_body(fit);
            for (i=[0:5]) rotate([0,0,i*60]) {
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_SLOT_W, INSERT_TOTAL_H]);
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_TOTAL_H, INSERT_SLOT_SIDE]);
            }
        }
    }
}

// ============================================================================
//  CONNECTOR 3 — hsw_clip : spring snap clip (from hsw-lib-core, sh1-verified).
//  Two cantilever arms catch the 1mm lip at 5mm depth. Mouth at z=0 into -Z.
// ============================================================================
CLIP_FIT_DEFAULT = 0.15;
CLIP_AF  = HSWX_INSIDE;      // 20 plug across-flats target
CLIP_LEN = HSWX_DEPTH;       // 8  plug length into the wall
SPRING_WALL = 1.6;           // cantilever arm wall (>=1.4 to flex)
SPRING_SLOT = 2.2;           // central relief slot width
module hsw_clip(fit = CLIP_FIT_DEFAULT) {
    af = CLIP_AF - 2*fit;  L = CLIP_LEN;
    barb = HSWX_LOCK_LIP;  locz = HSWX_LOCK_DEPTH;  cham = HSWX_LOCK_CHAMFER;  halfX = af/2;
    translate([0,0,HSW_WELD])
    difference() {
        union() {
            translate([0,0,-L/2]) linear_extrude(height = L, center = true) hsw_hex2d(af);   // hex plug
            for (sx=[-1,1]) translate([sx*halfX,0,-locz]) rotate([90,0,0])                    // outward barbs
                linear_extrude(height = af*0.62, center = true)
                    polygon([[0,0],[sx*barb,0],[sx*barb,cham],[0,cham+barb]]);
            translate([0,0,0.6/2]) linear_extrude(height = 0.6, center = true) hsw_hex2d(af + 1.2);  // mouth flange
        }
        translate([0,0,-L/2-0.5]) cube([SPRING_SLOT, af+4, L+2-1.2], center = true);          // central relief slot
        for (sx=[-1,1]) translate([sx*(halfX-SPRING_WALL-0.3),0,-L/2-1]) cube([1.4, af*0.5, L], center=true);  // arm hollow
    }
}

// per-cell connector dispatch:
//   peg     = friction peg, jams the bare grid hole (one-part)
//   barepeg = thin core peg, plugs into a SEPARATE latch pre-snapped in the wall
//   latch   = snap-tab insert, snaps into the bare grid hole
//   clip    = spring clip, snaps into the bare grid hole
module hsw_connector(type = "peg", fit = PEG_FIT_DEFAULT) {
    if      (type == "latch")   hsw_latch_insert(fit);
    else if (type == "clip")    hsw_clip(fit);
    else if (type == "barepeg") hsw_bare_peg(fit);
    else                        hsw_peg(fit);
}

// ============================================================================
//  hsw_grid(nx, ny, depth) — the FEMALE wall panel. Holes placed by the SAME
//  hsw_cx/hsw_cy so a hsw_mount(nx,ny) co-registers EXACTLY (proof artifact).
//  Lipped hex socket: 20mm bore, 1mm catch lip at 5mm depth.
// ============================================================================
module hsw_hex2d(af) { rotate([0,0,90]) circle(r = af/sqrt(3), $fn = 6); }

module hsw_hex_hole(depth) {
    afMouth = HSWX_INSIDE + 2*HSWX_LOCK_CHAMFER;
    afFull  = HSWX_INSIDE;
    afLip   = HSWX_INSIDE - 2*HSWX_LOCK_LIP;
    translate([0,0,-HSWX_LOCK_CHAMFER/2 + 0.01])
        linear_extrude(HSWX_LOCK_CHAMFER + 0.02, center=true, scale = afFull/afMouth) hsw_hex2d(afMouth);
    translate([0,0,-HSWX_LOCK_DEPTH/2])
        linear_extrude(HSWX_LOCK_DEPTH + 0.02, center=true) hsw_hex2d(afFull);
    translate([0,0,-HSWX_LOCK_DEPTH])
        linear_extrude(0.6, center=true) hsw_hex2d(afLip);
    backLen = depth - HSWX_LOCK_DEPTH;
    if (backLen > 0.1)
        translate([0,0,-(HSWX_LOCK_DEPTH + backLen/2)])
            linear_extrude(backLen + 0.4, center=true) hsw_hex2d(afFull);
}

module hsw_grid(nx = 3, ny = 3, depth = HSWX_DEPTH) {
    spanX = (nx-1)*HSW_PITCH_X;
    spanY = (ny-1)*HSW_PITCH_Y;
    slabW = spanX + HSWX_OUTSIDE;
    slabD = spanY + HSWX_OUTSIDE + hsw_max_stag(nx);
    difference() {
        translate([0, -hsw_max_stag(nx)/2, -depth/2]) cube([slabW, slabD, depth], center = true);
        for (c = [0 : nx-1])
            for (r = [0 : ny-1])
                translate([hsw_cx(c, nx), hsw_cy(c, r, nx, ny), 0]) hsw_hex_hole(depth);
    }
}

// ============================================================================
//  hsw_display() — canonical AnimBox display orientation. The geometry is built
//  in the OpenSCAD print frame (scad +Z = wall normal, +Y = up the wall). The
//  The OpenSCAD->AnimBox import is IDENTITY (verified by bbox: cube([10,20,40])
//  imports to world [10,20,40]). The wall-frame is already the display frame:
//  up-the-wall (+Y) = world UP, along-the-wall (+X) = world X, wall normal (+Z)
//  = toward the viewer (the body projects out of the wall). So hsw_display() is a
//  pass-through; it stays as the single place to adjust display orientation if the
//  import convention ever changes. Wrap every recipe's top call: hsw_display() my_part();
// ============================================================================
module hsw_display() { children(); }

// ---- product body (hidden internals) ----
eps   = 0.05;
PLATE = PLATE_T_DEFAULT;

module hex_key_holder_body() {
    span = (slots - 1) * spacing;
    bw = span + slot_w + 10;          // X width
    bd = slot_len + 8;                // Z depth out from wall
    bh = slot_depth + base_t;         // Y height
    z0 = PLATE - HSW_WELD;
    y0 = -bh / 2;
    difference() {
        translate([-bw / 2, y0, z0]) cube([bw, bh, bd + HSW_WELD]);
        // row of slots cut from the top (each a thin rectangular pocket)
        for (i = [0 : slots - 1])
            translate([-span / 2 + i * spacing - slot_w / 2, y0 + bh - slot_depth, PLATE + (bd - slot_len) / 2])
                cube([slot_w, slot_depth + eps, slot_len]);
    }
}
module hex_key_holder() {
    hsw_mount(connectors_x, connectors_y, type = connector_type, clearance = clearance,
              straight = (support_style == "grid"), crot = connector_rotation);
    hex_key_holder_body();
}
hsw_display() hex_key_holder();
`);

Open in editor →

HSW Phone / Tablet Shelf

A small ledge that holds a phone or tablet leaning against the wall, with a front lip to stop it sliding and a cable slot through the deck. Swappable wall plugs.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// HSW Phone / Tablet Shelf
//
// Source: honeycomb-wall phone shelf
// Generated from the library above, used under its license.

/* [Wall mount] */
// How it attaches to the wall
connector_type = "peg";       // [peg:Friction peg (into wall), barepeg:Bare peg (into a latch), latch:Latch insert (into wall), clip:Spring clip (into wall)]
// Plug support style
support_style = "grid";       // [grid:Grid (aligned rows + columns), honeycomb:Honeycomb (staggered, denser)]
// Rotate the plug pattern (to match a wall mounted sideways)
connector_rotation = 0;       // [0:0 degrees, 90:90 degrees]
// Hex connectors across
connectors_x = 2;             // [1:8]
// Hex connector rows
connectors_y = 2;             // [1:4]
// Fit tweak: + looser / - tighter
clearance = 0;                // [-0.3:0.05:0.5]

/* [Shelf] */
// Ledge width (mm)
ledge_width = 85;             // [40:160]
// Ledge depth out from the wall (mm)
ledge_depth = 24;            // [15:60]
// Ledge thickness (mm)
ledge_t = 5;                 // [3:12]
// Front lip height (mm)
lip_h = 14;                  // [6:30]
// Lip thickness (mm)
lip_t = 4;                   // [2:8]
// Cable slot width (mm)
cable_w = 18;                // [0:50]

// ============================================================================
//  HSW CONNECTOR TEMPLATE — the single canonical, self-contained connector kit
//  every HSW example inlines VERBATIM so plug spacing + sizing stay identical.
//  OpenSCAD 2021.01-safe. Self-contained: no include/use, no external libraries.
//
//  THE ONE RULE: plugs (hsw_mount) and wall holes (hsw_grid) are placed by the
//  SAME lattice functions hsw_cx()/hsw_cy(), so plug(c,r) == hole(c,r) for ANY
//  count by construction — verified 0.0000 mm deviation for 1..5 in each axis.
//
//  Frame: +Z = wall-normal (out of the wall). Connectors point into -Z (into the
//  wall); the back-plate front face sits at +Z = plate_t; accessory bodies build
//  on the +Z face. UP the wall = +Y, X = horizontal.
//
//  CUSTOMIZER: everything below is in the Hidden group so a product recipe that
//  inlines this template exposes ONLY its own dimensions + connectors_x/y +
//  connector_type + one clearance tweak. The HSW internals are NEVER customer-tunable.
// ============================================================================
/* [Hidden] */
$fn = 48;

// ---- Core hex interface (the 20mm hole a connector plugs into) -------------
HSWX_INSIDE       = 20;                              // hex hole flat-to-flat
HSWX_WALL         = 1.8;                             // shared cell wall thickness
HSWX_OUTSIDE      = HSWX_INSIDE + HSWX_WALL*2;       // 23.6  outside flat-to-flat
HSWX_SIDE         = HSWX_OUTSIDE / sqrt(3);          // ~13.6255 outer side length
HSWX_DEPTH        = 8;                               // panel / plug depth (Std Duty)
HSWX_LOCK_DEPTH   = 5;                               // depth where the lock step starts
HSWX_LOCK_LIP     = 1;                               // 1mm internal lip the barb catches
HSWX_LOCK_CHAMFER = HSWX_LOCK_LIP;                   // 1mm @ 45deg lead-in

// ---- Verified honeycomb lattice (flat-topped hexes, column tiling) ---------
HSW_PITCH_X       = 1.5 * HSWX_SIDE;                 // ~20.4382 column-to-column
HSW_PITCH_Y       = HSWX_OUTSIDE;                    // 23.6    row-to-row in a column
HSW_STAGGER_Y     = HSWX_OUTSIDE / 2;               // 11.8    alternate-column offset

// ---- Shared connector tunables ---------------------------------------------
PEG_FIT_DEFAULT   = 0.35;                            // bare-peg friction clearance
PEG_LEN_DEFAULT   = 7;                               // bare-peg depth into wall (< HSWX_DEPTH)
PLATE_T_DEFAULT   = 3;                               // back-plate thickness (welds depend on it)
HSW_WELD          = 0.6;                              // connector overlap INTO the plate (one fused solid)

// Across-flats -> circumscribed diameter (a $fn=6 cylinder lands on those flats).
// af/sqrt(3)*2 is IDENTICAL to af/cos(30); ONE form library-wide.
function hsw_af_to_d(af) = af / sqrt(3) * 2;

// ============================================================================
//  THE LATTICE — the single source of truth for WHERE connectors/holes go.
//  Bounding-box-centred on the origin for ANY nx/ny (incl. the single-column
//  case): the staggered odd columns only exist when nx>1, so the y-centring of
//  the cluster is conditional on nx>1. hsw_mount AND hsw_grid both call these.
// ============================================================================
function hsw_max_stag(nx) = (nx > 1) ? HSW_STAGGER_Y : 0;     // odd col only exists if nx>1
function hsw_cx(c, nx)    = c*HSW_PITCH_X - (nx-1)*HSW_PITCH_X/2;
function hsw_cy(c, r, nx, ny) =
    r*HSW_PITCH_Y
    - (ny-1)*HSW_PITCH_Y/2
    + ((c % 2 == 1) ? HSW_STAGGER_Y : 0)            // real alternate-column stagger
    - hsw_max_stag(nx)/2;                            // centre the cluster (cond. on nx>1)

// straight=true strip: every-OTHER column, no stagger (the legacy 40.88 strip).
// Use 2*HSW_PITCH_X (=40.8764), NEVER the rounded 40.88 literal.
function hsw_cx_straight(c, nx) = c*(2*HSW_PITCH_X) - (nx-1)*(2*HSW_PITCH_X)/2;

// ============================================================================
//  CONNECTOR 1 — hsw_peg : bare friction press-peg (the de-facto canonical peg).
//  $fn=6 hex prism, across-flats = HSWX_INSIDE - 2*fit, into -Z. Press fit only.
// ============================================================================
module hsw_peg(fit = PEG_FIT_DEFAULT, len = PEG_LEN_DEFAULT) {
    af = HSWX_INSIDE - 2*fit;                        // flat-to-flat, slightly under 20
    // hex prism from z=+HSW_WELD (buried INTO the plate) down to z=-len (into wall),
    // so the peg fuses with any plate occupying z>=0 into ONE solid (no coincident-face seam).
    translate([0, 0, -len])
        cylinder(h = len + HSW_WELD, d = hsw_af_to_d(af), $fn = 6);
}

// ============================================================================
//  CONNECTOR 1b — hsw_bare_peg : the THIN CORE peg (hex-plug-library hexagon_plug)
//  that plugs into a SEPARATE latch insert pre-snapped in the wall — NOT the grid
//  directly. Verbatim dims: 14.7 across-corners, 13 deep. Into -Z, welds the plate.
// ============================================================================
BAREPEG_D   = 14.7;     // across-corners ($fn=6) — source PLUG_HEXAGON_DIAMETER
BAREPEG_LEN = 13;       // source PLUG_LENGTH
module hsw_bare_peg(fit = 0) {
    translate([0, 0, -BAREPEG_LEN])
        cylinder(h = BAREPEG_LEN + HSW_WELD, d = BAREPEG_D - 2*fit, $fn = 6);
}

// ============================================================================
//  hsw_mount(nx, ny, type, plate_t, fit, straight)
//  ONE back-plate (front face +Z = plate_t) carrying an nx*ny connector lattice
//  on -Z, placed by hsw_cx/hsw_cy. type dispatches the per-cell connector.
// ============================================================================
// straight=true  -> GRID support  : pegs on an aligned rectangular grid
//                                    (40.8764 horiz x 23.6 vert, every-other
//                                    honeycomb column -> all land in real holes).
// straight=false -> HONEYCOMB support: pegs follow the staggered hex lattice
//                                    (20.4382 column pitch, odd columns staggered).
module hsw_mount(nx = 1, ny = 1, type = "peg", plate_t = PLATE_T_DEFAULT,
                 clearance = 0, straight = false, margin = 3, crot = 0) {
    // clamp counts so a user 0 (or negative) never yields an empty / garbage mount
    gnx = max(1, nx);
    gny = max(1, ny);
    // per-type base fit (peg=press 0.35, clip=snap 0.15, latch/barepeg=0 lip-tuned)
    // + the product's single user clearance tweak (+ looser / - tighter).
    pfit = (type == "clip" ? CLIP_FIT_DEFAULT
          : (type == "latch" || type == "barepeg") ? 0
          : PEG_FIT_DEFAULT) + clearance;
    // plate footprint spans the lattice + margin. GRID has no stagger; only the
    // staggered honeycomb extends Y by the odd-column stagger.
    spanX = straight ? (gnx-1)*(2*HSW_PITCH_X) : (gnx-1)*HSW_PITCH_X;
    spanY = (gny-1)*HSW_PITCH_Y;
    w = spanX + HSWX_OUTSIDE + 2*margin;
    d = spanY + HSWX_OUTSIDE + (straight ? 0 : hsw_max_stag(gnx)) + 2*margin;
    // crot rotates the PLUG PATTERN (plate + connectors, together so plugs stay on
    // the plate) about the wall normal so the accessory can match a wall installed
    // rotated 90deg. The body is built separately by the recipe and is NOT rotated
    // (plug layout only — body fixed).
    rotate([0, 0, crot]) {
        translate([0, 0, plate_t/2]) cube([w, d, plate_t], center = true);   // plate
        for (c = [0 : gnx-1])
            for (r = [0 : gny-1]) {
                x = straight ? hsw_cx_straight(c, gnx) : hsw_cx(c, gnx);
                y = straight ? (r*HSW_PITCH_Y - spanY/2) : hsw_cy(c, r, gnx, gny);
                translate([x, y, 0]) hsw_connector(type, pfit);
            }
    }
}

// ============================================================================
//  CONNECTOR 2 — hsw_latch_insert : snap-tab latching insert (vanilla port of
//  hex-plug-library / hsw-custom-insert, sh1-verified). Built front-face(lip) at
//  z=0 with body in +Z, then flipped to -Z and welded into the plate.
// ============================================================================
INSERT_BODY_FLATS = 19.7;   INSERT_LIP_FLATS = 22.5;   INSERT_TOTAL_H = 10;
INSERT_LIP_H = 2.5;         INSERT_SNAP_H = 6.5;       INSERT_TAB_OUT = 0.5;
INSERT_TAB_LEN = 2;         INSERT_SLOT_LEN = 8;       INSERT_SLOT_W = 0.8;
INSERT_SLOT_SIDE = 1;       INSERT_SLOT_RAD = 8.25;

module _hsw_bevel_cut(diameter) {
    h = diameter/2;                                     // tan(45)==1
    difference() { cylinder(d = diameter*2, h = h); cylinder(d1 = diameter, d2 = 0, h = h); }
}
module _hsw_insert_body(fit) {
    bodyD = hsw_af_to_d(INSERT_BODY_FLATS - 2*fit);
    lipD  = hsw_af_to_d(INSERT_LIP_FLATS);
    difference() {
        union() {
            cylinder(d = bodyD, h = INSERT_TOTAL_H, $fn = 6);   // main plug
            cylinder(d = lipD,  h = INSERT_LIP_H,  $fn = 6);    // overhang lip
        }
        translate([0,0,INSERT_TOTAL_H - 0.35]) _hsw_bevel_cut(bodyD);   // soften top edge
    }
}
module hsw_latch_insert(fit = 0) {
    translate([0,0,HSW_WELD]) rotate([180,0,0])
    union() {
        // six snap tabs (non-degenerate tip r=0.2, tops kept below the bevel)
        for (i=[0:5]) rotate([0,0,i*60]) translate([0, INSERT_BODY_FLATS/2, 0])
            hull() {
                translate([0,0,INSERT_SNAP_H + INSERT_SLOT_SIDE + INSERT_TAB_OUT])
                    rotate([0,90,0]) cylinder(r = INSERT_TAB_OUT, h = INSERT_TAB_LEN, center=true, $fn=20);
                translate([0,0,INSERT_TOTAL_H - 0.6])
                    rotate([0,90,0]) cylinder(r = 0.2, h = INSERT_TAB_LEN, center=true, $fn=20);
            }
        // body with flex slots so each tab deflects on insertion
        difference() {
            _hsw_insert_body(fit);
            for (i=[0:5]) rotate([0,0,i*60]) {
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_SLOT_W, INSERT_TOTAL_H]);
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_TOTAL_H, INSERT_SLOT_SIDE]);
            }
        }
    }
}

// ============================================================================
//  CONNECTOR 3 — hsw_clip : spring snap clip (from hsw-lib-core, sh1-verified).
//  Two cantilever arms catch the 1mm lip at 5mm depth. Mouth at z=0 into -Z.
// ============================================================================
CLIP_FIT_DEFAULT = 0.15;
CLIP_AF  = HSWX_INSIDE;      // 20 plug across-flats target
CLIP_LEN = HSWX_DEPTH;       // 8  plug length into the wall
SPRING_WALL = 1.6;           // cantilever arm wall (>=1.4 to flex)
SPRING_SLOT = 2.2;           // central relief slot width
module hsw_clip(fit = CLIP_FIT_DEFAULT) {
    af = CLIP_AF - 2*fit;  L = CLIP_LEN;
    barb = HSWX_LOCK_LIP;  locz = HSWX_LOCK_DEPTH;  cham = HSWX_LOCK_CHAMFER;  halfX = af/2;
    translate([0,0,HSW_WELD])
    difference() {
        union() {
            translate([0,0,-L/2]) linear_extrude(height = L, center = true) hsw_hex2d(af);   // hex plug
            for (sx=[-1,1]) translate([sx*halfX,0,-locz]) rotate([90,0,0])                    // outward barbs
                linear_extrude(height = af*0.62, center = true)
                    polygon([[0,0],[sx*barb,0],[sx*barb,cham],[0,cham+barb]]);
            translate([0,0,0.6/2]) linear_extrude(height = 0.6, center = true) hsw_hex2d(af + 1.2);  // mouth flange
        }
        translate([0,0,-L/2-0.5]) cube([SPRING_SLOT, af+4, L+2-1.2], center = true);          // central relief slot
        for (sx=[-1,1]) translate([sx*(halfX-SPRING_WALL-0.3),0,-L/2-1]) cube([1.4, af*0.5, L], center=true);  // arm hollow
    }
}

// per-cell connector dispatch:
//   peg     = friction peg, jams the bare grid hole (one-part)
//   barepeg = thin core peg, plugs into a SEPARATE latch pre-snapped in the wall
//   latch   = snap-tab insert, snaps into the bare grid hole
//   clip    = spring clip, snaps into the bare grid hole
module hsw_connector(type = "peg", fit = PEG_FIT_DEFAULT) {
    if      (type == "latch")   hsw_latch_insert(fit);
    else if (type == "clip")    hsw_clip(fit);
    else if (type == "barepeg") hsw_bare_peg(fit);
    else                        hsw_peg(fit);
}

// ============================================================================
//  hsw_grid(nx, ny, depth) — the FEMALE wall panel. Holes placed by the SAME
//  hsw_cx/hsw_cy so a hsw_mount(nx,ny) co-registers EXACTLY (proof artifact).
//  Lipped hex socket: 20mm bore, 1mm catch lip at 5mm depth.
// ============================================================================
module hsw_hex2d(af) { rotate([0,0,90]) circle(r = af/sqrt(3), $fn = 6); }

module hsw_hex_hole(depth) {
    afMouth = HSWX_INSIDE + 2*HSWX_LOCK_CHAMFER;
    afFull  = HSWX_INSIDE;
    afLip   = HSWX_INSIDE - 2*HSWX_LOCK_LIP;
    translate([0,0,-HSWX_LOCK_CHAMFER/2 + 0.01])
        linear_extrude(HSWX_LOCK_CHAMFER + 0.02, center=true, scale = afFull/afMouth) hsw_hex2d(afMouth);
    translate([0,0,-HSWX_LOCK_DEPTH/2])
        linear_extrude(HSWX_LOCK_DEPTH + 0.02, center=true) hsw_hex2d(afFull);
    translate([0,0,-HSWX_LOCK_DEPTH])
        linear_extrude(0.6, center=true) hsw_hex2d(afLip);
    backLen = depth - HSWX_LOCK_DEPTH;
    if (backLen > 0.1)
        translate([0,0,-(HSWX_LOCK_DEPTH + backLen/2)])
            linear_extrude(backLen + 0.4, center=true) hsw_hex2d(afFull);
}

module hsw_grid(nx = 3, ny = 3, depth = HSWX_DEPTH) {
    spanX = (nx-1)*HSW_PITCH_X;
    spanY = (ny-1)*HSW_PITCH_Y;
    slabW = spanX + HSWX_OUTSIDE;
    slabD = spanY + HSWX_OUTSIDE + hsw_max_stag(nx);
    difference() {
        translate([0, -hsw_max_stag(nx)/2, -depth/2]) cube([slabW, slabD, depth], center = true);
        for (c = [0 : nx-1])
            for (r = [0 : ny-1])
                translate([hsw_cx(c, nx), hsw_cy(c, r, nx, ny), 0]) hsw_hex_hole(depth);
    }
}

// ============================================================================
//  hsw_display() — canonical AnimBox display orientation. The geometry is built
//  in the OpenSCAD print frame (scad +Z = wall normal, +Y = up the wall). The
//  The OpenSCAD->AnimBox import is IDENTITY (verified by bbox: cube([10,20,40])
//  imports to world [10,20,40]). The wall-frame is already the display frame:
//  up-the-wall (+Y) = world UP, along-the-wall (+X) = world X, wall normal (+Z)
//  = toward the viewer (the body projects out of the wall). So hsw_display() is a
//  pass-through; it stays as the single place to adjust display orientation if the
//  import convention ever changes. Wrap every recipe's top call: hsw_display() my_part();
// ============================================================================
module hsw_display() { children(); }

// ---- product body (hidden internals) ----
eps   = 0.05;
PLATE = PLATE_T_DEFAULT;

module phone_shelf_body() {
    z0 = PLATE - HSW_WELD;
    y0 = -(ledge_t) / 2 - 8;      // ledge near the lower part of the plate
    difference() {
        union() {
            // ledge deck (top surface at y0 + ledge_t)
            translate([-ledge_width / 2, y0, z0]) cube([ledge_width, ledge_t, ledge_depth + HSW_WELD]);
            // front lip rising up at the far edge
            translate([-ledge_width / 2, y0, PLATE + ledge_depth - lip_t]) cube([ledge_width, ledge_t + lip_h, lip_t]);
        }
        // cable pass-through slot through the deck near the wall
        if (cable_w > 0)
            translate([-cable_w / 2, y0 - eps, PLATE + 3]) cube([cable_w, ledge_t + 2 * eps, 7]);
    }
}
module phone_shelf() {
    hsw_mount(connectors_x, connectors_y, type = connector_type, clearance = clearance,
              straight = (support_style == "grid"), crot = connector_rotation);
    phone_shelf_body();
}
hsw_display() phone_shelf();
`);

Open in editor →

HSW Rod / Pillar Holder

A deep round socket that holds a rod, dowel, pillar, umbrella, or long tool upright. Optional drain hole in the base. Swappable wall plugs.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// HSW Rod / Pillar Holder
//
// Source: honeycomb-wall vertical rod holder
// Generated from the library above, used under its license.

/* [Wall mount] */
// How it attaches to the wall
connector_type = "peg";       // [peg:Friction peg (into wall), barepeg:Bare peg (into a latch), latch:Latch insert (into wall), clip:Spring clip (into wall)]
// Plug support style
support_style = "grid";       // [grid:Grid (aligned rows + columns), honeycomb:Honeycomb (staggered, denser)]
// Rotate the plug pattern (to match a wall mounted sideways)
connector_rotation = 0;       // [0:0 degrees, 90:90 degrees]
// Hex connectors across
connectors_x = 1;             // [1:8]
// Hex connector rows (2 = strong for a tall rod)
connectors_y = 2;             // [1:4]
// Fit tweak: + looser / - tighter
clearance = 0;                // [-0.3:0.05:0.5]

/* [Socket] */
// Bore diameter (mm)
bore_d = 24;                  // [8:60]
// Wall thickness (mm)
wall = 3;                     // [1.5:0.5:6]
// Socket depth (mm)
depth = 65;                   // [25:140]
// Base thickness (mm)
base_t = 4;                   // [2:12]
// Drain hole through the base
drain = true;
// Drain hole diameter (mm)
drain_d = 6;                  // [3:16]

// ============================================================================
//  HSW CONNECTOR TEMPLATE — the single canonical, self-contained connector kit
//  every HSW example inlines VERBATIM so plug spacing + sizing stay identical.
//  OpenSCAD 2021.01-safe. Self-contained: no include/use, no external libraries.
//
//  THE ONE RULE: plugs (hsw_mount) and wall holes (hsw_grid) are placed by the
//  SAME lattice functions hsw_cx()/hsw_cy(), so plug(c,r) == hole(c,r) for ANY
//  count by construction — verified 0.0000 mm deviation for 1..5 in each axis.
//
//  Frame: +Z = wall-normal (out of the wall). Connectors point into -Z (into the
//  wall); the back-plate front face sits at +Z = plate_t; accessory bodies build
//  on the +Z face. UP the wall = +Y, X = horizontal.
//
//  CUSTOMIZER: everything below is in the Hidden group so a product recipe that
//  inlines this template exposes ONLY its own dimensions + connectors_x/y +
//  connector_type + one clearance tweak. The HSW internals are NEVER customer-tunable.
// ============================================================================
/* [Hidden] */
$fn = 48;

// ---- Core hex interface (the 20mm hole a connector plugs into) -------------
HSWX_INSIDE       = 20;                              // hex hole flat-to-flat
HSWX_WALL         = 1.8;                             // shared cell wall thickness
HSWX_OUTSIDE      = HSWX_INSIDE + HSWX_WALL*2;       // 23.6  outside flat-to-flat
HSWX_SIDE         = HSWX_OUTSIDE / sqrt(3);          // ~13.6255 outer side length
HSWX_DEPTH        = 8;                               // panel / plug depth (Std Duty)
HSWX_LOCK_DEPTH   = 5;                               // depth where the lock step starts
HSWX_LOCK_LIP     = 1;                               // 1mm internal lip the barb catches
HSWX_LOCK_CHAMFER = HSWX_LOCK_LIP;                   // 1mm @ 45deg lead-in

// ---- Verified honeycomb lattice (flat-topped hexes, column tiling) ---------
HSW_PITCH_X       = 1.5 * HSWX_SIDE;                 // ~20.4382 column-to-column
HSW_PITCH_Y       = HSWX_OUTSIDE;                    // 23.6    row-to-row in a column
HSW_STAGGER_Y     = HSWX_OUTSIDE / 2;               // 11.8    alternate-column offset

// ---- Shared connector tunables ---------------------------------------------
PEG_FIT_DEFAULT   = 0.35;                            // bare-peg friction clearance
PEG_LEN_DEFAULT   = 7;                               // bare-peg depth into wall (< HSWX_DEPTH)
PLATE_T_DEFAULT   = 3;                               // back-plate thickness (welds depend on it)
HSW_WELD          = 0.6;                              // connector overlap INTO the plate (one fused solid)

// Across-flats -> circumscribed diameter (a $fn=6 cylinder lands on those flats).
// af/sqrt(3)*2 is IDENTICAL to af/cos(30); ONE form library-wide.
function hsw_af_to_d(af) = af / sqrt(3) * 2;

// ============================================================================
//  THE LATTICE — the single source of truth for WHERE connectors/holes go.
//  Bounding-box-centred on the origin for ANY nx/ny (incl. the single-column
//  case): the staggered odd columns only exist when nx>1, so the y-centring of
//  the cluster is conditional on nx>1. hsw_mount AND hsw_grid both call these.
// ============================================================================
function hsw_max_stag(nx) = (nx > 1) ? HSW_STAGGER_Y : 0;     // odd col only exists if nx>1
function hsw_cx(c, nx)    = c*HSW_PITCH_X - (nx-1)*HSW_PITCH_X/2;
function hsw_cy(c, r, nx, ny) =
    r*HSW_PITCH_Y
    - (ny-1)*HSW_PITCH_Y/2
    + ((c % 2 == 1) ? HSW_STAGGER_Y : 0)            // real alternate-column stagger
    - hsw_max_stag(nx)/2;                            // centre the cluster (cond. on nx>1)

// straight=true strip: every-OTHER column, no stagger (the legacy 40.88 strip).
// Use 2*HSW_PITCH_X (=40.8764), NEVER the rounded 40.88 literal.
function hsw_cx_straight(c, nx) = c*(2*HSW_PITCH_X) - (nx-1)*(2*HSW_PITCH_X)/2;

// ============================================================================
//  CONNECTOR 1 — hsw_peg : bare friction press-peg (the de-facto canonical peg).
//  $fn=6 hex prism, across-flats = HSWX_INSIDE - 2*fit, into -Z. Press fit only.
// ============================================================================
module hsw_peg(fit = PEG_FIT_DEFAULT, len = PEG_LEN_DEFAULT) {
    af = HSWX_INSIDE - 2*fit;                        // flat-to-flat, slightly under 20
    // hex prism from z=+HSW_WELD (buried INTO the plate) down to z=-len (into wall),
    // so the peg fuses with any plate occupying z>=0 into ONE solid (no coincident-face seam).
    translate([0, 0, -len])
        cylinder(h = len + HSW_WELD, d = hsw_af_to_d(af), $fn = 6);
}

// ============================================================================
//  CONNECTOR 1b — hsw_bare_peg : the THIN CORE peg (hex-plug-library hexagon_plug)
//  that plugs into a SEPARATE latch insert pre-snapped in the wall — NOT the grid
//  directly. Verbatim dims: 14.7 across-corners, 13 deep. Into -Z, welds the plate.
// ============================================================================
BAREPEG_D   = 14.7;     // across-corners ($fn=6) — source PLUG_HEXAGON_DIAMETER
BAREPEG_LEN = 13;       // source PLUG_LENGTH
module hsw_bare_peg(fit = 0) {
    translate([0, 0, -BAREPEG_LEN])
        cylinder(h = BAREPEG_LEN + HSW_WELD, d = BAREPEG_D - 2*fit, $fn = 6);
}

// ============================================================================
//  hsw_mount(nx, ny, type, plate_t, fit, straight)
//  ONE back-plate (front face +Z = plate_t) carrying an nx*ny connector lattice
//  on -Z, placed by hsw_cx/hsw_cy. type dispatches the per-cell connector.
// ============================================================================
// straight=true  -> GRID support  : pegs on an aligned rectangular grid
//                                    (40.8764 horiz x 23.6 vert, every-other
//                                    honeycomb column -> all land in real holes).
// straight=false -> HONEYCOMB support: pegs follow the staggered hex lattice
//                                    (20.4382 column pitch, odd columns staggered).
module hsw_mount(nx = 1, ny = 1, type = "peg", plate_t = PLATE_T_DEFAULT,
                 clearance = 0, straight = false, margin = 3, crot = 0) {
    // clamp counts so a user 0 (or negative) never yields an empty / garbage mount
    gnx = max(1, nx);
    gny = max(1, ny);
    // per-type base fit (peg=press 0.35, clip=snap 0.15, latch/barepeg=0 lip-tuned)
    // + the product's single user clearance tweak (+ looser / - tighter).
    pfit = (type == "clip" ? CLIP_FIT_DEFAULT
          : (type == "latch" || type == "barepeg") ? 0
          : PEG_FIT_DEFAULT) + clearance;
    // plate footprint spans the lattice + margin. GRID has no stagger; only the
    // staggered honeycomb extends Y by the odd-column stagger.
    spanX = straight ? (gnx-1)*(2*HSW_PITCH_X) : (gnx-1)*HSW_PITCH_X;
    spanY = (gny-1)*HSW_PITCH_Y;
    w = spanX + HSWX_OUTSIDE + 2*margin;
    d = spanY + HSWX_OUTSIDE + (straight ? 0 : hsw_max_stag(gnx)) + 2*margin;
    // crot rotates the PLUG PATTERN (plate + connectors, together so plugs stay on
    // the plate) about the wall normal so the accessory can match a wall installed
    // rotated 90deg. The body is built separately by the recipe and is NOT rotated
    // (plug layout only — body fixed).
    rotate([0, 0, crot]) {
        translate([0, 0, plate_t/2]) cube([w, d, plate_t], center = true);   // plate
        for (c = [0 : gnx-1])
            for (r = [0 : gny-1]) {
                x = straight ? hsw_cx_straight(c, gnx) : hsw_cx(c, gnx);
                y = straight ? (r*HSW_PITCH_Y - spanY/2) : hsw_cy(c, r, gnx, gny);
                translate([x, y, 0]) hsw_connector(type, pfit);
            }
    }
}

// ============================================================================
//  CONNECTOR 2 — hsw_latch_insert : snap-tab latching insert (vanilla port of
//  hex-plug-library / hsw-custom-insert, sh1-verified). Built front-face(lip) at
//  z=0 with body in +Z, then flipped to -Z and welded into the plate.
// ============================================================================
INSERT_BODY_FLATS = 19.7;   INSERT_LIP_FLATS = 22.5;   INSERT_TOTAL_H = 10;
INSERT_LIP_H = 2.5;         INSERT_SNAP_H = 6.5;       INSERT_TAB_OUT = 0.5;
INSERT_TAB_LEN = 2;         INSERT_SLOT_LEN = 8;       INSERT_SLOT_W = 0.8;
INSERT_SLOT_SIDE = 1;       INSERT_SLOT_RAD = 8.25;

module _hsw_bevel_cut(diameter) {
    h = diameter/2;                                     // tan(45)==1
    difference() { cylinder(d = diameter*2, h = h); cylinder(d1 = diameter, d2 = 0, h = h); }
}
module _hsw_insert_body(fit) {
    bodyD = hsw_af_to_d(INSERT_BODY_FLATS - 2*fit);
    lipD  = hsw_af_to_d(INSERT_LIP_FLATS);
    difference() {
        union() {
            cylinder(d = bodyD, h = INSERT_TOTAL_H, $fn = 6);   // main plug
            cylinder(d = lipD,  h = INSERT_LIP_H,  $fn = 6);    // overhang lip
        }
        translate([0,0,INSERT_TOTAL_H - 0.35]) _hsw_bevel_cut(bodyD);   // soften top edge
    }
}
module hsw_latch_insert(fit = 0) {
    translate([0,0,HSW_WELD]) rotate([180,0,0])
    union() {
        // six snap tabs (non-degenerate tip r=0.2, tops kept below the bevel)
        for (i=[0:5]) rotate([0,0,i*60]) translate([0, INSERT_BODY_FLATS/2, 0])
            hull() {
                translate([0,0,INSERT_SNAP_H + INSERT_SLOT_SIDE + INSERT_TAB_OUT])
                    rotate([0,90,0]) cylinder(r = INSERT_TAB_OUT, h = INSERT_TAB_LEN, center=true, $fn=20);
                translate([0,0,INSERT_TOTAL_H - 0.6])
                    rotate([0,90,0]) cylinder(r = 0.2, h = INSERT_TAB_LEN, center=true, $fn=20);
            }
        // body with flex slots so each tab deflects on insertion
        difference() {
            _hsw_insert_body(fit);
            for (i=[0:5]) rotate([0,0,i*60]) {
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_SLOT_W, INSERT_TOTAL_H]);
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_TOTAL_H, INSERT_SLOT_SIDE]);
            }
        }
    }
}

// ============================================================================
//  CONNECTOR 3 — hsw_clip : spring snap clip (from hsw-lib-core, sh1-verified).
//  Two cantilever arms catch the 1mm lip at 5mm depth. Mouth at z=0 into -Z.
// ============================================================================
CLIP_FIT_DEFAULT = 0.15;
CLIP_AF  = HSWX_INSIDE;      // 20 plug across-flats target
CLIP_LEN = HSWX_DEPTH;       // 8  plug length into the wall
SPRING_WALL = 1.6;           // cantilever arm wall (>=1.4 to flex)
SPRING_SLOT = 2.2;           // central relief slot width
module hsw_clip(fit = CLIP_FIT_DEFAULT) {
    af = CLIP_AF - 2*fit;  L = CLIP_LEN;
    barb = HSWX_LOCK_LIP;  locz = HSWX_LOCK_DEPTH;  cham = HSWX_LOCK_CHAMFER;  halfX = af/2;
    translate([0,0,HSW_WELD])
    difference() {
        union() {
            translate([0,0,-L/2]) linear_extrude(height = L, center = true) hsw_hex2d(af);   // hex plug
            for (sx=[-1,1]) translate([sx*halfX,0,-locz]) rotate([90,0,0])                    // outward barbs
                linear_extrude(height = af*0.62, center = true)
                    polygon([[0,0],[sx*barb,0],[sx*barb,cham],[0,cham+barb]]);
            translate([0,0,0.6/2]) linear_extrude(height = 0.6, center = true) hsw_hex2d(af + 1.2);  // mouth flange
        }
        translate([0,0,-L/2-0.5]) cube([SPRING_SLOT, af+4, L+2-1.2], center = true);          // central relief slot
        for (sx=[-1,1]) translate([sx*(halfX-SPRING_WALL-0.3),0,-L/2-1]) cube([1.4, af*0.5, L], center=true);  // arm hollow
    }
}

// per-cell connector dispatch:
//   peg     = friction peg, jams the bare grid hole (one-part)
//   barepeg = thin core peg, plugs into a SEPARATE latch pre-snapped in the wall
//   latch   = snap-tab insert, snaps into the bare grid hole
//   clip    = spring clip, snaps into the bare grid hole
module hsw_connector(type = "peg", fit = PEG_FIT_DEFAULT) {
    if      (type == "latch")   hsw_latch_insert(fit);
    else if (type == "clip")    hsw_clip(fit);
    else if (type == "barepeg") hsw_bare_peg(fit);
    else                        hsw_peg(fit);
}

// ============================================================================
//  hsw_grid(nx, ny, depth) — the FEMALE wall panel. Holes placed by the SAME
//  hsw_cx/hsw_cy so a hsw_mount(nx,ny) co-registers EXACTLY (proof artifact).
//  Lipped hex socket: 20mm bore, 1mm catch lip at 5mm depth.
// ============================================================================
module hsw_hex2d(af) { rotate([0,0,90]) circle(r = af/sqrt(3), $fn = 6); }

module hsw_hex_hole(depth) {
    afMouth = HSWX_INSIDE + 2*HSWX_LOCK_CHAMFER;
    afFull  = HSWX_INSIDE;
    afLip   = HSWX_INSIDE - 2*HSWX_LOCK_LIP;
    translate([0,0,-HSWX_LOCK_CHAMFER/2 + 0.01])
        linear_extrude(HSWX_LOCK_CHAMFER + 0.02, center=true, scale = afFull/afMouth) hsw_hex2d(afMouth);
    translate([0,0,-HSWX_LOCK_DEPTH/2])
        linear_extrude(HSWX_LOCK_DEPTH + 0.02, center=true) hsw_hex2d(afFull);
    translate([0,0,-HSWX_LOCK_DEPTH])
        linear_extrude(0.6, center=true) hsw_hex2d(afLip);
    backLen = depth - HSWX_LOCK_DEPTH;
    if (backLen > 0.1)
        translate([0,0,-(HSWX_LOCK_DEPTH + backLen/2)])
            linear_extrude(backLen + 0.4, center=true) hsw_hex2d(afFull);
}

module hsw_grid(nx = 3, ny = 3, depth = HSWX_DEPTH) {
    spanX = (nx-1)*HSW_PITCH_X;
    spanY = (ny-1)*HSW_PITCH_Y;
    slabW = spanX + HSWX_OUTSIDE;
    slabD = spanY + HSWX_OUTSIDE + hsw_max_stag(nx);
    difference() {
        translate([0, -hsw_max_stag(nx)/2, -depth/2]) cube([slabW, slabD, depth], center = true);
        for (c = [0 : nx-1])
            for (r = [0 : ny-1])
                translate([hsw_cx(c, nx), hsw_cy(c, r, nx, ny), 0]) hsw_hex_hole(depth);
    }
}

// ============================================================================
//  hsw_display() — canonical AnimBox display orientation. The geometry is built
//  in the OpenSCAD print frame (scad +Z = wall normal, +Y = up the wall). The
//  The OpenSCAD->AnimBox import is IDENTITY (verified by bbox: cube([10,20,40])
//  imports to world [10,20,40]). The wall-frame is already the display frame:
//  up-the-wall (+Y) = world UP, along-the-wall (+X) = world X, wall normal (+Z)
//  = toward the viewer (the body projects out of the wall). So hsw_display() is a
//  pass-through; it stays as the single place to adjust display orientation if the
//  import convention ever changes. Wrap every recipe's top call: hsw_display() my_part();
// ============================================================================
module hsw_display() { children(); }

// ---- product body (hidden internals) ----
eps   = 0.05;
PLATE = PLATE_T_DEFAULT;

module rod_socket() {
    od = bore_d + 2 * wall;
    or = od / 2;
    // vertical tube (opens up +Y), lifted so it rests just off the plate
    translate([0, 0, PLATE + or]) {
        difference() {
            rotate([-90, 0, 0]) cylinder(h = depth, d = od);
            translate([0, base_t, 0]) rotate([-90, 0, 0]) cylinder(h = depth - base_t + eps, d = bore_d);
            if (drain) translate([0, -eps, 0]) rotate([-90, 0, 0]) cylinder(h = base_t + 2 * eps, d = drain_d);
        }
    }
    // web welding the socket back to the plate
    web_w = od - 2;
    web_h = depth * 0.6;
    translate([-web_w / 2, 0, PLATE - HSW_WELD]) cube([web_w, web_h, or + HSW_WELD]);
}
module rod_holder() {
    hsw_mount(connectors_x, connectors_y, type = connector_type, clearance = clearance,
              straight = (support_style == "grid"), crot = connector_rotation);
    rod_socket();
}
hsw_display() rod_holder();
`);

Open in editor →

HSW Blank Baseplate

A flat blank plate on swappable wall plugs — a starting point to build your own accessory, glue parts to, or mount hardware. Pick the size and plug count.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// HSW Blank Baseplate
//
// Source: honeycomb-wall blank baseplate
// Generated from the library above, used under its license.

/* [Wall mount] */
// How it attaches to the wall
connector_type = "peg";       // [peg:Friction peg (into wall), barepeg:Bare peg (into a latch), latch:Latch insert (into wall), clip:Spring clip (into wall)]
// Plug support style
support_style = "grid";       // [grid:Grid (aligned rows + columns), honeycomb:Honeycomb (staggered, denser)]
// Rotate the plug pattern (to match a wall mounted sideways)
connector_rotation = 0;       // [0:0 degrees, 90:90 degrees]
// Hex connectors across
connectors_x = 2;             // [1:8]
// Hex connector rows
connectors_y = 2;             // [1:4]
// Fit tweak: + looser / - tighter
clearance = 0;                // [-0.3:0.05:0.5]

/* [Plate] */
// Pad width (mm)
pad_width = 80;               // [30:200]
// Pad height (mm)
pad_height = 80;              // [30:200]
// Pad thickness added in front (mm)
pad_t = 4;                    // [2:12]

// ============================================================================
//  HSW CONNECTOR TEMPLATE — the single canonical, self-contained connector kit
//  every HSW example inlines VERBATIM so plug spacing + sizing stay identical.
//  OpenSCAD 2021.01-safe. Self-contained: no include/use, no external libraries.
//
//  THE ONE RULE: plugs (hsw_mount) and wall holes (hsw_grid) are placed by the
//  SAME lattice functions hsw_cx()/hsw_cy(), so plug(c,r) == hole(c,r) for ANY
//  count by construction — verified 0.0000 mm deviation for 1..5 in each axis.
//
//  Frame: +Z = wall-normal (out of the wall). Connectors point into -Z (into the
//  wall); the back-plate front face sits at +Z = plate_t; accessory bodies build
//  on the +Z face. UP the wall = +Y, X = horizontal.
//
//  CUSTOMIZER: everything below is in the Hidden group so a product recipe that
//  inlines this template exposes ONLY its own dimensions + connectors_x/y +
//  connector_type + one clearance tweak. The HSW internals are NEVER customer-tunable.
// ============================================================================
/* [Hidden] */
$fn = 48;

// ---- Core hex interface (the 20mm hole a connector plugs into) -------------
HSWX_INSIDE       = 20;                              // hex hole flat-to-flat
HSWX_WALL         = 1.8;                             // shared cell wall thickness
HSWX_OUTSIDE      = HSWX_INSIDE + HSWX_WALL*2;       // 23.6  outside flat-to-flat
HSWX_SIDE         = HSWX_OUTSIDE / sqrt(3);          // ~13.6255 outer side length
HSWX_DEPTH        = 8;                               // panel / plug depth (Std Duty)
HSWX_LOCK_DEPTH   = 5;                               // depth where the lock step starts
HSWX_LOCK_LIP     = 1;                               // 1mm internal lip the barb catches
HSWX_LOCK_CHAMFER = HSWX_LOCK_LIP;                   // 1mm @ 45deg lead-in

// ---- Verified honeycomb lattice (flat-topped hexes, column tiling) ---------
HSW_PITCH_X       = 1.5 * HSWX_SIDE;                 // ~20.4382 column-to-column
HSW_PITCH_Y       = HSWX_OUTSIDE;                    // 23.6    row-to-row in a column
HSW_STAGGER_Y     = HSWX_OUTSIDE / 2;               // 11.8    alternate-column offset

// ---- Shared connector tunables ---------------------------------------------
PEG_FIT_DEFAULT   = 0.35;                            // bare-peg friction clearance
PEG_LEN_DEFAULT   = 7;                               // bare-peg depth into wall (< HSWX_DEPTH)
PLATE_T_DEFAULT   = 3;                               // back-plate thickness (welds depend on it)
HSW_WELD          = 0.6;                              // connector overlap INTO the plate (one fused solid)

// Across-flats -> circumscribed diameter (a $fn=6 cylinder lands on those flats).
// af/sqrt(3)*2 is IDENTICAL to af/cos(30); ONE form library-wide.
function hsw_af_to_d(af) = af / sqrt(3) * 2;

// ============================================================================
//  THE LATTICE — the single source of truth for WHERE connectors/holes go.
//  Bounding-box-centred on the origin for ANY nx/ny (incl. the single-column
//  case): the staggered odd columns only exist when nx>1, so the y-centring of
//  the cluster is conditional on nx>1. hsw_mount AND hsw_grid both call these.
// ============================================================================
function hsw_max_stag(nx) = (nx > 1) ? HSW_STAGGER_Y : 0;     // odd col only exists if nx>1
function hsw_cx(c, nx)    = c*HSW_PITCH_X - (nx-1)*HSW_PITCH_X/2;
function hsw_cy(c, r, nx, ny) =
    r*HSW_PITCH_Y
    - (ny-1)*HSW_PITCH_Y/2
    + ((c % 2 == 1) ? HSW_STAGGER_Y : 0)            // real alternate-column stagger
    - hsw_max_stag(nx)/2;                            // centre the cluster (cond. on nx>1)

// straight=true strip: every-OTHER column, no stagger (the legacy 40.88 strip).
// Use 2*HSW_PITCH_X (=40.8764), NEVER the rounded 40.88 literal.
function hsw_cx_straight(c, nx) = c*(2*HSW_PITCH_X) - (nx-1)*(2*HSW_PITCH_X)/2;

// ============================================================================
//  CONNECTOR 1 — hsw_peg : bare friction press-peg (the de-facto canonical peg).
//  $fn=6 hex prism, across-flats = HSWX_INSIDE - 2*fit, into -Z. Press fit only.
// ============================================================================
module hsw_peg(fit = PEG_FIT_DEFAULT, len = PEG_LEN_DEFAULT) {
    af = HSWX_INSIDE - 2*fit;                        // flat-to-flat, slightly under 20
    // hex prism from z=+HSW_WELD (buried INTO the plate) down to z=-len (into wall),
    // so the peg fuses with any plate occupying z>=0 into ONE solid (no coincident-face seam).
    translate([0, 0, -len])
        cylinder(h = len + HSW_WELD, d = hsw_af_to_d(af), $fn = 6);
}

// ============================================================================
//  CONNECTOR 1b — hsw_bare_peg : the THIN CORE peg (hex-plug-library hexagon_plug)
//  that plugs into a SEPARATE latch insert pre-snapped in the wall — NOT the grid
//  directly. Verbatim dims: 14.7 across-corners, 13 deep. Into -Z, welds the plate.
// ============================================================================
BAREPEG_D   = 14.7;     // across-corners ($fn=6) — source PLUG_HEXAGON_DIAMETER
BAREPEG_LEN = 13;       // source PLUG_LENGTH
module hsw_bare_peg(fit = 0) {
    translate([0, 0, -BAREPEG_LEN])
        cylinder(h = BAREPEG_LEN + HSW_WELD, d = BAREPEG_D - 2*fit, $fn = 6);
}

// ============================================================================
//  hsw_mount(nx, ny, type, plate_t, fit, straight)
//  ONE back-plate (front face +Z = plate_t) carrying an nx*ny connector lattice
//  on -Z, placed by hsw_cx/hsw_cy. type dispatches the per-cell connector.
// ============================================================================
// straight=true  -> GRID support  : pegs on an aligned rectangular grid
//                                    (40.8764 horiz x 23.6 vert, every-other
//                                    honeycomb column -> all land in real holes).
// straight=false -> HONEYCOMB support: pegs follow the staggered hex lattice
//                                    (20.4382 column pitch, odd columns staggered).
module hsw_mount(nx = 1, ny = 1, type = "peg", plate_t = PLATE_T_DEFAULT,
                 clearance = 0, straight = false, margin = 3, crot = 0) {
    // clamp counts so a user 0 (or negative) never yields an empty / garbage mount
    gnx = max(1, nx);
    gny = max(1, ny);
    // per-type base fit (peg=press 0.35, clip=snap 0.15, latch/barepeg=0 lip-tuned)
    // + the product's single user clearance tweak (+ looser / - tighter).
    pfit = (type == "clip" ? CLIP_FIT_DEFAULT
          : (type == "latch" || type == "barepeg") ? 0
          : PEG_FIT_DEFAULT) + clearance;
    // plate footprint spans the lattice + margin. GRID has no stagger; only the
    // staggered honeycomb extends Y by the odd-column stagger.
    spanX = straight ? (gnx-1)*(2*HSW_PITCH_X) : (gnx-1)*HSW_PITCH_X;
    spanY = (gny-1)*HSW_PITCH_Y;
    w = spanX + HSWX_OUTSIDE + 2*margin;
    d = spanY + HSWX_OUTSIDE + (straight ? 0 : hsw_max_stag(gnx)) + 2*margin;
    // crot rotates the PLUG PATTERN (plate + connectors, together so plugs stay on
    // the plate) about the wall normal so the accessory can match a wall installed
    // rotated 90deg. The body is built separately by the recipe and is NOT rotated
    // (plug layout only — body fixed).
    rotate([0, 0, crot]) {
        translate([0, 0, plate_t/2]) cube([w, d, plate_t], center = true);   // plate
        for (c = [0 : gnx-1])
            for (r = [0 : gny-1]) {
                x = straight ? hsw_cx_straight(c, gnx) : hsw_cx(c, gnx);
                y = straight ? (r*HSW_PITCH_Y - spanY/2) : hsw_cy(c, r, gnx, gny);
                translate([x, y, 0]) hsw_connector(type, pfit);
            }
    }
}

// ============================================================================
//  CONNECTOR 2 — hsw_latch_insert : snap-tab latching insert (vanilla port of
//  hex-plug-library / hsw-custom-insert, sh1-verified). Built front-face(lip) at
//  z=0 with body in +Z, then flipped to -Z and welded into the plate.
// ============================================================================
INSERT_BODY_FLATS = 19.7;   INSERT_LIP_FLATS = 22.5;   INSERT_TOTAL_H = 10;
INSERT_LIP_H = 2.5;         INSERT_SNAP_H = 6.5;       INSERT_TAB_OUT = 0.5;
INSERT_TAB_LEN = 2;         INSERT_SLOT_LEN = 8;       INSERT_SLOT_W = 0.8;
INSERT_SLOT_SIDE = 1;       INSERT_SLOT_RAD = 8.25;

module _hsw_bevel_cut(diameter) {
    h = diameter/2;                                     // tan(45)==1
    difference() { cylinder(d = diameter*2, h = h); cylinder(d1 = diameter, d2 = 0, h = h); }
}
module _hsw_insert_body(fit) {
    bodyD = hsw_af_to_d(INSERT_BODY_FLATS - 2*fit);
    lipD  = hsw_af_to_d(INSERT_LIP_FLATS);
    difference() {
        union() {
            cylinder(d = bodyD, h = INSERT_TOTAL_H, $fn = 6);   // main plug
            cylinder(d = lipD,  h = INSERT_LIP_H,  $fn = 6);    // overhang lip
        }
        translate([0,0,INSERT_TOTAL_H - 0.35]) _hsw_bevel_cut(bodyD);   // soften top edge
    }
}
module hsw_latch_insert(fit = 0) {
    translate([0,0,HSW_WELD]) rotate([180,0,0])
    union() {
        // six snap tabs (non-degenerate tip r=0.2, tops kept below the bevel)
        for (i=[0:5]) rotate([0,0,i*60]) translate([0, INSERT_BODY_FLATS/2, 0])
            hull() {
                translate([0,0,INSERT_SNAP_H + INSERT_SLOT_SIDE + INSERT_TAB_OUT])
                    rotate([0,90,0]) cylinder(r = INSERT_TAB_OUT, h = INSERT_TAB_LEN, center=true, $fn=20);
                translate([0,0,INSERT_TOTAL_H - 0.6])
                    rotate([0,90,0]) cylinder(r = 0.2, h = INSERT_TAB_LEN, center=true, $fn=20);
            }
        // body with flex slots so each tab deflects on insertion
        difference() {
            _hsw_insert_body(fit);
            for (i=[0:5]) rotate([0,0,i*60]) {
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_SLOT_W, INSERT_TOTAL_H]);
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_TOTAL_H, INSERT_SLOT_SIDE]);
            }
        }
    }
}

// ============================================================================
//  CONNECTOR 3 — hsw_clip : spring snap clip (from hsw-lib-core, sh1-verified).
//  Two cantilever arms catch the 1mm lip at 5mm depth. Mouth at z=0 into -Z.
// ============================================================================
CLIP_FIT_DEFAULT = 0.15;
CLIP_AF  = HSWX_INSIDE;      // 20 plug across-flats target
CLIP_LEN = HSWX_DEPTH;       // 8  plug length into the wall
SPRING_WALL = 1.6;           // cantilever arm wall (>=1.4 to flex)
SPRING_SLOT = 2.2;           // central relief slot width
module hsw_clip(fit = CLIP_FIT_DEFAULT) {
    af = CLIP_AF - 2*fit;  L = CLIP_LEN;
    barb = HSWX_LOCK_LIP;  locz = HSWX_LOCK_DEPTH;  cham = HSWX_LOCK_CHAMFER;  halfX = af/2;
    translate([0,0,HSW_WELD])
    difference() {
        union() {
            translate([0,0,-L/2]) linear_extrude(height = L, center = true) hsw_hex2d(af);   // hex plug
            for (sx=[-1,1]) translate([sx*halfX,0,-locz]) rotate([90,0,0])                    // outward barbs
                linear_extrude(height = af*0.62, center = true)
                    polygon([[0,0],[sx*barb,0],[sx*barb,cham],[0,cham+barb]]);
            translate([0,0,0.6/2]) linear_extrude(height = 0.6, center = true) hsw_hex2d(af + 1.2);  // mouth flange
        }
        translate([0,0,-L/2-0.5]) cube([SPRING_SLOT, af+4, L+2-1.2], center = true);          // central relief slot
        for (sx=[-1,1]) translate([sx*(halfX-SPRING_WALL-0.3),0,-L/2-1]) cube([1.4, af*0.5, L], center=true);  // arm hollow
    }
}

// per-cell connector dispatch:
//   peg     = friction peg, jams the bare grid hole (one-part)
//   barepeg = thin core peg, plugs into a SEPARATE latch pre-snapped in the wall
//   latch   = snap-tab insert, snaps into the bare grid hole
//   clip    = spring clip, snaps into the bare grid hole
module hsw_connector(type = "peg", fit = PEG_FIT_DEFAULT) {
    if      (type == "latch")   hsw_latch_insert(fit);
    else if (type == "clip")    hsw_clip(fit);
    else if (type == "barepeg") hsw_bare_peg(fit);
    else                        hsw_peg(fit);
}

// ============================================================================
//  hsw_grid(nx, ny, depth) — the FEMALE wall panel. Holes placed by the SAME
//  hsw_cx/hsw_cy so a hsw_mount(nx,ny) co-registers EXACTLY (proof artifact).
//  Lipped hex socket: 20mm bore, 1mm catch lip at 5mm depth.
// ============================================================================
module hsw_hex2d(af) { rotate([0,0,90]) circle(r = af/sqrt(3), $fn = 6); }

module hsw_hex_hole(depth) {
    afMouth = HSWX_INSIDE + 2*HSWX_LOCK_CHAMFER;
    afFull  = HSWX_INSIDE;
    afLip   = HSWX_INSIDE - 2*HSWX_LOCK_LIP;
    translate([0,0,-HSWX_LOCK_CHAMFER/2 + 0.01])
        linear_extrude(HSWX_LOCK_CHAMFER + 0.02, center=true, scale = afFull/afMouth) hsw_hex2d(afMouth);
    translate([0,0,-HSWX_LOCK_DEPTH/2])
        linear_extrude(HSWX_LOCK_DEPTH + 0.02, center=true) hsw_hex2d(afFull);
    translate([0,0,-HSWX_LOCK_DEPTH])
        linear_extrude(0.6, center=true) hsw_hex2d(afLip);
    backLen = depth - HSWX_LOCK_DEPTH;
    if (backLen > 0.1)
        translate([0,0,-(HSWX_LOCK_DEPTH + backLen/2)])
            linear_extrude(backLen + 0.4, center=true) hsw_hex2d(afFull);
}

module hsw_grid(nx = 3, ny = 3, depth = HSWX_DEPTH) {
    spanX = (nx-1)*HSW_PITCH_X;
    spanY = (ny-1)*HSW_PITCH_Y;
    slabW = spanX + HSWX_OUTSIDE;
    slabD = spanY + HSWX_OUTSIDE + hsw_max_stag(nx);
    difference() {
        translate([0, -hsw_max_stag(nx)/2, -depth/2]) cube([slabW, slabD, depth], center = true);
        for (c = [0 : nx-1])
            for (r = [0 : ny-1])
                translate([hsw_cx(c, nx), hsw_cy(c, r, nx, ny), 0]) hsw_hex_hole(depth);
    }
}

// ============================================================================
//  hsw_display() — canonical AnimBox display orientation. The geometry is built
//  in the OpenSCAD print frame (scad +Z = wall normal, +Y = up the wall). The
//  The OpenSCAD->AnimBox import is IDENTITY (verified by bbox: cube([10,20,40])
//  imports to world [10,20,40]). The wall-frame is already the display frame:
//  up-the-wall (+Y) = world UP, along-the-wall (+X) = world X, wall normal (+Z)
//  = toward the viewer (the body projects out of the wall). So hsw_display() is a
//  pass-through; it stays as the single place to adjust display orientation if the
//  import convention ever changes. Wrap every recipe's top call: hsw_display() my_part();
// ============================================================================
module hsw_display() { children(); }

// ---- product body (hidden internals) ----
PLATE = PLATE_T_DEFAULT;

module baseplate_pad() {
    // a flat pad welded onto the +Z plate face (the blank build surface)
    translate([-pad_width / 2, -pad_height / 2, PLATE - HSW_WELD])
        cube([pad_width, pad_height, pad_t + HSW_WELD]);
}
module baseplate() {
    hsw_mount(connectors_x, connectors_y, type = connector_type, clearance = clearance,
              straight = (support_style == "grid"), crot = connector_rotation);
    baseplate_pad();
}
hsw_display() baseplate();
`);

Open in editor →

HSW Brush / Marker Cup

A tall, narrow cup for paintbrushes, markers, files, or long slim tools — keeps them upright and visible. Optional drain. Swappable wall plugs.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// HSW Brush / Marker Cup
//
// Source: honeycomb-wall tall brush cup
// Generated from the library above, used under its license.

/* [Wall mount] */
// How it attaches to the wall
connector_type = "peg";       // [peg:Friction peg (into wall), barepeg:Bare peg (into a latch), latch:Latch insert (into wall), clip:Spring clip (into wall)]
// Plug support style
support_style = "grid";       // [grid:Grid (aligned rows + columns), honeycomb:Honeycomb (staggered, denser)]
// Rotate the plug pattern (to match a wall mounted sideways)
connector_rotation = 0;       // [0:0 degrees, 90:90 degrees]
// Hex connectors across
connectors_x = 1;             // [1:8]
// Hex connector rows (2 = better for a tall cup)
connectors_y = 2;             // [1:4]
// Fit tweak: + looser / - tighter
clearance = 0;                // [-0.3:0.05:0.5]

/* [Cup] */
// Inner bore diameter (mm)
cup_inner_d = 36;             // [18:70]
// Side wall thickness (mm)
cup_wall = 2.4;               // [1.2:0.2:4]
// Cup height (mm)
cup_height = 85;              // [40:160]
// Base thickness (mm)
cup_base_t = 2.4;             // [1.2:0.2:5]
// Drain hole through the base
drain = true;
// Drain hole diameter (mm)
drain_d = 6;                  // [3:16]

// ============================================================================
//  HSW CONNECTOR TEMPLATE — the single canonical, self-contained connector kit
//  every HSW example inlines VERBATIM so plug spacing + sizing stay identical.
//  OpenSCAD 2021.01-safe. Self-contained: no include/use, no external libraries.
//
//  THE ONE RULE: plugs (hsw_mount) and wall holes (hsw_grid) are placed by the
//  SAME lattice functions hsw_cx()/hsw_cy(), so plug(c,r) == hole(c,r) for ANY
//  count by construction — verified 0.0000 mm deviation for 1..5 in each axis.
//
//  Frame: +Z = wall-normal (out of the wall). Connectors point into -Z (into the
//  wall); the back-plate front face sits at +Z = plate_t; accessory bodies build
//  on the +Z face. UP the wall = +Y, X = horizontal.
//
//  CUSTOMIZER: everything below is in the Hidden group so a product recipe that
//  inlines this template exposes ONLY its own dimensions + connectors_x/y +
//  connector_type + one clearance tweak. The HSW internals are NEVER customer-tunable.
// ============================================================================
/* [Hidden] */
$fn = 48;

// ---- Core hex interface (the 20mm hole a connector plugs into) -------------
HSWX_INSIDE       = 20;                              // hex hole flat-to-flat
HSWX_WALL         = 1.8;                             // shared cell wall thickness
HSWX_OUTSIDE      = HSWX_INSIDE + HSWX_WALL*2;       // 23.6  outside flat-to-flat
HSWX_SIDE         = HSWX_OUTSIDE / sqrt(3);          // ~13.6255 outer side length
HSWX_DEPTH        = 8;                               // panel / plug depth (Std Duty)
HSWX_LOCK_DEPTH   = 5;                               // depth where the lock step starts
HSWX_LOCK_LIP     = 1;                               // 1mm internal lip the barb catches
HSWX_LOCK_CHAMFER = HSWX_LOCK_LIP;                   // 1mm @ 45deg lead-in

// ---- Verified honeycomb lattice (flat-topped hexes, column tiling) ---------
HSW_PITCH_X       = 1.5 * HSWX_SIDE;                 // ~20.4382 column-to-column
HSW_PITCH_Y       = HSWX_OUTSIDE;                    // 23.6    row-to-row in a column
HSW_STAGGER_Y     = HSWX_OUTSIDE / 2;               // 11.8    alternate-column offset

// ---- Shared connector tunables ---------------------------------------------
PEG_FIT_DEFAULT   = 0.35;                            // bare-peg friction clearance
PEG_LEN_DEFAULT   = 7;                               // bare-peg depth into wall (< HSWX_DEPTH)
PLATE_T_DEFAULT   = 3;                               // back-plate thickness (welds depend on it)
HSW_WELD          = 0.6;                              // connector overlap INTO the plate (one fused solid)

// Across-flats -> circumscribed diameter (a $fn=6 cylinder lands on those flats).
// af/sqrt(3)*2 is IDENTICAL to af/cos(30); ONE form library-wide.
function hsw_af_to_d(af) = af / sqrt(3) * 2;

// ============================================================================
//  THE LATTICE — the single source of truth for WHERE connectors/holes go.
//  Bounding-box-centred on the origin for ANY nx/ny (incl. the single-column
//  case): the staggered odd columns only exist when nx>1, so the y-centring of
//  the cluster is conditional on nx>1. hsw_mount AND hsw_grid both call these.
// ============================================================================
function hsw_max_stag(nx) = (nx > 1) ? HSW_STAGGER_Y : 0;     // odd col only exists if nx>1
function hsw_cx(c, nx)    = c*HSW_PITCH_X - (nx-1)*HSW_PITCH_X/2;
function hsw_cy(c, r, nx, ny) =
    r*HSW_PITCH_Y
    - (ny-1)*HSW_PITCH_Y/2
    + ((c % 2 == 1) ? HSW_STAGGER_Y : 0)            // real alternate-column stagger
    - hsw_max_stag(nx)/2;                            // centre the cluster (cond. on nx>1)

// straight=true strip: every-OTHER column, no stagger (the legacy 40.88 strip).
// Use 2*HSW_PITCH_X (=40.8764), NEVER the rounded 40.88 literal.
function hsw_cx_straight(c, nx) = c*(2*HSW_PITCH_X) - (nx-1)*(2*HSW_PITCH_X)/2;

// ============================================================================
//  CONNECTOR 1 — hsw_peg : bare friction press-peg (the de-facto canonical peg).
//  $fn=6 hex prism, across-flats = HSWX_INSIDE - 2*fit, into -Z. Press fit only.
// ============================================================================
module hsw_peg(fit = PEG_FIT_DEFAULT, len = PEG_LEN_DEFAULT) {
    af = HSWX_INSIDE - 2*fit;                        // flat-to-flat, slightly under 20
    // hex prism from z=+HSW_WELD (buried INTO the plate) down to z=-len (into wall),
    // so the peg fuses with any plate occupying z>=0 into ONE solid (no coincident-face seam).
    translate([0, 0, -len])
        cylinder(h = len + HSW_WELD, d = hsw_af_to_d(af), $fn = 6);
}

// ============================================================================
//  CONNECTOR 1b — hsw_bare_peg : the THIN CORE peg (hex-plug-library hexagon_plug)
//  that plugs into a SEPARATE latch insert pre-snapped in the wall — NOT the grid
//  directly. Verbatim dims: 14.7 across-corners, 13 deep. Into -Z, welds the plate.
// ============================================================================
BAREPEG_D   = 14.7;     // across-corners ($fn=6) — source PLUG_HEXAGON_DIAMETER
BAREPEG_LEN = 13;       // source PLUG_LENGTH
module hsw_bare_peg(fit = 0) {
    translate([0, 0, -BAREPEG_LEN])
        cylinder(h = BAREPEG_LEN + HSW_WELD, d = BAREPEG_D - 2*fit, $fn = 6);
}

// ============================================================================
//  hsw_mount(nx, ny, type, plate_t, fit, straight)
//  ONE back-plate (front face +Z = plate_t) carrying an nx*ny connector lattice
//  on -Z, placed by hsw_cx/hsw_cy. type dispatches the per-cell connector.
// ============================================================================
// straight=true  -> GRID support  : pegs on an aligned rectangular grid
//                                    (40.8764 horiz x 23.6 vert, every-other
//                                    honeycomb column -> all land in real holes).
// straight=false -> HONEYCOMB support: pegs follow the staggered hex lattice
//                                    (20.4382 column pitch, odd columns staggered).
module hsw_mount(nx = 1, ny = 1, type = "peg", plate_t = PLATE_T_DEFAULT,
                 clearance = 0, straight = false, margin = 3, crot = 0) {
    // clamp counts so a user 0 (or negative) never yields an empty / garbage mount
    gnx = max(1, nx);
    gny = max(1, ny);
    // per-type base fit (peg=press 0.35, clip=snap 0.15, latch/barepeg=0 lip-tuned)
    // + the product's single user clearance tweak (+ looser / - tighter).
    pfit = (type == "clip" ? CLIP_FIT_DEFAULT
          : (type == "latch" || type == "barepeg") ? 0
          : PEG_FIT_DEFAULT) + clearance;
    // plate footprint spans the lattice + margin. GRID has no stagger; only the
    // staggered honeycomb extends Y by the odd-column stagger.
    spanX = straight ? (gnx-1)*(2*HSW_PITCH_X) : (gnx-1)*HSW_PITCH_X;
    spanY = (gny-1)*HSW_PITCH_Y;
    w = spanX + HSWX_OUTSIDE + 2*margin;
    d = spanY + HSWX_OUTSIDE + (straight ? 0 : hsw_max_stag(gnx)) + 2*margin;
    // crot rotates the PLUG PATTERN (plate + connectors, together so plugs stay on
    // the plate) about the wall normal so the accessory can match a wall installed
    // rotated 90deg. The body is built separately by the recipe and is NOT rotated
    // (plug layout only — body fixed).
    rotate([0, 0, crot]) {
        translate([0, 0, plate_t/2]) cube([w, d, plate_t], center = true);   // plate
        for (c = [0 : gnx-1])
            for (r = [0 : gny-1]) {
                x = straight ? hsw_cx_straight(c, gnx) : hsw_cx(c, gnx);
                y = straight ? (r*HSW_PITCH_Y - spanY/2) : hsw_cy(c, r, gnx, gny);
                translate([x, y, 0]) hsw_connector(type, pfit);
            }
    }
}

// ============================================================================
//  CONNECTOR 2 — hsw_latch_insert : snap-tab latching insert (vanilla port of
//  hex-plug-library / hsw-custom-insert, sh1-verified). Built front-face(lip) at
//  z=0 with body in +Z, then flipped to -Z and welded into the plate.
// ============================================================================
INSERT_BODY_FLATS = 19.7;   INSERT_LIP_FLATS = 22.5;   INSERT_TOTAL_H = 10;
INSERT_LIP_H = 2.5;         INSERT_SNAP_H = 6.5;       INSERT_TAB_OUT = 0.5;
INSERT_TAB_LEN = 2;         INSERT_SLOT_LEN = 8;       INSERT_SLOT_W = 0.8;
INSERT_SLOT_SIDE = 1;       INSERT_SLOT_RAD = 8.25;

module _hsw_bevel_cut(diameter) {
    h = diameter/2;                                     // tan(45)==1
    difference() { cylinder(d = diameter*2, h = h); cylinder(d1 = diameter, d2 = 0, h = h); }
}
module _hsw_insert_body(fit) {
    bodyD = hsw_af_to_d(INSERT_BODY_FLATS - 2*fit);
    lipD  = hsw_af_to_d(INSERT_LIP_FLATS);
    difference() {
        union() {
            cylinder(d = bodyD, h = INSERT_TOTAL_H, $fn = 6);   // main plug
            cylinder(d = lipD,  h = INSERT_LIP_H,  $fn = 6);    // overhang lip
        }
        translate([0,0,INSERT_TOTAL_H - 0.35]) _hsw_bevel_cut(bodyD);   // soften top edge
    }
}
module hsw_latch_insert(fit = 0) {
    translate([0,0,HSW_WELD]) rotate([180,0,0])
    union() {
        // six snap tabs (non-degenerate tip r=0.2, tops kept below the bevel)
        for (i=[0:5]) rotate([0,0,i*60]) translate([0, INSERT_BODY_FLATS/2, 0])
            hull() {
                translate([0,0,INSERT_SNAP_H + INSERT_SLOT_SIDE + INSERT_TAB_OUT])
                    rotate([0,90,0]) cylinder(r = INSERT_TAB_OUT, h = INSERT_TAB_LEN, center=true, $fn=20);
                translate([0,0,INSERT_TOTAL_H - 0.6])
                    rotate([0,90,0]) cylinder(r = 0.2, h = INSERT_TAB_LEN, center=true, $fn=20);
            }
        // body with flex slots so each tab deflects on insertion
        difference() {
            _hsw_insert_body(fit);
            for (i=[0:5]) rotate([0,0,i*60]) {
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_SLOT_W, INSERT_TOTAL_H]);
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_TOTAL_H, INSERT_SLOT_SIDE]);
            }
        }
    }
}

// ============================================================================
//  CONNECTOR 3 — hsw_clip : spring snap clip (from hsw-lib-core, sh1-verified).
//  Two cantilever arms catch the 1mm lip at 5mm depth. Mouth at z=0 into -Z.
// ============================================================================
CLIP_FIT_DEFAULT = 0.15;
CLIP_AF  = HSWX_INSIDE;      // 20 plug across-flats target
CLIP_LEN = HSWX_DEPTH;       // 8  plug length into the wall
SPRING_WALL = 1.6;           // cantilever arm wall (>=1.4 to flex)
SPRING_SLOT = 2.2;           // central relief slot width
module hsw_clip(fit = CLIP_FIT_DEFAULT) {
    af = CLIP_AF - 2*fit;  L = CLIP_LEN;
    barb = HSWX_LOCK_LIP;  locz = HSWX_LOCK_DEPTH;  cham = HSWX_LOCK_CHAMFER;  halfX = af/2;
    translate([0,0,HSW_WELD])
    difference() {
        union() {
            translate([0,0,-L/2]) linear_extrude(height = L, center = true) hsw_hex2d(af);   // hex plug
            for (sx=[-1,1]) translate([sx*halfX,0,-locz]) rotate([90,0,0])                    // outward barbs
                linear_extrude(height = af*0.62, center = true)
                    polygon([[0,0],[sx*barb,0],[sx*barb,cham],[0,cham+barb]]);
            translate([0,0,0.6/2]) linear_extrude(height = 0.6, center = true) hsw_hex2d(af + 1.2);  // mouth flange
        }
        translate([0,0,-L/2-0.5]) cube([SPRING_SLOT, af+4, L+2-1.2], center = true);          // central relief slot
        for (sx=[-1,1]) translate([sx*(halfX-SPRING_WALL-0.3),0,-L/2-1]) cube([1.4, af*0.5, L], center=true);  // arm hollow
    }
}

// per-cell connector dispatch:
//   peg     = friction peg, jams the bare grid hole (one-part)
//   barepeg = thin core peg, plugs into a SEPARATE latch pre-snapped in the wall
//   latch   = snap-tab insert, snaps into the bare grid hole
//   clip    = spring clip, snaps into the bare grid hole
module hsw_connector(type = "peg", fit = PEG_FIT_DEFAULT) {
    if      (type == "latch")   hsw_latch_insert(fit);
    else if (type == "clip")    hsw_clip(fit);
    else if (type == "barepeg") hsw_bare_peg(fit);
    else                        hsw_peg(fit);
}

// ============================================================================
//  hsw_grid(nx, ny, depth) — the FEMALE wall panel. Holes placed by the SAME
//  hsw_cx/hsw_cy so a hsw_mount(nx,ny) co-registers EXACTLY (proof artifact).
//  Lipped hex socket: 20mm bore, 1mm catch lip at 5mm depth.
// ============================================================================
module hsw_hex2d(af) { rotate([0,0,90]) circle(r = af/sqrt(3), $fn = 6); }

module hsw_hex_hole(depth) {
    afMouth = HSWX_INSIDE + 2*HSWX_LOCK_CHAMFER;
    afFull  = HSWX_INSIDE;
    afLip   = HSWX_INSIDE - 2*HSWX_LOCK_LIP;
    translate([0,0,-HSWX_LOCK_CHAMFER/2 + 0.01])
        linear_extrude(HSWX_LOCK_CHAMFER + 0.02, center=true, scale = afFull/afMouth) hsw_hex2d(afMouth);
    translate([0,0,-HSWX_LOCK_DEPTH/2])
        linear_extrude(HSWX_LOCK_DEPTH + 0.02, center=true) hsw_hex2d(afFull);
    translate([0,0,-HSWX_LOCK_DEPTH])
        linear_extrude(0.6, center=true) hsw_hex2d(afLip);
    backLen = depth - HSWX_LOCK_DEPTH;
    if (backLen > 0.1)
        translate([0,0,-(HSWX_LOCK_DEPTH + backLen/2)])
            linear_extrude(backLen + 0.4, center=true) hsw_hex2d(afFull);
}

module hsw_grid(nx = 3, ny = 3, depth = HSWX_DEPTH) {
    spanX = (nx-1)*HSW_PITCH_X;
    spanY = (ny-1)*HSW_PITCH_Y;
    slabW = spanX + HSWX_OUTSIDE;
    slabD = spanY + HSWX_OUTSIDE + hsw_max_stag(nx);
    difference() {
        translate([0, -hsw_max_stag(nx)/2, -depth/2]) cube([slabW, slabD, depth], center = true);
        for (c = [0 : nx-1])
            for (r = [0 : ny-1])
                translate([hsw_cx(c, nx), hsw_cy(c, r, nx, ny), 0]) hsw_hex_hole(depth);
    }
}

// ============================================================================
//  hsw_display() — canonical AnimBox display orientation. The geometry is built
//  in the OpenSCAD print frame (scad +Z = wall normal, +Y = up the wall). The
//  The OpenSCAD->AnimBox import is IDENTITY (verified by bbox: cube([10,20,40])
//  imports to world [10,20,40]). The wall-frame is already the display frame:
//  up-the-wall (+Y) = world UP, along-the-wall (+X) = world X, wall normal (+Z)
//  = toward the viewer (the body projects out of the wall). So hsw_display() is a
//  pass-through; it stays as the single place to adjust display orientation if the
//  import convention ever changes. Wrap every recipe's top call: hsw_display() my_part();
// ============================================================================
module hsw_display() { children(); }

// ---- product body (hidden internals) ----
eps   = 0.05;
PLATE = PLATE_T_DEFAULT;

module brush_cup_body() {
    cup_outer_d = cup_inner_d + 2 * cup_wall;
    cup_outer_r = cup_outer_d / 2;
    translate([0, 0, PLATE + cup_outer_r]) {
        difference() {
            rotate([-90, 0, 0]) cylinder(h = cup_height, d = cup_outer_d);
            translate([0, cup_base_t, 0]) rotate([-90, 0, 0])
                cylinder(h = cup_height - cup_base_t + eps, d = cup_inner_d);
            if (drain)
                translate([0, -eps, 0]) rotate([-90, 0, 0])
                    cylinder(h = cup_base_t + 2 * eps, d = drain_d);
        }
    }
    // web welding the cup back to the plate face
    web_w = cup_outer_d - 2;
    web_h = cup_height * 0.6;
    translate([-web_w / 2, 0, PLATE - HSW_WELD])
        cube([web_w, web_h, cup_outer_r + HSW_WELD]);
}
module brush_cup() {
    hsw_mount(connectors_x, connectors_y, type = connector_type, clearance = clearance,
              straight = (support_style == "grid"), crot = connector_rotation);
    brush_cup_body();
}
hsw_display() brush_cup();
`);

Open in editor →

HSW Plier / Cutter Rack

A row of wide slots that hold pliers, cutters, and snips by the handle, tips hanging down. Choose how many. Swappable wall plugs.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// HSW Plier / Cutter Rack
//
// Source: honeycomb-wall plier rack
// Generated from the library above, used under its license.

/* [Wall mount] */
// How it attaches to the wall
connector_type = "peg";       // [peg:Friction peg (into wall), barepeg:Bare peg (into a latch), latch:Latch insert (into wall), clip:Spring clip (into wall)]
// Plug support style
support_style = "grid";       // [grid:Grid (aligned rows + columns), honeycomb:Honeycomb (staggered, denser)]
// Rotate the plug pattern (to match a wall mounted sideways)
connector_rotation = 0;       // [0:0 degrees, 90:90 degrees]
// Hex connectors across (a wide rack wants 3+)
connectors_x = 3;             // [1:8]
// Hex connector rows
connectors_y = 1;             // [1:4]
// Fit tweak: + looser / - tighter
clearance = 0;                // [-0.3:0.05:0.5]

/* [Rack] */
// Number of tool slots
slots = 4;                    // [1:8]
// Slot width — fits the plier head (mm)
slot_w = 14;                  // [6:30]
// Slot length across the shelf (mm)
slot_len = 24;               // [10:50]
// Spacing between slots (mm)
spacing = 30;                // [16:60]
// Shelf thickness (mm)
shelf_t = 10;                // [5:20]
// Shelf height up the wall (mm)
shelf_y = 0;                 // [-25:30]

// ============================================================================
//  HSW CONNECTOR TEMPLATE — the single canonical, self-contained connector kit
//  every HSW example inlines VERBATIM so plug spacing + sizing stay identical.
//  OpenSCAD 2021.01-safe. Self-contained: no include/use, no external libraries.
//
//  THE ONE RULE: plugs (hsw_mount) and wall holes (hsw_grid) are placed by the
//  SAME lattice functions hsw_cx()/hsw_cy(), so plug(c,r) == hole(c,r) for ANY
//  count by construction — verified 0.0000 mm deviation for 1..5 in each axis.
//
//  Frame: +Z = wall-normal (out of the wall). Connectors point into -Z (into the
//  wall); the back-plate front face sits at +Z = plate_t; accessory bodies build
//  on the +Z face. UP the wall = +Y, X = horizontal.
//
//  CUSTOMIZER: everything below is in the Hidden group so a product recipe that
//  inlines this template exposes ONLY its own dimensions + connectors_x/y +
//  connector_type + one clearance tweak. The HSW internals are NEVER customer-tunable.
// ============================================================================
/* [Hidden] */
$fn = 48;

// ---- Core hex interface (the 20mm hole a connector plugs into) -------------
HSWX_INSIDE       = 20;                              // hex hole flat-to-flat
HSWX_WALL         = 1.8;                             // shared cell wall thickness
HSWX_OUTSIDE      = HSWX_INSIDE + HSWX_WALL*2;       // 23.6  outside flat-to-flat
HSWX_SIDE         = HSWX_OUTSIDE / sqrt(3);          // ~13.6255 outer side length
HSWX_DEPTH        = 8;                               // panel / plug depth (Std Duty)
HSWX_LOCK_DEPTH   = 5;                               // depth where the lock step starts
HSWX_LOCK_LIP     = 1;                               // 1mm internal lip the barb catches
HSWX_LOCK_CHAMFER = HSWX_LOCK_LIP;                   // 1mm @ 45deg lead-in

// ---- Verified honeycomb lattice (flat-topped hexes, column tiling) ---------
HSW_PITCH_X       = 1.5 * HSWX_SIDE;                 // ~20.4382 column-to-column
HSW_PITCH_Y       = HSWX_OUTSIDE;                    // 23.6    row-to-row in a column
HSW_STAGGER_Y     = HSWX_OUTSIDE / 2;               // 11.8    alternate-column offset

// ---- Shared connector tunables ---------------------------------------------
PEG_FIT_DEFAULT   = 0.35;                            // bare-peg friction clearance
PEG_LEN_DEFAULT   = 7;                               // bare-peg depth into wall (< HSWX_DEPTH)
PLATE_T_DEFAULT   = 3;                               // back-plate thickness (welds depend on it)
HSW_WELD          = 0.6;                              // connector overlap INTO the plate (one fused solid)

// Across-flats -> circumscribed diameter (a $fn=6 cylinder lands on those flats).
// af/sqrt(3)*2 is IDENTICAL to af/cos(30); ONE form library-wide.
function hsw_af_to_d(af) = af / sqrt(3) * 2;

// ============================================================================
//  THE LATTICE — the single source of truth for WHERE connectors/holes go.
//  Bounding-box-centred on the origin for ANY nx/ny (incl. the single-column
//  case): the staggered odd columns only exist when nx>1, so the y-centring of
//  the cluster is conditional on nx>1. hsw_mount AND hsw_grid both call these.
// ============================================================================
function hsw_max_stag(nx) = (nx > 1) ? HSW_STAGGER_Y : 0;     // odd col only exists if nx>1
function hsw_cx(c, nx)    = c*HSW_PITCH_X - (nx-1)*HSW_PITCH_X/2;
function hsw_cy(c, r, nx, ny) =
    r*HSW_PITCH_Y
    - (ny-1)*HSW_PITCH_Y/2
    + ((c % 2 == 1) ? HSW_STAGGER_Y : 0)            // real alternate-column stagger
    - hsw_max_stag(nx)/2;                            // centre the cluster (cond. on nx>1)

// straight=true strip: every-OTHER column, no stagger (the legacy 40.88 strip).
// Use 2*HSW_PITCH_X (=40.8764), NEVER the rounded 40.88 literal.
function hsw_cx_straight(c, nx) = c*(2*HSW_PITCH_X) - (nx-1)*(2*HSW_PITCH_X)/2;

// ============================================================================
//  CONNECTOR 1 — hsw_peg : bare friction press-peg (the de-facto canonical peg).
//  $fn=6 hex prism, across-flats = HSWX_INSIDE - 2*fit, into -Z. Press fit only.
// ============================================================================
module hsw_peg(fit = PEG_FIT_DEFAULT, len = PEG_LEN_DEFAULT) {
    af = HSWX_INSIDE - 2*fit;                        // flat-to-flat, slightly under 20
    // hex prism from z=+HSW_WELD (buried INTO the plate) down to z=-len (into wall),
    // so the peg fuses with any plate occupying z>=0 into ONE solid (no coincident-face seam).
    translate([0, 0, -len])
        cylinder(h = len + HSW_WELD, d = hsw_af_to_d(af), $fn = 6);
}

// ============================================================================
//  CONNECTOR 1b — hsw_bare_peg : the THIN CORE peg (hex-plug-library hexagon_plug)
//  that plugs into a SEPARATE latch insert pre-snapped in the wall — NOT the grid
//  directly. Verbatim dims: 14.7 across-corners, 13 deep. Into -Z, welds the plate.
// ============================================================================
BAREPEG_D   = 14.7;     // across-corners ($fn=6) — source PLUG_HEXAGON_DIAMETER
BAREPEG_LEN = 13;       // source PLUG_LENGTH
module hsw_bare_peg(fit = 0) {
    translate([0, 0, -BAREPEG_LEN])
        cylinder(h = BAREPEG_LEN + HSW_WELD, d = BAREPEG_D - 2*fit, $fn = 6);
}

// ============================================================================
//  hsw_mount(nx, ny, type, plate_t, fit, straight)
//  ONE back-plate (front face +Z = plate_t) carrying an nx*ny connector lattice
//  on -Z, placed by hsw_cx/hsw_cy. type dispatches the per-cell connector.
// ============================================================================
// straight=true  -> GRID support  : pegs on an aligned rectangular grid
//                                    (40.8764 horiz x 23.6 vert, every-other
//                                    honeycomb column -> all land in real holes).
// straight=false -> HONEYCOMB support: pegs follow the staggered hex lattice
//                                    (20.4382 column pitch, odd columns staggered).
module hsw_mount(nx = 1, ny = 1, type = "peg", plate_t = PLATE_T_DEFAULT,
                 clearance = 0, straight = false, margin = 3, crot = 0) {
    // clamp counts so a user 0 (or negative) never yields an empty / garbage mount
    gnx = max(1, nx);
    gny = max(1, ny);
    // per-type base fit (peg=press 0.35, clip=snap 0.15, latch/barepeg=0 lip-tuned)
    // + the product's single user clearance tweak (+ looser / - tighter).
    pfit = (type == "clip" ? CLIP_FIT_DEFAULT
          : (type == "latch" || type == "barepeg") ? 0
          : PEG_FIT_DEFAULT) + clearance;
    // plate footprint spans the lattice + margin. GRID has no stagger; only the
    // staggered honeycomb extends Y by the odd-column stagger.
    spanX = straight ? (gnx-1)*(2*HSW_PITCH_X) : (gnx-1)*HSW_PITCH_X;
    spanY = (gny-1)*HSW_PITCH_Y;
    w = spanX + HSWX_OUTSIDE + 2*margin;
    d = spanY + HSWX_OUTSIDE + (straight ? 0 : hsw_max_stag(gnx)) + 2*margin;
    // crot rotates the PLUG PATTERN (plate + connectors, together so plugs stay on
    // the plate) about the wall normal so the accessory can match a wall installed
    // rotated 90deg. The body is built separately by the recipe and is NOT rotated
    // (plug layout only — body fixed).
    rotate([0, 0, crot]) {
        translate([0, 0, plate_t/2]) cube([w, d, plate_t], center = true);   // plate
        for (c = [0 : gnx-1])
            for (r = [0 : gny-1]) {
                x = straight ? hsw_cx_straight(c, gnx) : hsw_cx(c, gnx);
                y = straight ? (r*HSW_PITCH_Y - spanY/2) : hsw_cy(c, r, gnx, gny);
                translate([x, y, 0]) hsw_connector(type, pfit);
            }
    }
}

// ============================================================================
//  CONNECTOR 2 — hsw_latch_insert : snap-tab latching insert (vanilla port of
//  hex-plug-library / hsw-custom-insert, sh1-verified). Built front-face(lip) at
//  z=0 with body in +Z, then flipped to -Z and welded into the plate.
// ============================================================================
INSERT_BODY_FLATS = 19.7;   INSERT_LIP_FLATS = 22.5;   INSERT_TOTAL_H = 10;
INSERT_LIP_H = 2.5;         INSERT_SNAP_H = 6.5;       INSERT_TAB_OUT = 0.5;
INSERT_TAB_LEN = 2;         INSERT_SLOT_LEN = 8;       INSERT_SLOT_W = 0.8;
INSERT_SLOT_SIDE = 1;       INSERT_SLOT_RAD = 8.25;

module _hsw_bevel_cut(diameter) {
    h = diameter/2;                                     // tan(45)==1
    difference() { cylinder(d = diameter*2, h = h); cylinder(d1 = diameter, d2 = 0, h = h); }
}
module _hsw_insert_body(fit) {
    bodyD = hsw_af_to_d(INSERT_BODY_FLATS - 2*fit);
    lipD  = hsw_af_to_d(INSERT_LIP_FLATS);
    difference() {
        union() {
            cylinder(d = bodyD, h = INSERT_TOTAL_H, $fn = 6);   // main plug
            cylinder(d = lipD,  h = INSERT_LIP_H,  $fn = 6);    // overhang lip
        }
        translate([0,0,INSERT_TOTAL_H - 0.35]) _hsw_bevel_cut(bodyD);   // soften top edge
    }
}
module hsw_latch_insert(fit = 0) {
    translate([0,0,HSW_WELD]) rotate([180,0,0])
    union() {
        // six snap tabs (non-degenerate tip r=0.2, tops kept below the bevel)
        for (i=[0:5]) rotate([0,0,i*60]) translate([0, INSERT_BODY_FLATS/2, 0])
            hull() {
                translate([0,0,INSERT_SNAP_H + INSERT_SLOT_SIDE + INSERT_TAB_OUT])
                    rotate([0,90,0]) cylinder(r = INSERT_TAB_OUT, h = INSERT_TAB_LEN, center=true, $fn=20);
                translate([0,0,INSERT_TOTAL_H - 0.6])
                    rotate([0,90,0]) cylinder(r = 0.2, h = INSERT_TAB_LEN, center=true, $fn=20);
            }
        // body with flex slots so each tab deflects on insertion
        difference() {
            _hsw_insert_body(fit);
            for (i=[0:5]) rotate([0,0,i*60]) {
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_SLOT_W, INSERT_TOTAL_H]);
                translate([-INSERT_SLOT_LEN/2, INSERT_SLOT_RAD, INSERT_SNAP_H]) cube([INSERT_SLOT_LEN, INSERT_TOTAL_H, INSERT_SLOT_SIDE]);
            }
        }
    }
}

// ============================================================================
//  CONNECTOR 3 — hsw_clip : spring snap clip (from hsw-lib-core, sh1-verified).
//  Two cantilever arms catch the 1mm lip at 5mm depth. Mouth at z=0 into -Z.
// ============================================================================
CLIP_FIT_DEFAULT = 0.15;
CLIP_AF  = HSWX_INSIDE;      // 20 plug across-flats target
CLIP_LEN = HSWX_DEPTH;       // 8  plug length into the wall
SPRING_WALL = 1.6;           // cantilever arm wall (>=1.4 to flex)
SPRING_SLOT = 2.2;           // central relief slot width
module hsw_clip(fit = CLIP_FIT_DEFAULT) {
    af = CLIP_AF - 2*fit;  L = CLIP_LEN;
    barb = HSWX_LOCK_LIP;  locz = HSWX_LOCK_DEPTH;  cham = HSWX_LOCK_CHAMFER;  halfX = af/2;
    translate([0,0,HSW_WELD])
    difference() {
        union() {
            translate([0,0,-L/2]) linear_extrude(height = L, center = true) hsw_hex2d(af);   // hex plug
            for (sx=[-1,1]) translate([sx*halfX,0,-locz]) rotate([90,0,0])                    // outward barbs
                linear_extrude(height = af*0.62, center = true)
                    polygon([[0,0],[sx*barb,0],[sx*barb,cham],[0,cham+barb]]);
            translate([0,0,0.6/2]) linear_extrude(height = 0.6, center = true) hsw_hex2d(af + 1.2);  // mouth flange
        }
        translate([0,0,-L/2-0.5]) cube([SPRING_SLOT, af+4, L+2-1.2], center = true);          // central relief slot
        for (sx=[-1,1]) translate([sx*(halfX-SPRING_WALL-0.3),0,-L/2-1]) cube([1.4, af*0.5, L], center=true);  // arm hollow
    }
}

// per-cell connector dispatch:
//   peg     = friction peg, jams the bare grid hole (one-part)
//   barepeg = thin core peg, plugs into a SEPARATE latch pre-snapped in the wall
//   latch   = snap-tab insert, snaps into the bare grid hole
//   clip    = spring clip, snaps into the bare grid hole
module hsw_connector(type = "peg", fit = PEG_FIT_DEFAULT) {
    if      (type == "latch")   hsw_latch_insert(fit);
    else if (type == "clip")    hsw_clip(fit);
    else if (type == "barepeg") hsw_bare_peg(fit);
    else                        hsw_peg(fit);
}

// ============================================================================
//  hsw_grid(nx, ny, depth) — the FEMALE wall panel. Holes placed by the SAME
//  hsw_cx/hsw_cy so a hsw_mount(nx,ny) co-registers EXACTLY (proof artifact).
//  Lipped hex socket: 20mm bore, 1mm catch lip at 5mm depth.
// ============================================================================
module hsw_hex2d(af) { rotate([0,0,90]) circle(r = af/sqrt(3), $fn = 6); }

module hsw_hex_hole(depth) {
    afMouth = HSWX_INSIDE + 2*HSWX_LOCK_CHAMFER;
    afFull  = HSWX_INSIDE;
    afLip   = HSWX_INSIDE - 2*HSWX_LOCK_LIP;
    translate([0,0,-HSWX_LOCK_CHAMFER/2 + 0.01])
        linear_extrude(HSWX_LOCK_CHAMFER + 0.02, center=true, scale = afFull/afMouth) hsw_hex2d(afMouth);
    translate([0,0,-HSWX_LOCK_DEPTH/2])
        linear_extrude(HSWX_LOCK_DEPTH + 0.02, center=true) hsw_hex2d(afFull);
    translate([0,0,-HSWX_LOCK_DEPTH])
        linear_extrude(0.6, center=true) hsw_hex2d(afLip);
    backLen = depth - HSWX_LOCK_DEPTH;
    if (backLen > 0.1)
        translate([0,0,-(HSWX_LOCK_DEPTH + backLen/2)])
            linear_extrude(backLen + 0.4, center=true) hsw_hex2d(afFull);
}

module hsw_grid(nx = 3, ny = 3, depth = HSWX_DEPTH) {
    spanX = (nx-1)*HSW_PITCH_X;
    spanY = (ny-1)*HSW_PITCH_Y;
    slabW = spanX + HSWX_OUTSIDE;
    slabD = spanY + HSWX_OUTSIDE + hsw_max_stag(nx);
    difference() {
        translate([0, -hsw_max_stag(nx)/2, -depth/2]) cube([slabW, slabD, depth], center = true);
        for (c = [0 : nx-1])
            for (r = [0 : ny-1])
                translate([hsw_cx(c, nx), hsw_cy(c, r, nx, ny), 0]) hsw_hex_hole(depth);
    }
}

// ============================================================================
//  hsw_display() — canonical AnimBox display orientation. The geometry is built
//  in the OpenSCAD print frame (scad +Z = wall normal, +Y = up the wall). The
//  The OpenSCAD->AnimBox import is IDENTITY (verified by bbox: cube([10,20,40])
//  imports to world [10,20,40]). The wall-frame is already the display frame:
//  up-the-wall (+Y) = world UP, along-the-wall (+X) = world X, wall normal (+Z)
//  = toward the viewer (the body projects out of the wall). So hsw_display() is a
//  pass-through; it stays as the single place to adjust display orientation if the
//  import convention ever changes. Wrap every recipe's top call: hsw_display() my_part();
// ============================================================================
module hsw_display() { children(); }

// ---- product body (hidden internals) ----
eps   = 0.05;
PLATE = PLATE_T_DEFAULT;

module plier_rack() {
    span = (slots - 1) * spacing;
    w  = span + slot_len + 12;
    bd = slot_len + 12;
    difference() {
        translate([-w / 2, shelf_y - shelf_t / 2, PLATE - HSW_WELD])
            cube([w, shelf_t, bd + HSW_WELD]);
        // wide vertical slots (through Y) the plier head drops through, handle rests on top
        for (i = [0 : slots - 1])
            translate([-span / 2 + i * spacing - slot_w / 2, shelf_y - shelf_t / 2 - eps, PLATE + (bd - slot_len) / 2])
                cube([slot_w, shelf_t + 2 * eps, slot_len]);
    }
}
module plier_rack_part() {
    hsw_mount(connectors_x, connectors_y, type = connector_type, clearance = clearance,
              straight = (support_style == "grid"), crot = connector_rotation);
    plier_rack();
}
hsw_display() plier_rack_part();
`);

Open in editor →

HSW Insert (solid latching)

A solid hexagonal insert that snaps into one honeycomb wall cell with sprung side latches and a flat decorated face - the base building block other attachments grow from.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
/* Library of hex wall bits */
/* updated */
$fn = 64;  // curve smoothness

/* Constants relating to the insert part */
INSERT_MAIN_OUTER_AF_DISTANCE = 19.7;
INSERT_MAIN_INNER_AF_DISTANCE = 13.4;
INSERT_LIP_AF_DISTANCE = 22.5;
INSERT_MAIN_OUTER_DIAMETER = af_to_diameter(INSERT_MAIN_OUTER_AF_DISTANCE);
INSERT_MAIN_INNER_DIAMETER = af_to_diameter(INSERT_MAIN_INNER_AF_DISTANCE);
INSERT_LIP_DIAMETER = af_to_diameter(INSERT_LIP_AF_DISTANCE);
INSERT_TOTAL_HEIGHT = 10;
INSERT_LIP_HEIGHT = 2.5;
INSERT_LIP_PROTRUSION = (INSERT_LIP_AF_DISTANCE - INSERT_MAIN_OUTER_AF_DISTANCE)/2;

/* Constants relating to the honeycomb itself */
HEXAGON_WIDTH = 20;
HEX_WALL_THICKNESS = 3.6;
HEX_SEPARATION = HEXAGON_WIDTH + HEX_WALL_THICKNESS;
HORIZONTAL_HEX_SEPARATION = HEX_SEPARATION * 2 / sqrt(3) + af_to_diameter(HEXAGON_WIDTH + HEX_WALL_THICKNESS)/2;

/* Constants relating to the plug that can go into an empty insert */
PLUG_HEXAGON_DIAMETER = 14.7;
PLUG_AF_SIZE = PLUG_HEXAGON_DIAMETER * sqrt(3) / 2;
PLUG_LENGTH = 13;

DECORATION_OUTER_DIAMETER = 21.362;
DECORATION_INNER_DIAMETER = 19.053;
DECORATION_DEPTH = 0.3;
DECORATEION_FACET_HEIGHT = 0.35;

tiny_distance = .001;
maxInnerDiameter = 16.5;

cellAf = 23.6;
cellD = af_to_diameter(cellAf);

// insert_empty();
// insert_with_plate();
// insert_horizontal();
// hexagon_plug();
// hexagon_plug_horizontal();
// ^ this items has no decorations for compatibility

//insert(); 		// same as insert_with_plate(); but no cut hexagon underneeze
//insertEmpty(); 	// same as insert_empty();
//insertM2_5();
//insertM3();
//insertM4();
//insertM5();
//insertM6();
//insertM8();
//insertM10();
//insertAttachToWall(5, facetHeight = 1, bottomThickness = 1.5, translateHole = [2.5,-3.5], decorations=false);
//insertAttachToWallEmpty(3.5, facetHeight = 2, bottomThickness = 3, withLatch = false, decorations = true, supportless = true);
//hexagonPlug();
//hexagonPlugHorizontal();

//makeInsertHorizontal() insertEmpty(); // <- any insert 


/*
grid(changeCellOrder=false) {
	row(decorations = false) {
		insertAttachToWallEmpty(4, decorations=false, withLatch=true, facetHeight = 1.6);
		insertEmpty(decorations=false);
	}
	row(decorations = false) {
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
	}
}
//*/

module insert_empty(tolerance = 0, inner_tolerance = 0) insertEmpty(tolerance, inner_tolerance, decorations=false);

module insert_with_plate(tolerance = 0, inner_tolerance = 0) { 
	difference() {
		insert(tolerance, decorations=false);
		cutHexagon(inner_tolerance, INSERT_LIP_HEIGHT);
	}
}

module insert_horizontal(tolerance = 0, inner_tolerance = 0) {
	makeInsertHorizontal(tolerance) insert_with_plate(tolerance);
}

module hexagon_plug(tolerance = 0) {
    cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
}

module hexagon_plug_horizontal(tolerance = 0) {
    translate([0, 0, PLUG_AF_SIZE/2 - tolerance])
        rotate([90, 0, 0]) 
			hexagon_plug(tolerance);
}

module insert(tolerance = 0, decorations = true) {
	$fn = 6;
    WALL_SIDE_GAP_START_HEIGHT = 6.5;
    WALL_SIDE_GAP_WIDTH = 1;
    WALL_TOP_GAP_WIDTH = 0.8;
    WALL_GAP_LENGTH = 8;
    WALL_TOP_GAP_RADIUS = 8.25;
    TAB_STICKS_OUT_BY = 0.5;
    TAB_LENGTH = 2;


	difference() {
		union() {
			for (i=[0:5]) {
					rotate([0, 0, i*60]) {
					translate([0, INSERT_MAIN_OUTER_AF_DISTANCE/2 - tolerance, 0]) {
						hull() {
							translate([0, 0, WALL_SIDE_GAP_START_HEIGHT + WALL_SIDE_GAP_WIDTH + TAB_STICKS_OUT_BY]) {
								rotate([0,90,0]){
									cylinder(r=TAB_STICKS_OUT_BY, h=TAB_LENGTH, center=true, $fn=20);
								}
							}
							translate([0, 0, INSERT_TOTAL_HEIGHT - tiny_distance]) {
								rotate([0, 90, 0]) {
									cylinder(r=0.2, h=TAB_LENGTH, center=true, $fn=20);  // rounded retention-tab tip
								}
							}
						}
					}
				}
			}
			difference() {
				insertBase(tolerance, decorations);
				for (i=[0:5]) {
					rotate([0, 0, i*60]) {
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS - tolerance, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, WALL_TOP_GAP_WIDTH, 10]);
						}
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, 10, WALL_SIDE_GAP_WIDTH]);
						}
					}
				}
			}
		}
		cutFacetBottom();
	}
}

module insertEmpty(tolerance = 0, inner_tolerance = 0, decorations = true) {
	difference() {
		insert(tolerance, decorations);
		cutHexagon(inner_tolerance);
	}
}

module insertM2_5(tolerance=0, decorations=true) insertMX(2.5, 5.77, tolerance=tolerance, decorations=decorations);
module insertM3(tolerance=0, decorations=true)   insertMX(3, 6.35, tolerance=tolerance, decorations=decorations);
module insertM4(tolerance=0, decorations=true)   insertMX(4, 8.08, tolerance=tolerance, decorations=decorations);
module insertM5(tolerance=0, decorations=true)   insertMX(5, 9.24, tolerance=tolerance, decorations=decorations);
module insertM6(tolerance=0, decorations=true)   insertMX(6, 11.55, tolerance=tolerance, decorations=decorations);
module insertM8(tolerance=0, decorations=true)   insertMX(8, 15.01, tolerance=tolerance, decorations=decorations);
module insertM10(tolerance=0, decorations=true)  insertMX(10, 17.32, tolerance=tolerance, decorations=decorations);

function calculateFacetDiameter(holeD, facetHeight) = facetHeight * 2 + holeD;

module insertAttachToWall(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 1.5, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, // <- I think there is no need latch, but you can turn it on
	translateHole = [0,0], // <- if you drill hole not accurate, you can move it by [x, y],
	decorations = true
) {
	$fn=64;
	isTranslateHole = translateHole[0] != 0 || translateHole[1] != 0;
	spacer = 0.2;
	holeD = holeDiameter + spacer;
	outHoleDiameter = isTranslateHole ? maxInnerDiameter : holeD + 4;
	facetD = calculateFacetDiameter(holeD, facetHeight);

	difference() {
		if (withLatch)  
			insert(tolerance, decorations = decorations);
		 else  
			insertBase(tolerance, decorations = decorations);

		translate([0, 0, -bottomThickness]) cylinder(d = outHoleDiameter, h = INSERT_TOTAL_HEIGHT); 

		if (isTranslateHole) 
			translate([translateHole[0], translateHole[1], 0]) hole();
		else 
			hole();
	}

	module hole() {
		translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness - 0.1]) cylinder(d1 = facetD, d2 = holeD, h = facetHeight + 0.1); 
		cylinder(d = holeD, INSERT_TOTAL_HEIGHT + 0.1); 
	}
}

module insertAttachToWallEmpty(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 2, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, 
	decorations = true,
    supportless = false,
) {
    layerThickness = 0.2;

	difference() {
		insertAttachToWall(holeDiameter, facetHeight, bottomThickness, tolerance, inner_tolerance, withLatch, decorations = decorations);
		cutHexagon(inner_tolerance, -bottomThickness);
	}
    if (supportless) {
        translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness]) 
            difference() {
                cylinder(d = PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 2, $fn = 6, center = true);  
                cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight), layerThickness * 4], center = true);  
            }
        translate([0,0,INSERT_TOTAL_HEIGHT-bottomThickness]) 
            difference() {
                cylinder(d=PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 4, $fn = 6, center = true);  
                rotate(90, [0, 0, 1]) 
                    cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight),layerThickness* 2 * 2 * 2], center = true);  
            }
    }
}

module hexagonPlug(tolerance=0, decorations=true) {
	if (decorations) {
		D = PLUG_HEXAGON_DIAMETER - tolerance*2;
		intersection() {
			cylinder(d=D, h=PLUG_LENGTH, $fn=6);
			translate([0,0,-0.75])
				cylinder(r1=PLUG_LENGTH + D/2, r2=0, h = PLUG_LENGTH + D/2, $fn=6); 
			translate([0,0,-D/2 + 0.75])
				cylinder(r2=PLUG_LENGTH + D/2, r1=0, h = PLUG_LENGTH + D/2, $fn=6); 
		}
	} else {
		cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
	}
}

module hexagonPlugHorizontal(tolerance=0, decorations=true) {
	translate([0,0, PLUG_AF_SIZE/2] )
	translate([0,0,-INSERT_MAIN_OUTER_AF_DISTANCE/2] )
	makeInsertHorizontal() hexagonPlug(tolerance, decorations);
}

module makeInsertHorizontal(tolerance=0) {
    large_distance=10;
    difference() {
        translate([0, 0, INSERT_MAIN_OUTER_AF_DISTANCE/2]) 
            rotate([90, 0, 0])
                children();
        translate([-large_distance, -INSERT_TOTAL_HEIGHT - 0.1, -large_distance + tolerance]) 
            cube([large_distance*2, INSERT_TOTAL_HEIGHT + 0.2, large_distance]);
    }
}

module grid(rows=[], changeCellOrder = false, maxRowLength = 10) {
	noRowsInfo = len(rows) == 0;
	upCutRowCount = noRowsInfo ? maxRowLength : rows[0];
	downCutRowCount = noRowsInfo ? maxRowLength : rows[len(rows)-1];
	
	assert( !(!noRowsInfo && len(rows) != $children), 
		"rows info if specified must describe all rows! Example: grid(rows=[1,2]) { row() { insert(); } row() { insert(); insert(); } }");

	difference() {
		for (i = [0:$children-1]) {
			tY = cellOffsetY(i, changeCellOrder);
			translate([(cellD - cellD / 4) * i, tY, 0]) children(i);
		}
		for (i = [0:$children-1]) {

			tY = cellOffsetY(i, changeCellOrder); 
			translate([(cellD - cellD / 4) * i, tY  - cellAf, 0]) connectorCutting();

			if (!noRowsInfo) {
				itemsInRow = rows[i];
				for (k=[0:maxRowLength-1]){
					translate([(cellD - cellD / 4) * i, tY  + (k + itemsInRow) * cellAf, 0]) connectorCutting();
				}
			}
		}

		tYUp = cellOffsetY($children, changeCellOrder);
		translate([(cellD - cellD / 4) * $children, -tYUp, 0]){
			for (j=[0:downCutRowCount-1]) {
				translate([0, cellAf * j, 0]) connectorCutting();
			}
		}
		tYDown = cellOffsetY(-1, changeCellOrder);
		translate([-(cellD - cellD / 4), -tYDown, 0])
			for (k=[0:upCutRowCount-1]) {
				translate([0, cellAf * k, 0]) connectorCutting();
			}
	}
}

module row(connections=true, decorations = true) {
	if ($children > 0) {
		difference() {
			for (i = [0:$children-1]) 
				translate([0, cellAf * i, 0]) {
					if (connections) connector(false, decorations);
					children(i);
				}
			translate([(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
			translate([0, cellAf * $children, 0]) connectorCutting();
			translate([-(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
		}
	}
}

// utils modules section ----------------------------------------------------

module insertBase(tolerance=0, decorations=true) {
    $fn = 6;
    difference() {
        union() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER-tolerance*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=INSERT_LIP_DIAMETER, h=INSERT_LIP_HEIGHT);
        }
		if (decorations) {
			translate([0,0,-0.1])
				union() {
					difference() {
						cylinder(d = DECORATION_OUTER_DIAMETER, h = DECORATION_DEPTH + 0.1);
						cylinder(d = DECORATION_INNER_DIAMETER, h = DECORATION_DEPTH + 0.1);
					}
				}

			translate([0,0,DECORATEION_FACET_HEIGHT]) cutFacet(INSERT_LIP_DIAMETER, inverse=true);
		}
        translate([0,0,INSERT_LIP_HEIGHT])
        rotate(90,[0,0,1])
        difference() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=af_to_diameter(INSERT_MAIN_OUTER_DIAMETER-tolerance*2) - 0.12 * 2, h=INSERT_TOTAL_HEIGHT);
        }
        cutFacetBottom();
    }
}

module cutFacet(diameter, inverse=false) {
	h = diameter / 2 * tan(45);
	z = inverse ? -h : 0;
	translate([0,0,z])
		difference() {
			cylinder(d=diameter*2, h = h);
			if (inverse)
				cylinder(d2=diameter, d1=0, h = h);
			else
				cylinder(d1=diameter, d2=0, h = h);
		}
}

module cutFacetBottom() {
	translate([0,0,INSERT_TOTAL_HEIGHT-DECORATEION_FACET_HEIGHT])
		cutFacet(INSERT_MAIN_OUTER_DIAMETER);
}

module cutHexagon(inner_tolerance, indent = 0) {
	// remove preview artifacts
	z = indent == 0 ? -0.5 : indent;
	addH = indent == 0 ? 1 : 0;
	translate([0,0,z]) 
		cylinder(d=INSERT_MAIN_INNER_DIAMETER + inner_tolerance*2, h=INSERT_TOTAL_HEIGHT + addH, $fn=6);
}

module insertMX(diameter,  nutWidth, tolerance = 0, decorations = true) {
	spacer = 0.2;
	holeD = min(maxInnerDiameter, diameter + spacer);
	facet = holeD / 8;
	facetH = 0.3;
	nutW = min(maxInnerDiameter, nutWidth + spacer);
	aboveNutW = min(maxInnerDiameter, nutW + 6);

	difference() {
		insert(tolerance, decorations = decorations);
		translate([0,0,-0.1]) // remove preview artifacts
			cylinder(d1 = holeD + facet * 2, d2 = holeD, h = facetH + 0.1);
		cylinder(d = holeD, h = INSERT_TOTAL_HEIGHT);
		translate([0, 0, 4])
		cylinder(d = nutW, h = INSERT_TOTAL_HEIGHT, $fn=6);
		translate([0, 0, 7])
		cylinder(d = aboveNutW, h = INSERT_TOTAL_HEIGHT + 0.1, $fn=6);
	}
}

module connector(forCutting=false, decorations = true) {
	connectorW = (cellAf-INSERT_LIP_AF_DISTANCE);
	connectorH = decorations ? INSERT_LIP_HEIGHT - DECORATEION_FACET_HEIGHT : INSERT_LIP_HEIGHT;
	connectorL = INSERT_LIP_DIAMETER/2;
	cuttingTranslateZ = forCutting ? -2 : 0;
	cuttingScaleZ = forCutting ? 2 : 1;

	translate([0,0,cuttingTranslateZ])
		scale([1,1,cuttingScaleZ]) 
			for (a=[0:60:300])
			rotate(a,[0,0,1])
				translate([-connectorL/2, -INSERT_LIP_AF_DISTANCE/2 - connectorW, decorations ? DECORATEION_FACET_HEIGHT : 0]) {
				points = [
					[0, addCutting(connectorW)],
					[connectorL, addCutting(connectorW)],
					[connectorL, 0],
					[0, 0],
					[-(connectorW*sin(60)), connectorW/2]
				];
				linear_extrude(height = connectorH) polygon(points);
			}

	function addCutting(value) = forCutting ? value + 0.1 : value;
}

module connectorCutting() connector(true, true);
function cellOrder(i, change) = change ? i % 2 == 0 : i % 2 != 0;
function cellOffsetY(i, change) = cellOrder(i, change) ? 0 : cellAf / 2;

/* converts an 'across flats' dimension to a maximum diameter — useful for openScad */
function af_to_diameter(af) = af / sqrt(3) * 2;
function diameter_to_af(diameter) = diameter * sqrt(3) / 2;

// ---- part ----
insert();
`);

Open in editor →

HSW Insert (empty / hollow)

A latching wall insert with its centre bored through - a hollow socket to pass a fastener, cable, or your own plug through.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
/* Library of hex wall bits */
/* updated */
$fn = 64;  // curve smoothness

/* Constants relating to the insert part */
INSERT_MAIN_OUTER_AF_DISTANCE = 19.7;
INSERT_MAIN_INNER_AF_DISTANCE = 13.4;
INSERT_LIP_AF_DISTANCE = 22.5;
INSERT_MAIN_OUTER_DIAMETER = af_to_diameter(INSERT_MAIN_OUTER_AF_DISTANCE);
INSERT_MAIN_INNER_DIAMETER = af_to_diameter(INSERT_MAIN_INNER_AF_DISTANCE);
INSERT_LIP_DIAMETER = af_to_diameter(INSERT_LIP_AF_DISTANCE);
INSERT_TOTAL_HEIGHT = 10;
INSERT_LIP_HEIGHT = 2.5;
INSERT_LIP_PROTRUSION = (INSERT_LIP_AF_DISTANCE - INSERT_MAIN_OUTER_AF_DISTANCE)/2;

/* Constants relating to the honeycomb itself */
HEXAGON_WIDTH = 20;
HEX_WALL_THICKNESS = 3.6;
HEX_SEPARATION = HEXAGON_WIDTH + HEX_WALL_THICKNESS;
HORIZONTAL_HEX_SEPARATION = HEX_SEPARATION * 2 / sqrt(3) + af_to_diameter(HEXAGON_WIDTH + HEX_WALL_THICKNESS)/2;

/* Constants relating to the plug that can go into an empty insert */
PLUG_HEXAGON_DIAMETER = 14.7;
PLUG_AF_SIZE = PLUG_HEXAGON_DIAMETER * sqrt(3) / 2;
PLUG_LENGTH = 13;

DECORATION_OUTER_DIAMETER = 21.362;
DECORATION_INNER_DIAMETER = 19.053;
DECORATION_DEPTH = 0.3;
DECORATEION_FACET_HEIGHT = 0.35;

tiny_distance = .001;
maxInnerDiameter = 16.5;

cellAf = 23.6;
cellD = af_to_diameter(cellAf);

// insert_empty();
// insert_with_plate();
// insert_horizontal();
// hexagon_plug();
// hexagon_plug_horizontal();
// ^ this items has no decorations for compatibility

//insert(); 		// same as insert_with_plate(); but no cut hexagon underneeze
//insertEmpty(); 	// same as insert_empty();
//insertM2_5();
//insertM3();
//insertM4();
//insertM5();
//insertM6();
//insertM8();
//insertM10();
//insertAttachToWall(5, facetHeight = 1, bottomThickness = 1.5, translateHole = [2.5,-3.5], decorations=false);
//insertAttachToWallEmpty(3.5, facetHeight = 2, bottomThickness = 3, withLatch = false, decorations = true, supportless = true);
//hexagonPlug();
//hexagonPlugHorizontal();

//makeInsertHorizontal() insertEmpty(); // <- any insert 


/*
grid(changeCellOrder=false) {
	row(decorations = false) {
		insertAttachToWallEmpty(4, decorations=false, withLatch=true, facetHeight = 1.6);
		insertEmpty(decorations=false);
	}
	row(decorations = false) {
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
	}
}
//*/

module insert_empty(tolerance = 0, inner_tolerance = 0) insertEmpty(tolerance, inner_tolerance, decorations=false);

module insert_with_plate(tolerance = 0, inner_tolerance = 0) { 
	difference() {
		insert(tolerance, decorations=false);
		cutHexagon(inner_tolerance, INSERT_LIP_HEIGHT);
	}
}

module insert_horizontal(tolerance = 0, inner_tolerance = 0) {
	makeInsertHorizontal(tolerance) insert_with_plate(tolerance);
}

module hexagon_plug(tolerance = 0) {
    cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
}

module hexagon_plug_horizontal(tolerance = 0) {
    translate([0, 0, PLUG_AF_SIZE/2 - tolerance])
        rotate([90, 0, 0]) 
			hexagon_plug(tolerance);
}

module insert(tolerance = 0, decorations = true) {
	$fn = 6;
    WALL_SIDE_GAP_START_HEIGHT = 6.5;
    WALL_SIDE_GAP_WIDTH = 1;
    WALL_TOP_GAP_WIDTH = 0.8;
    WALL_GAP_LENGTH = 8;
    WALL_TOP_GAP_RADIUS = 8.25;
    TAB_STICKS_OUT_BY = 0.5;
    TAB_LENGTH = 2;


	difference() {
		union() {
			for (i=[0:5]) {
					rotate([0, 0, i*60]) {
					translate([0, INSERT_MAIN_OUTER_AF_DISTANCE/2 - tolerance, 0]) {
						hull() {
							translate([0, 0, WALL_SIDE_GAP_START_HEIGHT + WALL_SIDE_GAP_WIDTH + TAB_STICKS_OUT_BY]) {
								rotate([0,90,0]){
									cylinder(r=TAB_STICKS_OUT_BY, h=TAB_LENGTH, center=true, $fn=20);
								}
							}
							translate([0, 0, INSERT_TOTAL_HEIGHT - tiny_distance]) {
								rotate([0, 90, 0]) {
									cylinder(r=0.2, h=TAB_LENGTH, center=true, $fn=20);  // rounded retention-tab tip
								}
							}
						}
					}
				}
			}
			difference() {
				insertBase(tolerance, decorations);
				for (i=[0:5]) {
					rotate([0, 0, i*60]) {
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS - tolerance, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, WALL_TOP_GAP_WIDTH, 10]);
						}
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, 10, WALL_SIDE_GAP_WIDTH]);
						}
					}
				}
			}
		}
		cutFacetBottom();
	}
}

module insertEmpty(tolerance = 0, inner_tolerance = 0, decorations = true) {
	difference() {
		insert(tolerance, decorations);
		cutHexagon(inner_tolerance);
	}
}

module insertM2_5(tolerance=0, decorations=true) insertMX(2.5, 5.77, tolerance=tolerance, decorations=decorations);
module insertM3(tolerance=0, decorations=true)   insertMX(3, 6.35, tolerance=tolerance, decorations=decorations);
module insertM4(tolerance=0, decorations=true)   insertMX(4, 8.08, tolerance=tolerance, decorations=decorations);
module insertM5(tolerance=0, decorations=true)   insertMX(5, 9.24, tolerance=tolerance, decorations=decorations);
module insertM6(tolerance=0, decorations=true)   insertMX(6, 11.55, tolerance=tolerance, decorations=decorations);
module insertM8(tolerance=0, decorations=true)   insertMX(8, 15.01, tolerance=tolerance, decorations=decorations);
module insertM10(tolerance=0, decorations=true)  insertMX(10, 17.32, tolerance=tolerance, decorations=decorations);

function calculateFacetDiameter(holeD, facetHeight) = facetHeight * 2 + holeD;

module insertAttachToWall(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 1.5, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, // <- I think there is no need latch, but you can turn it on
	translateHole = [0,0], // <- if you drill hole not accurate, you can move it by [x, y],
	decorations = true
) {
	$fn=64;
	isTranslateHole = translateHole[0] != 0 || translateHole[1] != 0;
	spacer = 0.2;
	holeD = holeDiameter + spacer;
	outHoleDiameter = isTranslateHole ? maxInnerDiameter : holeD + 4;
	facetD = calculateFacetDiameter(holeD, facetHeight);

	difference() {
		if (withLatch)  
			insert(tolerance, decorations = decorations);
		 else  
			insertBase(tolerance, decorations = decorations);

		translate([0, 0, -bottomThickness]) cylinder(d = outHoleDiameter, h = INSERT_TOTAL_HEIGHT); 

		if (isTranslateHole) 
			translate([translateHole[0], translateHole[1], 0]) hole();
		else 
			hole();
	}

	module hole() {
		translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness - 0.1]) cylinder(d1 = facetD, d2 = holeD, h = facetHeight + 0.1); 
		cylinder(d = holeD, INSERT_TOTAL_HEIGHT + 0.1); 
	}
}

module insertAttachToWallEmpty(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 2, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, 
	decorations = true,
    supportless = false,
) {
    layerThickness = 0.2;

	difference() {
		insertAttachToWall(holeDiameter, facetHeight, bottomThickness, tolerance, inner_tolerance, withLatch, decorations = decorations);
		cutHexagon(inner_tolerance, -bottomThickness);
	}
    if (supportless) {
        translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness]) 
            difference() {
                cylinder(d = PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 2, $fn = 6, center = true);  
                cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight), layerThickness * 4], center = true);  
            }
        translate([0,0,INSERT_TOTAL_HEIGHT-bottomThickness]) 
            difference() {
                cylinder(d=PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 4, $fn = 6, center = true);  
                rotate(90, [0, 0, 1]) 
                    cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight),layerThickness* 2 * 2 * 2], center = true);  
            }
    }
}

module hexagonPlug(tolerance=0, decorations=true) {
	if (decorations) {
		D = PLUG_HEXAGON_DIAMETER - tolerance*2;
		intersection() {
			cylinder(d=D, h=PLUG_LENGTH, $fn=6);
			translate([0,0,-0.75])
				cylinder(r1=PLUG_LENGTH + D/2, r2=0, h = PLUG_LENGTH + D/2, $fn=6); 
			translate([0,0,-D/2 + 0.75])
				cylinder(r2=PLUG_LENGTH + D/2, r1=0, h = PLUG_LENGTH + D/2, $fn=6); 
		}
	} else {
		cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
	}
}

module hexagonPlugHorizontal(tolerance=0, decorations=true) {
	translate([0,0, PLUG_AF_SIZE/2] )
	translate([0,0,-INSERT_MAIN_OUTER_AF_DISTANCE/2] )
	makeInsertHorizontal() hexagonPlug(tolerance, decorations);
}

module makeInsertHorizontal(tolerance=0) {
    large_distance=10;
    difference() {
        translate([0, 0, INSERT_MAIN_OUTER_AF_DISTANCE/2]) 
            rotate([90, 0, 0])
                children();
        translate([-large_distance, -INSERT_TOTAL_HEIGHT - 0.1, -large_distance + tolerance]) 
            cube([large_distance*2, INSERT_TOTAL_HEIGHT + 0.2, large_distance]);
    }
}

module grid(rows=[], changeCellOrder = false, maxRowLength = 10) {
	noRowsInfo = len(rows) == 0;
	upCutRowCount = noRowsInfo ? maxRowLength : rows[0];
	downCutRowCount = noRowsInfo ? maxRowLength : rows[len(rows)-1];
	
	assert( !(!noRowsInfo && len(rows) != $children), 
		"rows info if specified must describe all rows! Example: grid(rows=[1,2]) { row() { insert(); } row() { insert(); insert(); } }");

	difference() {
		for (i = [0:$children-1]) {
			tY = cellOffsetY(i, changeCellOrder);
			translate([(cellD - cellD / 4) * i, tY, 0]) children(i);
		}
		for (i = [0:$children-1]) {

			tY = cellOffsetY(i, changeCellOrder); 
			translate([(cellD - cellD / 4) * i, tY  - cellAf, 0]) connectorCutting();

			if (!noRowsInfo) {
				itemsInRow = rows[i];
				for (k=[0:maxRowLength-1]){
					translate([(cellD - cellD / 4) * i, tY  + (k + itemsInRow) * cellAf, 0]) connectorCutting();
				}
			}
		}

		tYUp = cellOffsetY($children, changeCellOrder);
		translate([(cellD - cellD / 4) * $children, -tYUp, 0]){
			for (j=[0:downCutRowCount-1]) {
				translate([0, cellAf * j, 0]) connectorCutting();
			}
		}
		tYDown = cellOffsetY(-1, changeCellOrder);
		translate([-(cellD - cellD / 4), -tYDown, 0])
			for (k=[0:upCutRowCount-1]) {
				translate([0, cellAf * k, 0]) connectorCutting();
			}
	}
}

module row(connections=true, decorations = true) {
	if ($children > 0) {
		difference() {
			for (i = [0:$children-1]) 
				translate([0, cellAf * i, 0]) {
					if (connections) connector(false, decorations);
					children(i);
				}
			translate([(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
			translate([0, cellAf * $children, 0]) connectorCutting();
			translate([-(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
		}
	}
}

// utils modules section ----------------------------------------------------

module insertBase(tolerance=0, decorations=true) {
    $fn = 6;
    difference() {
        union() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER-tolerance*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=INSERT_LIP_DIAMETER, h=INSERT_LIP_HEIGHT);
        }
		if (decorations) {
			translate([0,0,-0.1])
				union() {
					difference() {
						cylinder(d = DECORATION_OUTER_DIAMETER, h = DECORATION_DEPTH + 0.1);
						cylinder(d = DECORATION_INNER_DIAMETER, h = DECORATION_DEPTH + 0.1);
					}
				}

			translate([0,0,DECORATEION_FACET_HEIGHT]) cutFacet(INSERT_LIP_DIAMETER, inverse=true);
		}
        translate([0,0,INSERT_LIP_HEIGHT])
        rotate(90,[0,0,1])
        difference() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=af_to_diameter(INSERT_MAIN_OUTER_DIAMETER-tolerance*2) - 0.12 * 2, h=INSERT_TOTAL_HEIGHT);
        }
        cutFacetBottom();
    }
}

module cutFacet(diameter, inverse=false) {
	h = diameter / 2 * tan(45);
	z = inverse ? -h : 0;
	translate([0,0,z])
		difference() {
			cylinder(d=diameter*2, h = h);
			if (inverse)
				cylinder(d2=diameter, d1=0, h = h);
			else
				cylinder(d1=diameter, d2=0, h = h);
		}
}

module cutFacetBottom() {
	translate([0,0,INSERT_TOTAL_HEIGHT-DECORATEION_FACET_HEIGHT])
		cutFacet(INSERT_MAIN_OUTER_DIAMETER);
}

module cutHexagon(inner_tolerance, indent = 0) {
	// remove preview artifacts
	z = indent == 0 ? -0.5 : indent;
	addH = indent == 0 ? 1 : 0;
	translate([0,0,z]) 
		cylinder(d=INSERT_MAIN_INNER_DIAMETER + inner_tolerance*2, h=INSERT_TOTAL_HEIGHT + addH, $fn=6);
}

module insertMX(diameter,  nutWidth, tolerance = 0, decorations = true) {
	spacer = 0.2;
	holeD = min(maxInnerDiameter, diameter + spacer);
	facet = holeD / 8;
	facetH = 0.3;
	nutW = min(maxInnerDiameter, nutWidth + spacer);
	aboveNutW = min(maxInnerDiameter, nutW + 6);

	difference() {
		insert(tolerance, decorations = decorations);
		translate([0,0,-0.1]) // remove preview artifacts
			cylinder(d1 = holeD + facet * 2, d2 = holeD, h = facetH + 0.1);
		cylinder(d = holeD, h = INSERT_TOTAL_HEIGHT);
		translate([0, 0, 4])
		cylinder(d = nutW, h = INSERT_TOTAL_HEIGHT, $fn=6);
		translate([0, 0, 7])
		cylinder(d = aboveNutW, h = INSERT_TOTAL_HEIGHT + 0.1, $fn=6);
	}
}

module connector(forCutting=false, decorations = true) {
	connectorW = (cellAf-INSERT_LIP_AF_DISTANCE);
	connectorH = decorations ? INSERT_LIP_HEIGHT - DECORATEION_FACET_HEIGHT : INSERT_LIP_HEIGHT;
	connectorL = INSERT_LIP_DIAMETER/2;
	cuttingTranslateZ = forCutting ? -2 : 0;
	cuttingScaleZ = forCutting ? 2 : 1;

	translate([0,0,cuttingTranslateZ])
		scale([1,1,cuttingScaleZ]) 
			for (a=[0:60:300])
			rotate(a,[0,0,1])
				translate([-connectorL/2, -INSERT_LIP_AF_DISTANCE/2 - connectorW, decorations ? DECORATEION_FACET_HEIGHT : 0]) {
				points = [
					[0, addCutting(connectorW)],
					[connectorL, addCutting(connectorW)],
					[connectorL, 0],
					[0, 0],
					[-(connectorW*sin(60)), connectorW/2]
				];
				linear_extrude(height = connectorH) polygon(points);
			}

	function addCutting(value) = forCutting ? value + 0.1 : value;
}

module connectorCutting() connector(true, true);
function cellOrder(i, change) = change ? i % 2 == 0 : i % 2 != 0;
function cellOffsetY(i, change) = cellOrder(i, change) ? 0 : cellAf / 2;

/* converts an 'across flats' dimension to a maximum diameter — useful for openScad */
function af_to_diameter(af) = af / sqrt(3) * 2;
function diameter_to_af(diameter) = diameter * sqrt(3) / 2;

// ---- part ----
insertEmpty();
`);

Open in editor →

HSW Insert (with mounting plate)

A latching wall insert capped by a solid plate face - a blank mounting pad to build your own accessory onto.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
/* Library of hex wall bits */
/* updated */
$fn = 64;  // curve smoothness

/* Constants relating to the insert part */
INSERT_MAIN_OUTER_AF_DISTANCE = 19.7;
INSERT_MAIN_INNER_AF_DISTANCE = 13.4;
INSERT_LIP_AF_DISTANCE = 22.5;
INSERT_MAIN_OUTER_DIAMETER = af_to_diameter(INSERT_MAIN_OUTER_AF_DISTANCE);
INSERT_MAIN_INNER_DIAMETER = af_to_diameter(INSERT_MAIN_INNER_AF_DISTANCE);
INSERT_LIP_DIAMETER = af_to_diameter(INSERT_LIP_AF_DISTANCE);
INSERT_TOTAL_HEIGHT = 10;
INSERT_LIP_HEIGHT = 2.5;
INSERT_LIP_PROTRUSION = (INSERT_LIP_AF_DISTANCE - INSERT_MAIN_OUTER_AF_DISTANCE)/2;

/* Constants relating to the honeycomb itself */
HEXAGON_WIDTH = 20;
HEX_WALL_THICKNESS = 3.6;
HEX_SEPARATION = HEXAGON_WIDTH + HEX_WALL_THICKNESS;
HORIZONTAL_HEX_SEPARATION = HEX_SEPARATION * 2 / sqrt(3) + af_to_diameter(HEXAGON_WIDTH + HEX_WALL_THICKNESS)/2;

/* Constants relating to the plug that can go into an empty insert */
PLUG_HEXAGON_DIAMETER = 14.7;
PLUG_AF_SIZE = PLUG_HEXAGON_DIAMETER * sqrt(3) / 2;
PLUG_LENGTH = 13;

DECORATION_OUTER_DIAMETER = 21.362;
DECORATION_INNER_DIAMETER = 19.053;
DECORATION_DEPTH = 0.3;
DECORATEION_FACET_HEIGHT = 0.35;

tiny_distance = .001;
maxInnerDiameter = 16.5;

cellAf = 23.6;
cellD = af_to_diameter(cellAf);

// insert_empty();
// insert_with_plate();
// insert_horizontal();
// hexagon_plug();
// hexagon_plug_horizontal();
// ^ this items has no decorations for compatibility

//insert(); 		// same as insert_with_plate(); but no cut hexagon underneeze
//insertEmpty(); 	// same as insert_empty();
//insertM2_5();
//insertM3();
//insertM4();
//insertM5();
//insertM6();
//insertM8();
//insertM10();
//insertAttachToWall(5, facetHeight = 1, bottomThickness = 1.5, translateHole = [2.5,-3.5], decorations=false);
//insertAttachToWallEmpty(3.5, facetHeight = 2, bottomThickness = 3, withLatch = false, decorations = true, supportless = true);
//hexagonPlug();
//hexagonPlugHorizontal();

//makeInsertHorizontal() insertEmpty(); // <- any insert 


/*
grid(changeCellOrder=false) {
	row(decorations = false) {
		insertAttachToWallEmpty(4, decorations=false, withLatch=true, facetHeight = 1.6);
		insertEmpty(decorations=false);
	}
	row(decorations = false) {
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
	}
}
//*/

module insert_empty(tolerance = 0, inner_tolerance = 0) insertEmpty(tolerance, inner_tolerance, decorations=false);

module insert_with_plate(tolerance = 0, inner_tolerance = 0) { 
	difference() {
		insert(tolerance, decorations=false);
		cutHexagon(inner_tolerance, INSERT_LIP_HEIGHT);
	}
}

module insert_horizontal(tolerance = 0, inner_tolerance = 0) {
	makeInsertHorizontal(tolerance) insert_with_plate(tolerance);
}

module hexagon_plug(tolerance = 0) {
    cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
}

module hexagon_plug_horizontal(tolerance = 0) {
    translate([0, 0, PLUG_AF_SIZE/2 - tolerance])
        rotate([90, 0, 0]) 
			hexagon_plug(tolerance);
}

module insert(tolerance = 0, decorations = true) {
	$fn = 6;
    WALL_SIDE_GAP_START_HEIGHT = 6.5;
    WALL_SIDE_GAP_WIDTH = 1;
    WALL_TOP_GAP_WIDTH = 0.8;
    WALL_GAP_LENGTH = 8;
    WALL_TOP_GAP_RADIUS = 8.25;
    TAB_STICKS_OUT_BY = 0.5;
    TAB_LENGTH = 2;


	difference() {
		union() {
			for (i=[0:5]) {
					rotate([0, 0, i*60]) {
					translate([0, INSERT_MAIN_OUTER_AF_DISTANCE/2 - tolerance, 0]) {
						hull() {
							translate([0, 0, WALL_SIDE_GAP_START_HEIGHT + WALL_SIDE_GAP_WIDTH + TAB_STICKS_OUT_BY]) {
								rotate([0,90,0]){
									cylinder(r=TAB_STICKS_OUT_BY, h=TAB_LENGTH, center=true, $fn=20);
								}
							}
							translate([0, 0, INSERT_TOTAL_HEIGHT - tiny_distance]) {
								rotate([0, 90, 0]) {
									cylinder(r=0.2, h=TAB_LENGTH, center=true, $fn=20);  // rounded retention-tab tip
								}
							}
						}
					}
				}
			}
			difference() {
				insertBase(tolerance, decorations);
				for (i=[0:5]) {
					rotate([0, 0, i*60]) {
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS - tolerance, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, WALL_TOP_GAP_WIDTH, 10]);
						}
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, 10, WALL_SIDE_GAP_WIDTH]);
						}
					}
				}
			}
		}
		cutFacetBottom();
	}
}

module insertEmpty(tolerance = 0, inner_tolerance = 0, decorations = true) {
	difference() {
		insert(tolerance, decorations);
		cutHexagon(inner_tolerance);
	}
}

module insertM2_5(tolerance=0, decorations=true) insertMX(2.5, 5.77, tolerance=tolerance, decorations=decorations);
module insertM3(tolerance=0, decorations=true)   insertMX(3, 6.35, tolerance=tolerance, decorations=decorations);
module insertM4(tolerance=0, decorations=true)   insertMX(4, 8.08, tolerance=tolerance, decorations=decorations);
module insertM5(tolerance=0, decorations=true)   insertMX(5, 9.24, tolerance=tolerance, decorations=decorations);
module insertM6(tolerance=0, decorations=true)   insertMX(6, 11.55, tolerance=tolerance, decorations=decorations);
module insertM8(tolerance=0, decorations=true)   insertMX(8, 15.01, tolerance=tolerance, decorations=decorations);
module insertM10(tolerance=0, decorations=true)  insertMX(10, 17.32, tolerance=tolerance, decorations=decorations);

function calculateFacetDiameter(holeD, facetHeight) = facetHeight * 2 + holeD;

module insertAttachToWall(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 1.5, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, // <- I think there is no need latch, but you can turn it on
	translateHole = [0,0], // <- if you drill hole not accurate, you can move it by [x, y],
	decorations = true
) {
	$fn=64;
	isTranslateHole = translateHole[0] != 0 || translateHole[1] != 0;
	spacer = 0.2;
	holeD = holeDiameter + spacer;
	outHoleDiameter = isTranslateHole ? maxInnerDiameter : holeD + 4;
	facetD = calculateFacetDiameter(holeD, facetHeight);

	difference() {
		if (withLatch)  
			insert(tolerance, decorations = decorations);
		 else  
			insertBase(tolerance, decorations = decorations);

		translate([0, 0, -bottomThickness]) cylinder(d = outHoleDiameter, h = INSERT_TOTAL_HEIGHT); 

		if (isTranslateHole) 
			translate([translateHole[0], translateHole[1], 0]) hole();
		else 
			hole();
	}

	module hole() {
		translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness - 0.1]) cylinder(d1 = facetD, d2 = holeD, h = facetHeight + 0.1); 
		cylinder(d = holeD, INSERT_TOTAL_HEIGHT + 0.1); 
	}
}

module insertAttachToWallEmpty(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 2, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, 
	decorations = true,
    supportless = false,
) {
    layerThickness = 0.2;

	difference() {
		insertAttachToWall(holeDiameter, facetHeight, bottomThickness, tolerance, inner_tolerance, withLatch, decorations = decorations);
		cutHexagon(inner_tolerance, -bottomThickness);
	}
    if (supportless) {
        translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness]) 
            difference() {
                cylinder(d = PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 2, $fn = 6, center = true);  
                cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight), layerThickness * 4], center = true);  
            }
        translate([0,0,INSERT_TOTAL_HEIGHT-bottomThickness]) 
            difference() {
                cylinder(d=PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 4, $fn = 6, center = true);  
                rotate(90, [0, 0, 1]) 
                    cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight),layerThickness* 2 * 2 * 2], center = true);  
            }
    }
}

module hexagonPlug(tolerance=0, decorations=true) {
	if (decorations) {
		D = PLUG_HEXAGON_DIAMETER - tolerance*2;
		intersection() {
			cylinder(d=D, h=PLUG_LENGTH, $fn=6);
			translate([0,0,-0.75])
				cylinder(r1=PLUG_LENGTH + D/2, r2=0, h = PLUG_LENGTH + D/2, $fn=6); 
			translate([0,0,-D/2 + 0.75])
				cylinder(r2=PLUG_LENGTH + D/2, r1=0, h = PLUG_LENGTH + D/2, $fn=6); 
		}
	} else {
		cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
	}
}

module hexagonPlugHorizontal(tolerance=0, decorations=true) {
	translate([0,0, PLUG_AF_SIZE/2] )
	translate([0,0,-INSERT_MAIN_OUTER_AF_DISTANCE/2] )
	makeInsertHorizontal() hexagonPlug(tolerance, decorations);
}

module makeInsertHorizontal(tolerance=0) {
    large_distance=10;
    difference() {
        translate([0, 0, INSERT_MAIN_OUTER_AF_DISTANCE/2]) 
            rotate([90, 0, 0])
                children();
        translate([-large_distance, -INSERT_TOTAL_HEIGHT - 0.1, -large_distance + tolerance]) 
            cube([large_distance*2, INSERT_TOTAL_HEIGHT + 0.2, large_distance]);
    }
}

module grid(rows=[], changeCellOrder = false, maxRowLength = 10) {
	noRowsInfo = len(rows) == 0;
	upCutRowCount = noRowsInfo ? maxRowLength : rows[0];
	downCutRowCount = noRowsInfo ? maxRowLength : rows[len(rows)-1];
	
	assert( !(!noRowsInfo && len(rows) != $children), 
		"rows info if specified must describe all rows! Example: grid(rows=[1,2]) { row() { insert(); } row() { insert(); insert(); } }");

	difference() {
		for (i = [0:$children-1]) {
			tY = cellOffsetY(i, changeCellOrder);
			translate([(cellD - cellD / 4) * i, tY, 0]) children(i);
		}
		for (i = [0:$children-1]) {

			tY = cellOffsetY(i, changeCellOrder); 
			translate([(cellD - cellD / 4) * i, tY  - cellAf, 0]) connectorCutting();

			if (!noRowsInfo) {
				itemsInRow = rows[i];
				for (k=[0:maxRowLength-1]){
					translate([(cellD - cellD / 4) * i, tY  + (k + itemsInRow) * cellAf, 0]) connectorCutting();
				}
			}
		}

		tYUp = cellOffsetY($children, changeCellOrder);
		translate([(cellD - cellD / 4) * $children, -tYUp, 0]){
			for (j=[0:downCutRowCount-1]) {
				translate([0, cellAf * j, 0]) connectorCutting();
			}
		}
		tYDown = cellOffsetY(-1, changeCellOrder);
		translate([-(cellD - cellD / 4), -tYDown, 0])
			for (k=[0:upCutRowCount-1]) {
				translate([0, cellAf * k, 0]) connectorCutting();
			}
	}
}

module row(connections=true, decorations = true) {
	if ($children > 0) {
		difference() {
			for (i = [0:$children-1]) 
				translate([0, cellAf * i, 0]) {
					if (connections) connector(false, decorations);
					children(i);
				}
			translate([(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
			translate([0, cellAf * $children, 0]) connectorCutting();
			translate([-(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
		}
	}
}

// utils modules section ----------------------------------------------------

module insertBase(tolerance=0, decorations=true) {
    $fn = 6;
    difference() {
        union() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER-tolerance*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=INSERT_LIP_DIAMETER, h=INSERT_LIP_HEIGHT);
        }
		if (decorations) {
			translate([0,0,-0.1])
				union() {
					difference() {
						cylinder(d = DECORATION_OUTER_DIAMETER, h = DECORATION_DEPTH + 0.1);
						cylinder(d = DECORATION_INNER_DIAMETER, h = DECORATION_DEPTH + 0.1);
					}
				}

			translate([0,0,DECORATEION_FACET_HEIGHT]) cutFacet(INSERT_LIP_DIAMETER, inverse=true);
		}
        translate([0,0,INSERT_LIP_HEIGHT])
        rotate(90,[0,0,1])
        difference() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=af_to_diameter(INSERT_MAIN_OUTER_DIAMETER-tolerance*2) - 0.12 * 2, h=INSERT_TOTAL_HEIGHT);
        }
        cutFacetBottom();
    }
}

module cutFacet(diameter, inverse=false) {
	h = diameter / 2 * tan(45);
	z = inverse ? -h : 0;
	translate([0,0,z])
		difference() {
			cylinder(d=diameter*2, h = h);
			if (inverse)
				cylinder(d2=diameter, d1=0, h = h);
			else
				cylinder(d1=diameter, d2=0, h = h);
		}
}

module cutFacetBottom() {
	translate([0,0,INSERT_TOTAL_HEIGHT-DECORATEION_FACET_HEIGHT])
		cutFacet(INSERT_MAIN_OUTER_DIAMETER);
}

module cutHexagon(inner_tolerance, indent = 0) {
	// remove preview artifacts
	z = indent == 0 ? -0.5 : indent;
	addH = indent == 0 ? 1 : 0;
	translate([0,0,z]) 
		cylinder(d=INSERT_MAIN_INNER_DIAMETER + inner_tolerance*2, h=INSERT_TOTAL_HEIGHT + addH, $fn=6);
}

module insertMX(diameter,  nutWidth, tolerance = 0, decorations = true) {
	spacer = 0.2;
	holeD = min(maxInnerDiameter, diameter + spacer);
	facet = holeD / 8;
	facetH = 0.3;
	nutW = min(maxInnerDiameter, nutWidth + spacer);
	aboveNutW = min(maxInnerDiameter, nutW + 6);

	difference() {
		insert(tolerance, decorations = decorations);
		translate([0,0,-0.1]) // remove preview artifacts
			cylinder(d1 = holeD + facet * 2, d2 = holeD, h = facetH + 0.1);
		cylinder(d = holeD, h = INSERT_TOTAL_HEIGHT);
		translate([0, 0, 4])
		cylinder(d = nutW, h = INSERT_TOTAL_HEIGHT, $fn=6);
		translate([0, 0, 7])
		cylinder(d = aboveNutW, h = INSERT_TOTAL_HEIGHT + 0.1, $fn=6);
	}
}

module connector(forCutting=false, decorations = true) {
	connectorW = (cellAf-INSERT_LIP_AF_DISTANCE);
	connectorH = decorations ? INSERT_LIP_HEIGHT - DECORATEION_FACET_HEIGHT : INSERT_LIP_HEIGHT;
	connectorL = INSERT_LIP_DIAMETER/2;
	cuttingTranslateZ = forCutting ? -2 : 0;
	cuttingScaleZ = forCutting ? 2 : 1;

	translate([0,0,cuttingTranslateZ])
		scale([1,1,cuttingScaleZ]) 
			for (a=[0:60:300])
			rotate(a,[0,0,1])
				translate([-connectorL/2, -INSERT_LIP_AF_DISTANCE/2 - connectorW, decorations ? DECORATEION_FACET_HEIGHT : 0]) {
				points = [
					[0, addCutting(connectorW)],
					[connectorL, addCutting(connectorW)],
					[connectorL, 0],
					[0, 0],
					[-(connectorW*sin(60)), connectorW/2]
				];
				linear_extrude(height = connectorH) polygon(points);
			}

	function addCutting(value) = forCutting ? value + 0.1 : value;
}

module connectorCutting() connector(true, true);
function cellOrder(i, change) = change ? i % 2 == 0 : i % 2 != 0;
function cellOffsetY(i, change) = cellOrder(i, change) ? 0 : cellAf / 2;

/* converts an 'across flats' dimension to a maximum diameter — useful for openScad */
function af_to_diameter(af) = af / sqrt(3) * 2;
function diameter_to_af(diameter) = diameter * sqrt(3) / 2;

// ---- part ----
insert_with_plate();
`);

Open in editor →

HSW Insert base (friction, no latches)

The bare insert body without the spring latches - a friction-only building block for designs that add their own retention.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
/* Library of hex wall bits */
/* updated */
$fn = 64;  // curve smoothness

/* Constants relating to the insert part */
INSERT_MAIN_OUTER_AF_DISTANCE = 19.7;
INSERT_MAIN_INNER_AF_DISTANCE = 13.4;
INSERT_LIP_AF_DISTANCE = 22.5;
INSERT_MAIN_OUTER_DIAMETER = af_to_diameter(INSERT_MAIN_OUTER_AF_DISTANCE);
INSERT_MAIN_INNER_DIAMETER = af_to_diameter(INSERT_MAIN_INNER_AF_DISTANCE);
INSERT_LIP_DIAMETER = af_to_diameter(INSERT_LIP_AF_DISTANCE);
INSERT_TOTAL_HEIGHT = 10;
INSERT_LIP_HEIGHT = 2.5;
INSERT_LIP_PROTRUSION = (INSERT_LIP_AF_DISTANCE - INSERT_MAIN_OUTER_AF_DISTANCE)/2;

/* Constants relating to the honeycomb itself */
HEXAGON_WIDTH = 20;
HEX_WALL_THICKNESS = 3.6;
HEX_SEPARATION = HEXAGON_WIDTH + HEX_WALL_THICKNESS;
HORIZONTAL_HEX_SEPARATION = HEX_SEPARATION * 2 / sqrt(3) + af_to_diameter(HEXAGON_WIDTH + HEX_WALL_THICKNESS)/2;

/* Constants relating to the plug that can go into an empty insert */
PLUG_HEXAGON_DIAMETER = 14.7;
PLUG_AF_SIZE = PLUG_HEXAGON_DIAMETER * sqrt(3) / 2;
PLUG_LENGTH = 13;

DECORATION_OUTER_DIAMETER = 21.362;
DECORATION_INNER_DIAMETER = 19.053;
DECORATION_DEPTH = 0.3;
DECORATEION_FACET_HEIGHT = 0.35;

tiny_distance = .001;
maxInnerDiameter = 16.5;

cellAf = 23.6;
cellD = af_to_diameter(cellAf);

// insert_empty();
// insert_with_plate();
// insert_horizontal();
// hexagon_plug();
// hexagon_plug_horizontal();
// ^ this items has no decorations for compatibility

//insert(); 		// same as insert_with_plate(); but no cut hexagon underneeze
//insertEmpty(); 	// same as insert_empty();
//insertM2_5();
//insertM3();
//insertM4();
//insertM5();
//insertM6();
//insertM8();
//insertM10();
//insertAttachToWall(5, facetHeight = 1, bottomThickness = 1.5, translateHole = [2.5,-3.5], decorations=false);
//insertAttachToWallEmpty(3.5, facetHeight = 2, bottomThickness = 3, withLatch = false, decorations = true, supportless = true);
//hexagonPlug();
//hexagonPlugHorizontal();

//makeInsertHorizontal() insertEmpty(); // <- any insert 


/*
grid(changeCellOrder=false) {
	row(decorations = false) {
		insertAttachToWallEmpty(4, decorations=false, withLatch=true, facetHeight = 1.6);
		insertEmpty(decorations=false);
	}
	row(decorations = false) {
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
	}
}
//*/

module insert_empty(tolerance = 0, inner_tolerance = 0) insertEmpty(tolerance, inner_tolerance, decorations=false);

module insert_with_plate(tolerance = 0, inner_tolerance = 0) { 
	difference() {
		insert(tolerance, decorations=false);
		cutHexagon(inner_tolerance, INSERT_LIP_HEIGHT);
	}
}

module insert_horizontal(tolerance = 0, inner_tolerance = 0) {
	makeInsertHorizontal(tolerance) insert_with_plate(tolerance);
}

module hexagon_plug(tolerance = 0) {
    cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
}

module hexagon_plug_horizontal(tolerance = 0) {
    translate([0, 0, PLUG_AF_SIZE/2 - tolerance])
        rotate([90, 0, 0]) 
			hexagon_plug(tolerance);
}

module insert(tolerance = 0, decorations = true) {
	$fn = 6;
    WALL_SIDE_GAP_START_HEIGHT = 6.5;
    WALL_SIDE_GAP_WIDTH = 1;
    WALL_TOP_GAP_WIDTH = 0.8;
    WALL_GAP_LENGTH = 8;
    WALL_TOP_GAP_RADIUS = 8.25;
    TAB_STICKS_OUT_BY = 0.5;
    TAB_LENGTH = 2;


	difference() {
		union() {
			for (i=[0:5]) {
					rotate([0, 0, i*60]) {
					translate([0, INSERT_MAIN_OUTER_AF_DISTANCE/2 - tolerance, 0]) {
						hull() {
							translate([0, 0, WALL_SIDE_GAP_START_HEIGHT + WALL_SIDE_GAP_WIDTH + TAB_STICKS_OUT_BY]) {
								rotate([0,90,0]){
									cylinder(r=TAB_STICKS_OUT_BY, h=TAB_LENGTH, center=true, $fn=20);
								}
							}
							translate([0, 0, INSERT_TOTAL_HEIGHT - tiny_distance]) {
								rotate([0, 90, 0]) {
									cylinder(r=0.2, h=TAB_LENGTH, center=true, $fn=20);  // rounded retention-tab tip
								}
							}
						}
					}
				}
			}
			difference() {
				insertBase(tolerance, decorations);
				for (i=[0:5]) {
					rotate([0, 0, i*60]) {
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS - tolerance, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, WALL_TOP_GAP_WIDTH, 10]);
						}
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, 10, WALL_SIDE_GAP_WIDTH]);
						}
					}
				}
			}
		}
		cutFacetBottom();
	}
}

module insertEmpty(tolerance = 0, inner_tolerance = 0, decorations = true) {
	difference() {
		insert(tolerance, decorations);
		cutHexagon(inner_tolerance);
	}
}

module insertM2_5(tolerance=0, decorations=true) insertMX(2.5, 5.77, tolerance=tolerance, decorations=decorations);
module insertM3(tolerance=0, decorations=true)   insertMX(3, 6.35, tolerance=tolerance, decorations=decorations);
module insertM4(tolerance=0, decorations=true)   insertMX(4, 8.08, tolerance=tolerance, decorations=decorations);
module insertM5(tolerance=0, decorations=true)   insertMX(5, 9.24, tolerance=tolerance, decorations=decorations);
module insertM6(tolerance=0, decorations=true)   insertMX(6, 11.55, tolerance=tolerance, decorations=decorations);
module insertM8(tolerance=0, decorations=true)   insertMX(8, 15.01, tolerance=tolerance, decorations=decorations);
module insertM10(tolerance=0, decorations=true)  insertMX(10, 17.32, tolerance=tolerance, decorations=decorations);

function calculateFacetDiameter(holeD, facetHeight) = facetHeight * 2 + holeD;

module insertAttachToWall(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 1.5, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, // <- I think there is no need latch, but you can turn it on
	translateHole = [0,0], // <- if you drill hole not accurate, you can move it by [x, y],
	decorations = true
) {
	$fn=64;
	isTranslateHole = translateHole[0] != 0 || translateHole[1] != 0;
	spacer = 0.2;
	holeD = holeDiameter + spacer;
	outHoleDiameter = isTranslateHole ? maxInnerDiameter : holeD + 4;
	facetD = calculateFacetDiameter(holeD, facetHeight);

	difference() {
		if (withLatch)  
			insert(tolerance, decorations = decorations);
		 else  
			insertBase(tolerance, decorations = decorations);

		translate([0, 0, -bottomThickness]) cylinder(d = outHoleDiameter, h = INSERT_TOTAL_HEIGHT); 

		if (isTranslateHole) 
			translate([translateHole[0], translateHole[1], 0]) hole();
		else 
			hole();
	}

	module hole() {
		translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness - 0.1]) cylinder(d1 = facetD, d2 = holeD, h = facetHeight + 0.1); 
		cylinder(d = holeD, INSERT_TOTAL_HEIGHT + 0.1); 
	}
}

module insertAttachToWallEmpty(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 2, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, 
	decorations = true,
    supportless = false,
) {
    layerThickness = 0.2;

	difference() {
		insertAttachToWall(holeDiameter, facetHeight, bottomThickness, tolerance, inner_tolerance, withLatch, decorations = decorations);
		cutHexagon(inner_tolerance, -bottomThickness);
	}
    if (supportless) {
        translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness]) 
            difference() {
                cylinder(d = PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 2, $fn = 6, center = true);  
                cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight), layerThickness * 4], center = true);  
            }
        translate([0,0,INSERT_TOTAL_HEIGHT-bottomThickness]) 
            difference() {
                cylinder(d=PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 4, $fn = 6, center = true);  
                rotate(90, [0, 0, 1]) 
                    cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight),layerThickness* 2 * 2 * 2], center = true);  
            }
    }
}

module hexagonPlug(tolerance=0, decorations=true) {
	if (decorations) {
		D = PLUG_HEXAGON_DIAMETER - tolerance*2;
		intersection() {
			cylinder(d=D, h=PLUG_LENGTH, $fn=6);
			translate([0,0,-0.75])
				cylinder(r1=PLUG_LENGTH + D/2, r2=0, h = PLUG_LENGTH + D/2, $fn=6); 
			translate([0,0,-D/2 + 0.75])
				cylinder(r2=PLUG_LENGTH + D/2, r1=0, h = PLUG_LENGTH + D/2, $fn=6); 
		}
	} else {
		cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
	}
}

module hexagonPlugHorizontal(tolerance=0, decorations=true) {
	translate([0,0, PLUG_AF_SIZE/2] )
	translate([0,0,-INSERT_MAIN_OUTER_AF_DISTANCE/2] )
	makeInsertHorizontal() hexagonPlug(tolerance, decorations);
}

module makeInsertHorizontal(tolerance=0) {
    large_distance=10;
    difference() {
        translate([0, 0, INSERT_MAIN_OUTER_AF_DISTANCE/2]) 
            rotate([90, 0, 0])
                children();
        translate([-large_distance, -INSERT_TOTAL_HEIGHT - 0.1, -large_distance + tolerance]) 
            cube([large_distance*2, INSERT_TOTAL_HEIGHT + 0.2, large_distance]);
    }
}

module grid(rows=[], changeCellOrder = false, maxRowLength = 10) {
	noRowsInfo = len(rows) == 0;
	upCutRowCount = noRowsInfo ? maxRowLength : rows[0];
	downCutRowCount = noRowsInfo ? maxRowLength : rows[len(rows)-1];
	
	assert( !(!noRowsInfo && len(rows) != $children), 
		"rows info if specified must describe all rows! Example: grid(rows=[1,2]) { row() { insert(); } row() { insert(); insert(); } }");

	difference() {
		for (i = [0:$children-1]) {
			tY = cellOffsetY(i, changeCellOrder);
			translate([(cellD - cellD / 4) * i, tY, 0]) children(i);
		}
		for (i = [0:$children-1]) {

			tY = cellOffsetY(i, changeCellOrder); 
			translate([(cellD - cellD / 4) * i, tY  - cellAf, 0]) connectorCutting();

			if (!noRowsInfo) {
				itemsInRow = rows[i];
				for (k=[0:maxRowLength-1]){
					translate([(cellD - cellD / 4) * i, tY  + (k + itemsInRow) * cellAf, 0]) connectorCutting();
				}
			}
		}

		tYUp = cellOffsetY($children, changeCellOrder);
		translate([(cellD - cellD / 4) * $children, -tYUp, 0]){
			for (j=[0:downCutRowCount-1]) {
				translate([0, cellAf * j, 0]) connectorCutting();
			}
		}
		tYDown = cellOffsetY(-1, changeCellOrder);
		translate([-(cellD - cellD / 4), -tYDown, 0])
			for (k=[0:upCutRowCount-1]) {
				translate([0, cellAf * k, 0]) connectorCutting();
			}
	}
}

module row(connections=true, decorations = true) {
	if ($children > 0) {
		difference() {
			for (i = [0:$children-1]) 
				translate([0, cellAf * i, 0]) {
					if (connections) connector(false, decorations);
					children(i);
				}
			translate([(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
			translate([0, cellAf * $children, 0]) connectorCutting();
			translate([-(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
		}
	}
}

// utils modules section ----------------------------------------------------

module insertBase(tolerance=0, decorations=true) {
    $fn = 6;
    difference() {
        union() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER-tolerance*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=INSERT_LIP_DIAMETER, h=INSERT_LIP_HEIGHT);
        }
		if (decorations) {
			translate([0,0,-0.1])
				union() {
					difference() {
						cylinder(d = DECORATION_OUTER_DIAMETER, h = DECORATION_DEPTH + 0.1);
						cylinder(d = DECORATION_INNER_DIAMETER, h = DECORATION_DEPTH + 0.1);
					}
				}

			translate([0,0,DECORATEION_FACET_HEIGHT]) cutFacet(INSERT_LIP_DIAMETER, inverse=true);
		}
        translate([0,0,INSERT_LIP_HEIGHT])
        rotate(90,[0,0,1])
        difference() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=af_to_diameter(INSERT_MAIN_OUTER_DIAMETER-tolerance*2) - 0.12 * 2, h=INSERT_TOTAL_HEIGHT);
        }
        cutFacetBottom();
    }
}

module cutFacet(diameter, inverse=false) {
	h = diameter / 2 * tan(45);
	z = inverse ? -h : 0;
	translate([0,0,z])
		difference() {
			cylinder(d=diameter*2, h = h);
			if (inverse)
				cylinder(d2=diameter, d1=0, h = h);
			else
				cylinder(d1=diameter, d2=0, h = h);
		}
}

module cutFacetBottom() {
	translate([0,0,INSERT_TOTAL_HEIGHT-DECORATEION_FACET_HEIGHT])
		cutFacet(INSERT_MAIN_OUTER_DIAMETER);
}

module cutHexagon(inner_tolerance, indent = 0) {
	// remove preview artifacts
	z = indent == 0 ? -0.5 : indent;
	addH = indent == 0 ? 1 : 0;
	translate([0,0,z]) 
		cylinder(d=INSERT_MAIN_INNER_DIAMETER + inner_tolerance*2, h=INSERT_TOTAL_HEIGHT + addH, $fn=6);
}

module insertMX(diameter,  nutWidth, tolerance = 0, decorations = true) {
	spacer = 0.2;
	holeD = min(maxInnerDiameter, diameter + spacer);
	facet = holeD / 8;
	facetH = 0.3;
	nutW = min(maxInnerDiameter, nutWidth + spacer);
	aboveNutW = min(maxInnerDiameter, nutW + 6);

	difference() {
		insert(tolerance, decorations = decorations);
		translate([0,0,-0.1]) // remove preview artifacts
			cylinder(d1 = holeD + facet * 2, d2 = holeD, h = facetH + 0.1);
		cylinder(d = holeD, h = INSERT_TOTAL_HEIGHT);
		translate([0, 0, 4])
		cylinder(d = nutW, h = INSERT_TOTAL_HEIGHT, $fn=6);
		translate([0, 0, 7])
		cylinder(d = aboveNutW, h = INSERT_TOTAL_HEIGHT + 0.1, $fn=6);
	}
}

module connector(forCutting=false, decorations = true) {
	connectorW = (cellAf-INSERT_LIP_AF_DISTANCE);
	connectorH = decorations ? INSERT_LIP_HEIGHT - DECORATEION_FACET_HEIGHT : INSERT_LIP_HEIGHT;
	connectorL = INSERT_LIP_DIAMETER/2;
	cuttingTranslateZ = forCutting ? -2 : 0;
	cuttingScaleZ = forCutting ? 2 : 1;

	translate([0,0,cuttingTranslateZ])
		scale([1,1,cuttingScaleZ]) 
			for (a=[0:60:300])
			rotate(a,[0,0,1])
				translate([-connectorL/2, -INSERT_LIP_AF_DISTANCE/2 - connectorW, decorations ? DECORATEION_FACET_HEIGHT : 0]) {
				points = [
					[0, addCutting(connectorW)],
					[connectorL, addCutting(connectorW)],
					[connectorL, 0],
					[0, 0],
					[-(connectorW*sin(60)), connectorW/2]
				];
				linear_extrude(height = connectorH) polygon(points);
			}

	function addCutting(value) = forCutting ? value + 0.1 : value;
}

module connectorCutting() connector(true, true);
function cellOrder(i, change) = change ? i % 2 == 0 : i % 2 != 0;
function cellOffsetY(i, change) = cellOrder(i, change) ? 0 : cellAf / 2;

/* converts an 'across flats' dimension to a maximum diameter — useful for openScad */
function af_to_diameter(af) = af / sqrt(3) * 2;
function diameter_to_af(diameter) = diameter * sqrt(3) / 2;

// ---- part ----
insertBase();
`);

Open in editor →

HSW Hex plug

A plain hexagonal plug that press-fits into an empty insert (or a wall cell) to blank it off or anchor a part.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
/* Library of hex wall bits */
/* updated */
$fn = 64;  // curve smoothness

/* Constants relating to the insert part */
INSERT_MAIN_OUTER_AF_DISTANCE = 19.7;
INSERT_MAIN_INNER_AF_DISTANCE = 13.4;
INSERT_LIP_AF_DISTANCE = 22.5;
INSERT_MAIN_OUTER_DIAMETER = af_to_diameter(INSERT_MAIN_OUTER_AF_DISTANCE);
INSERT_MAIN_INNER_DIAMETER = af_to_diameter(INSERT_MAIN_INNER_AF_DISTANCE);
INSERT_LIP_DIAMETER = af_to_diameter(INSERT_LIP_AF_DISTANCE);
INSERT_TOTAL_HEIGHT = 10;
INSERT_LIP_HEIGHT = 2.5;
INSERT_LIP_PROTRUSION = (INSERT_LIP_AF_DISTANCE - INSERT_MAIN_OUTER_AF_DISTANCE)/2;

/* Constants relating to the honeycomb itself */
HEXAGON_WIDTH = 20;
HEX_WALL_THICKNESS = 3.6;
HEX_SEPARATION = HEXAGON_WIDTH + HEX_WALL_THICKNESS;
HORIZONTAL_HEX_SEPARATION = HEX_SEPARATION * 2 / sqrt(3) + af_to_diameter(HEXAGON_WIDTH + HEX_WALL_THICKNESS)/2;

/* Constants relating to the plug that can go into an empty insert */
PLUG_HEXAGON_DIAMETER = 14.7;
PLUG_AF_SIZE = PLUG_HEXAGON_DIAMETER * sqrt(3) / 2;
PLUG_LENGTH = 13;

DECORATION_OUTER_DIAMETER = 21.362;
DECORATION_INNER_DIAMETER = 19.053;
DECORATION_DEPTH = 0.3;
DECORATEION_FACET_HEIGHT = 0.35;

tiny_distance = .001;
maxInnerDiameter = 16.5;

cellAf = 23.6;
cellD = af_to_diameter(cellAf);

// insert_empty();
// insert_with_plate();
// insert_horizontal();
// hexagon_plug();
// hexagon_plug_horizontal();
// ^ this items has no decorations for compatibility

//insert(); 		// same as insert_with_plate(); but no cut hexagon underneeze
//insertEmpty(); 	// same as insert_empty();
//insertM2_5();
//insertM3();
//insertM4();
//insertM5();
//insertM6();
//insertM8();
//insertM10();
//insertAttachToWall(5, facetHeight = 1, bottomThickness = 1.5, translateHole = [2.5,-3.5], decorations=false);
//insertAttachToWallEmpty(3.5, facetHeight = 2, bottomThickness = 3, withLatch = false, decorations = true, supportless = true);
//hexagonPlug();
//hexagonPlugHorizontal();

//makeInsertHorizontal() insertEmpty(); // <- any insert 


/*
grid(changeCellOrder=false) {
	row(decorations = false) {
		insertAttachToWallEmpty(4, decorations=false, withLatch=true, facetHeight = 1.6);
		insertEmpty(decorations=false);
	}
	row(decorations = false) {
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
	}
}
//*/

module insert_empty(tolerance = 0, inner_tolerance = 0) insertEmpty(tolerance, inner_tolerance, decorations=false);

module insert_with_plate(tolerance = 0, inner_tolerance = 0) { 
	difference() {
		insert(tolerance, decorations=false);
		cutHexagon(inner_tolerance, INSERT_LIP_HEIGHT);
	}
}

module insert_horizontal(tolerance = 0, inner_tolerance = 0) {
	makeInsertHorizontal(tolerance) insert_with_plate(tolerance);
}

module hexagon_plug(tolerance = 0) {
    cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
}

module hexagon_plug_horizontal(tolerance = 0) {
    translate([0, 0, PLUG_AF_SIZE/2 - tolerance])
        rotate([90, 0, 0]) 
			hexagon_plug(tolerance);
}

module insert(tolerance = 0, decorations = true) {
	$fn = 6;
    WALL_SIDE_GAP_START_HEIGHT = 6.5;
    WALL_SIDE_GAP_WIDTH = 1;
    WALL_TOP_GAP_WIDTH = 0.8;
    WALL_GAP_LENGTH = 8;
    WALL_TOP_GAP_RADIUS = 8.25;
    TAB_STICKS_OUT_BY = 0.5;
    TAB_LENGTH = 2;


	difference() {
		union() {
			for (i=[0:5]) {
					rotate([0, 0, i*60]) {
					translate([0, INSERT_MAIN_OUTER_AF_DISTANCE/2 - tolerance, 0]) {
						hull() {
							translate([0, 0, WALL_SIDE_GAP_START_HEIGHT + WALL_SIDE_GAP_WIDTH + TAB_STICKS_OUT_BY]) {
								rotate([0,90,0]){
									cylinder(r=TAB_STICKS_OUT_BY, h=TAB_LENGTH, center=true, $fn=20);
								}
							}
							translate([0, 0, INSERT_TOTAL_HEIGHT - tiny_distance]) {
								rotate([0, 90, 0]) {
									cylinder(r=0.2, h=TAB_LENGTH, center=true, $fn=20);  // rounded retention-tab tip
								}
							}
						}
					}
				}
			}
			difference() {
				insertBase(tolerance, decorations);
				for (i=[0:5]) {
					rotate([0, 0, i*60]) {
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS - tolerance, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, WALL_TOP_GAP_WIDTH, 10]);
						}
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, 10, WALL_SIDE_GAP_WIDTH]);
						}
					}
				}
			}
		}
		cutFacetBottom();
	}
}

module insertEmpty(tolerance = 0, inner_tolerance = 0, decorations = true) {
	difference() {
		insert(tolerance, decorations);
		cutHexagon(inner_tolerance);
	}
}

module insertM2_5(tolerance=0, decorations=true) insertMX(2.5, 5.77, tolerance=tolerance, decorations=decorations);
module insertM3(tolerance=0, decorations=true)   insertMX(3, 6.35, tolerance=tolerance, decorations=decorations);
module insertM4(tolerance=0, decorations=true)   insertMX(4, 8.08, tolerance=tolerance, decorations=decorations);
module insertM5(tolerance=0, decorations=true)   insertMX(5, 9.24, tolerance=tolerance, decorations=decorations);
module insertM6(tolerance=0, decorations=true)   insertMX(6, 11.55, tolerance=tolerance, decorations=decorations);
module insertM8(tolerance=0, decorations=true)   insertMX(8, 15.01, tolerance=tolerance, decorations=decorations);
module insertM10(tolerance=0, decorations=true)  insertMX(10, 17.32, tolerance=tolerance, decorations=decorations);

function calculateFacetDiameter(holeD, facetHeight) = facetHeight * 2 + holeD;

module insertAttachToWall(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 1.5, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, // <- I think there is no need latch, but you can turn it on
	translateHole = [0,0], // <- if you drill hole not accurate, you can move it by [x, y],
	decorations = true
) {
	$fn=64;
	isTranslateHole = translateHole[0] != 0 || translateHole[1] != 0;
	spacer = 0.2;
	holeD = holeDiameter + spacer;
	outHoleDiameter = isTranslateHole ? maxInnerDiameter : holeD + 4;
	facetD = calculateFacetDiameter(holeD, facetHeight);

	difference() {
		if (withLatch)  
			insert(tolerance, decorations = decorations);
		 else  
			insertBase(tolerance, decorations = decorations);

		translate([0, 0, -bottomThickness]) cylinder(d = outHoleDiameter, h = INSERT_TOTAL_HEIGHT); 

		if (isTranslateHole) 
			translate([translateHole[0], translateHole[1], 0]) hole();
		else 
			hole();
	}

	module hole() {
		translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness - 0.1]) cylinder(d1 = facetD, d2 = holeD, h = facetHeight + 0.1); 
		cylinder(d = holeD, INSERT_TOTAL_HEIGHT + 0.1); 
	}
}

module insertAttachToWallEmpty(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 2, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, 
	decorations = true,
    supportless = false,
) {
    layerThickness = 0.2;

	difference() {
		insertAttachToWall(holeDiameter, facetHeight, bottomThickness, tolerance, inner_tolerance, withLatch, decorations = decorations);
		cutHexagon(inner_tolerance, -bottomThickness);
	}
    if (supportless) {
        translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness]) 
            difference() {
                cylinder(d = PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 2, $fn = 6, center = true);  
                cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight), layerThickness * 4], center = true);  
            }
        translate([0,0,INSERT_TOTAL_HEIGHT-bottomThickness]) 
            difference() {
                cylinder(d=PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 4, $fn = 6, center = true);  
                rotate(90, [0, 0, 1]) 
                    cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight),layerThickness* 2 * 2 * 2], center = true);  
            }
    }
}

module hexagonPlug(tolerance=0, decorations=true) {
	if (decorations) {
		D = PLUG_HEXAGON_DIAMETER - tolerance*2;
		intersection() {
			cylinder(d=D, h=PLUG_LENGTH, $fn=6);
			translate([0,0,-0.75])
				cylinder(r1=PLUG_LENGTH + D/2, r2=0, h = PLUG_LENGTH + D/2, $fn=6); 
			translate([0,0,-D/2 + 0.75])
				cylinder(r2=PLUG_LENGTH + D/2, r1=0, h = PLUG_LENGTH + D/2, $fn=6); 
		}
	} else {
		cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
	}
}

module hexagonPlugHorizontal(tolerance=0, decorations=true) {
	translate([0,0, PLUG_AF_SIZE/2] )
	translate([0,0,-INSERT_MAIN_OUTER_AF_DISTANCE/2] )
	makeInsertHorizontal() hexagonPlug(tolerance, decorations);
}

module makeInsertHorizontal(tolerance=0) {
    large_distance=10;
    difference() {
        translate([0, 0, INSERT_MAIN_OUTER_AF_DISTANCE/2]) 
            rotate([90, 0, 0])
                children();
        translate([-large_distance, -INSERT_TOTAL_HEIGHT - 0.1, -large_distance + tolerance]) 
            cube([large_distance*2, INSERT_TOTAL_HEIGHT + 0.2, large_distance]);
    }
}

module grid(rows=[], changeCellOrder = false, maxRowLength = 10) {
	noRowsInfo = len(rows) == 0;
	upCutRowCount = noRowsInfo ? maxRowLength : rows[0];
	downCutRowCount = noRowsInfo ? maxRowLength : rows[len(rows)-1];
	
	assert( !(!noRowsInfo && len(rows) != $children), 
		"rows info if specified must describe all rows! Example: grid(rows=[1,2]) { row() { insert(); } row() { insert(); insert(); } }");

	difference() {
		for (i = [0:$children-1]) {
			tY = cellOffsetY(i, changeCellOrder);
			translate([(cellD - cellD / 4) * i, tY, 0]) children(i);
		}
		for (i = [0:$children-1]) {

			tY = cellOffsetY(i, changeCellOrder); 
			translate([(cellD - cellD / 4) * i, tY  - cellAf, 0]) connectorCutting();

			if (!noRowsInfo) {
				itemsInRow = rows[i];
				for (k=[0:maxRowLength-1]){
					translate([(cellD - cellD / 4) * i, tY  + (k + itemsInRow) * cellAf, 0]) connectorCutting();
				}
			}
		}

		tYUp = cellOffsetY($children, changeCellOrder);
		translate([(cellD - cellD / 4) * $children, -tYUp, 0]){
			for (j=[0:downCutRowCount-1]) {
				translate([0, cellAf * j, 0]) connectorCutting();
			}
		}
		tYDown = cellOffsetY(-1, changeCellOrder);
		translate([-(cellD - cellD / 4), -tYDown, 0])
			for (k=[0:upCutRowCount-1]) {
				translate([0, cellAf * k, 0]) connectorCutting();
			}
	}
}

module row(connections=true, decorations = true) {
	if ($children > 0) {
		difference() {
			for (i = [0:$children-1]) 
				translate([0, cellAf * i, 0]) {
					if (connections) connector(false, decorations);
					children(i);
				}
			translate([(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
			translate([0, cellAf * $children, 0]) connectorCutting();
			translate([-(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
		}
	}
}

// utils modules section ----------------------------------------------------

module insertBase(tolerance=0, decorations=true) {
    $fn = 6;
    difference() {
        union() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER-tolerance*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=INSERT_LIP_DIAMETER, h=INSERT_LIP_HEIGHT);
        }
		if (decorations) {
			translate([0,0,-0.1])
				union() {
					difference() {
						cylinder(d = DECORATION_OUTER_DIAMETER, h = DECORATION_DEPTH + 0.1);
						cylinder(d = DECORATION_INNER_DIAMETER, h = DECORATION_DEPTH + 0.1);
					}
				}

			translate([0,0,DECORATEION_FACET_HEIGHT]) cutFacet(INSERT_LIP_DIAMETER, inverse=true);
		}
        translate([0,0,INSERT_LIP_HEIGHT])
        rotate(90,[0,0,1])
        difference() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=af_to_diameter(INSERT_MAIN_OUTER_DIAMETER-tolerance*2) - 0.12 * 2, h=INSERT_TOTAL_HEIGHT);
        }
        cutFacetBottom();
    }
}

module cutFacet(diameter, inverse=false) {
	h = diameter / 2 * tan(45);
	z = inverse ? -h : 0;
	translate([0,0,z])
		difference() {
			cylinder(d=diameter*2, h = h);
			if (inverse)
				cylinder(d2=diameter, d1=0, h = h);
			else
				cylinder(d1=diameter, d2=0, h = h);
		}
}

module cutFacetBottom() {
	translate([0,0,INSERT_TOTAL_HEIGHT-DECORATEION_FACET_HEIGHT])
		cutFacet(INSERT_MAIN_OUTER_DIAMETER);
}

module cutHexagon(inner_tolerance, indent = 0) {
	// remove preview artifacts
	z = indent == 0 ? -0.5 : indent;
	addH = indent == 0 ? 1 : 0;
	translate([0,0,z]) 
		cylinder(d=INSERT_MAIN_INNER_DIAMETER + inner_tolerance*2, h=INSERT_TOTAL_HEIGHT + addH, $fn=6);
}

module insertMX(diameter,  nutWidth, tolerance = 0, decorations = true) {
	spacer = 0.2;
	holeD = min(maxInnerDiameter, diameter + spacer);
	facet = holeD / 8;
	facetH = 0.3;
	nutW = min(maxInnerDiameter, nutWidth + spacer);
	aboveNutW = min(maxInnerDiameter, nutW + 6);

	difference() {
		insert(tolerance, decorations = decorations);
		translate([0,0,-0.1]) // remove preview artifacts
			cylinder(d1 = holeD + facet * 2, d2 = holeD, h = facetH + 0.1);
		cylinder(d = holeD, h = INSERT_TOTAL_HEIGHT);
		translate([0, 0, 4])
		cylinder(d = nutW, h = INSERT_TOTAL_HEIGHT, $fn=6);
		translate([0, 0, 7])
		cylinder(d = aboveNutW, h = INSERT_TOTAL_HEIGHT + 0.1, $fn=6);
	}
}

module connector(forCutting=false, decorations = true) {
	connectorW = (cellAf-INSERT_LIP_AF_DISTANCE);
	connectorH = decorations ? INSERT_LIP_HEIGHT - DECORATEION_FACET_HEIGHT : INSERT_LIP_HEIGHT;
	connectorL = INSERT_LIP_DIAMETER/2;
	cuttingTranslateZ = forCutting ? -2 : 0;
	cuttingScaleZ = forCutting ? 2 : 1;

	translate([0,0,cuttingTranslateZ])
		scale([1,1,cuttingScaleZ]) 
			for (a=[0:60:300])
			rotate(a,[0,0,1])
				translate([-connectorL/2, -INSERT_LIP_AF_DISTANCE/2 - connectorW, decorations ? DECORATEION_FACET_HEIGHT : 0]) {
				points = [
					[0, addCutting(connectorW)],
					[connectorL, addCutting(connectorW)],
					[connectorL, 0],
					[0, 0],
					[-(connectorW*sin(60)), connectorW/2]
				];
				linear_extrude(height = connectorH) polygon(points);
			}

	function addCutting(value) = forCutting ? value + 0.1 : value;
}

module connectorCutting() connector(true, true);
function cellOrder(i, change) = change ? i % 2 == 0 : i % 2 != 0;
function cellOffsetY(i, change) = cellOrder(i, change) ? 0 : cellAf / 2;

/* converts an 'across flats' dimension to a maximum diameter — useful for openScad */
function af_to_diameter(af) = af / sqrt(3) * 2;
function diameter_to_af(diameter) = diameter * sqrt(3) / 2;

// ---- part ----
hexagonPlug(decorations = false);
`);

Open in editor →

HSW M2.5 nut insert

A wall insert with a captive M2.5 nut pocket and screw clearance - bolt accessories straight to the wall. (Sister recipes cover M3-M10; call insertM3()..insertM10() for other sizes.)

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
/* Library of hex wall bits */
/* updated */
$fn = 64;  // curve smoothness

/* Constants relating to the insert part */
INSERT_MAIN_OUTER_AF_DISTANCE = 19.7;
INSERT_MAIN_INNER_AF_DISTANCE = 13.4;
INSERT_LIP_AF_DISTANCE = 22.5;
INSERT_MAIN_OUTER_DIAMETER = af_to_diameter(INSERT_MAIN_OUTER_AF_DISTANCE);
INSERT_MAIN_INNER_DIAMETER = af_to_diameter(INSERT_MAIN_INNER_AF_DISTANCE);
INSERT_LIP_DIAMETER = af_to_diameter(INSERT_LIP_AF_DISTANCE);
INSERT_TOTAL_HEIGHT = 10;
INSERT_LIP_HEIGHT = 2.5;
INSERT_LIP_PROTRUSION = (INSERT_LIP_AF_DISTANCE - INSERT_MAIN_OUTER_AF_DISTANCE)/2;

/* Constants relating to the honeycomb itself */
HEXAGON_WIDTH = 20;
HEX_WALL_THICKNESS = 3.6;
HEX_SEPARATION = HEXAGON_WIDTH + HEX_WALL_THICKNESS;
HORIZONTAL_HEX_SEPARATION = HEX_SEPARATION * 2 / sqrt(3) + af_to_diameter(HEXAGON_WIDTH + HEX_WALL_THICKNESS)/2;

/* Constants relating to the plug that can go into an empty insert */
PLUG_HEXAGON_DIAMETER = 14.7;
PLUG_AF_SIZE = PLUG_HEXAGON_DIAMETER * sqrt(3) / 2;
PLUG_LENGTH = 13;

DECORATION_OUTER_DIAMETER = 21.362;
DECORATION_INNER_DIAMETER = 19.053;
DECORATION_DEPTH = 0.3;
DECORATEION_FACET_HEIGHT = 0.35;

tiny_distance = .001;
maxInnerDiameter = 16.5;

cellAf = 23.6;
cellD = af_to_diameter(cellAf);

// insert_empty();
// insert_with_plate();
// insert_horizontal();
// hexagon_plug();
// hexagon_plug_horizontal();
// ^ this items has no decorations for compatibility

//insert(); 		// same as insert_with_plate(); but no cut hexagon underneeze
//insertEmpty(); 	// same as insert_empty();
//insertM2_5();
//insertM3();
//insertM4();
//insertM5();
//insertM6();
//insertM8();
//insertM10();
//insertAttachToWall(5, facetHeight = 1, bottomThickness = 1.5, translateHole = [2.5,-3.5], decorations=false);
//insertAttachToWallEmpty(3.5, facetHeight = 2, bottomThickness = 3, withLatch = false, decorations = true, supportless = true);
//hexagonPlug();
//hexagonPlugHorizontal();

//makeInsertHorizontal() insertEmpty(); // <- any insert 


/*
grid(changeCellOrder=false) {
	row(decorations = false) {
		insertAttachToWallEmpty(4, decorations=false, withLatch=true, facetHeight = 1.6);
		insertEmpty(decorations=false);
	}
	row(decorations = false) {
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
	}
}
//*/

module insert_empty(tolerance = 0, inner_tolerance = 0) insertEmpty(tolerance, inner_tolerance, decorations=false);

module insert_with_plate(tolerance = 0, inner_tolerance = 0) { 
	difference() {
		insert(tolerance, decorations=false);
		cutHexagon(inner_tolerance, INSERT_LIP_HEIGHT);
	}
}

module insert_horizontal(tolerance = 0, inner_tolerance = 0) {
	makeInsertHorizontal(tolerance) insert_with_plate(tolerance);
}

module hexagon_plug(tolerance = 0) {
    cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
}

module hexagon_plug_horizontal(tolerance = 0) {
    translate([0, 0, PLUG_AF_SIZE/2 - tolerance])
        rotate([90, 0, 0]) 
			hexagon_plug(tolerance);
}

module insert(tolerance = 0, decorations = true) {
	$fn = 6;
    WALL_SIDE_GAP_START_HEIGHT = 6.5;
    WALL_SIDE_GAP_WIDTH = 1;
    WALL_TOP_GAP_WIDTH = 0.8;
    WALL_GAP_LENGTH = 8;
    WALL_TOP_GAP_RADIUS = 8.25;
    TAB_STICKS_OUT_BY = 0.5;
    TAB_LENGTH = 2;


	difference() {
		union() {
			for (i=[0:5]) {
					rotate([0, 0, i*60]) {
					translate([0, INSERT_MAIN_OUTER_AF_DISTANCE/2 - tolerance, 0]) {
						hull() {
							translate([0, 0, WALL_SIDE_GAP_START_HEIGHT + WALL_SIDE_GAP_WIDTH + TAB_STICKS_OUT_BY]) {
								rotate([0,90,0]){
									cylinder(r=TAB_STICKS_OUT_BY, h=TAB_LENGTH, center=true, $fn=20);
								}
							}
							translate([0, 0, INSERT_TOTAL_HEIGHT - tiny_distance]) {
								rotate([0, 90, 0]) {
									cylinder(r=0.2, h=TAB_LENGTH, center=true, $fn=20);  // rounded retention-tab tip
								}
							}
						}
					}
				}
			}
			difference() {
				insertBase(tolerance, decorations);
				for (i=[0:5]) {
					rotate([0, 0, i*60]) {
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS - tolerance, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, WALL_TOP_GAP_WIDTH, 10]);
						}
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, 10, WALL_SIDE_GAP_WIDTH]);
						}
					}
				}
			}
		}
		cutFacetBottom();
	}
}

module insertEmpty(tolerance = 0, inner_tolerance = 0, decorations = true) {
	difference() {
		insert(tolerance, decorations);
		cutHexagon(inner_tolerance);
	}
}

module insertM2_5(tolerance=0, decorations=true) insertMX(2.5, 5.77, tolerance=tolerance, decorations=decorations);
module insertM3(tolerance=0, decorations=true)   insertMX(3, 6.35, tolerance=tolerance, decorations=decorations);
module insertM4(tolerance=0, decorations=true)   insertMX(4, 8.08, tolerance=tolerance, decorations=decorations);
module insertM5(tolerance=0, decorations=true)   insertMX(5, 9.24, tolerance=tolerance, decorations=decorations);
module insertM6(tolerance=0, decorations=true)   insertMX(6, 11.55, tolerance=tolerance, decorations=decorations);
module insertM8(tolerance=0, decorations=true)   insertMX(8, 15.01, tolerance=tolerance, decorations=decorations);
module insertM10(tolerance=0, decorations=true)  insertMX(10, 17.32, tolerance=tolerance, decorations=decorations);

function calculateFacetDiameter(holeD, facetHeight) = facetHeight * 2 + holeD;

module insertAttachToWall(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 1.5, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, // <- I think there is no need latch, but you can turn it on
	translateHole = [0,0], // <- if you drill hole not accurate, you can move it by [x, y],
	decorations = true
) {
	$fn=64;
	isTranslateHole = translateHole[0] != 0 || translateHole[1] != 0;
	spacer = 0.2;
	holeD = holeDiameter + spacer;
	outHoleDiameter = isTranslateHole ? maxInnerDiameter : holeD + 4;
	facetD = calculateFacetDiameter(holeD, facetHeight);

	difference() {
		if (withLatch)  
			insert(tolerance, decorations = decorations);
		 else  
			insertBase(tolerance, decorations = decorations);

		translate([0, 0, -bottomThickness]) cylinder(d = outHoleDiameter, h = INSERT_TOTAL_HEIGHT); 

		if (isTranslateHole) 
			translate([translateHole[0], translateHole[1], 0]) hole();
		else 
			hole();
	}

	module hole() {
		translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness - 0.1]) cylinder(d1 = facetD, d2 = holeD, h = facetHeight + 0.1); 
		cylinder(d = holeD, INSERT_TOTAL_HEIGHT + 0.1); 
	}
}

module insertAttachToWallEmpty(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 2, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, 
	decorations = true,
    supportless = false,
) {
    layerThickness = 0.2;

	difference() {
		insertAttachToWall(holeDiameter, facetHeight, bottomThickness, tolerance, inner_tolerance, withLatch, decorations = decorations);
		cutHexagon(inner_tolerance, -bottomThickness);
	}
    if (supportless) {
        translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness]) 
            difference() {
                cylinder(d = PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 2, $fn = 6, center = true);  
                cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight), layerThickness * 4], center = true);  
            }
        translate([0,0,INSERT_TOTAL_HEIGHT-bottomThickness]) 
            difference() {
                cylinder(d=PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 4, $fn = 6, center = true);  
                rotate(90, [0, 0, 1]) 
                    cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight),layerThickness* 2 * 2 * 2], center = true);  
            }
    }
}

module hexagonPlug(tolerance=0, decorations=true) {
	if (decorations) {
		D = PLUG_HEXAGON_DIAMETER - tolerance*2;
		intersection() {
			cylinder(d=D, h=PLUG_LENGTH, $fn=6);
			translate([0,0,-0.75])
				cylinder(r1=PLUG_LENGTH + D/2, r2=0, h = PLUG_LENGTH + D/2, $fn=6); 
			translate([0,0,-D/2 + 0.75])
				cylinder(r2=PLUG_LENGTH + D/2, r1=0, h = PLUG_LENGTH + D/2, $fn=6); 
		}
	} else {
		cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
	}
}

module hexagonPlugHorizontal(tolerance=0, decorations=true) {
	translate([0,0, PLUG_AF_SIZE/2] )
	translate([0,0,-INSERT_MAIN_OUTER_AF_DISTANCE/2] )
	makeInsertHorizontal() hexagonPlug(tolerance, decorations);
}

module makeInsertHorizontal(tolerance=0) {
    large_distance=10;
    difference() {
        translate([0, 0, INSERT_MAIN_OUTER_AF_DISTANCE/2]) 
            rotate([90, 0, 0])
                children();
        translate([-large_distance, -INSERT_TOTAL_HEIGHT - 0.1, -large_distance + tolerance]) 
            cube([large_distance*2, INSERT_TOTAL_HEIGHT + 0.2, large_distance]);
    }
}

module grid(rows=[], changeCellOrder = false, maxRowLength = 10) {
	noRowsInfo = len(rows) == 0;
	upCutRowCount = noRowsInfo ? maxRowLength : rows[0];
	downCutRowCount = noRowsInfo ? maxRowLength : rows[len(rows)-1];
	
	assert( !(!noRowsInfo && len(rows) != $children), 
		"rows info if specified must describe all rows! Example: grid(rows=[1,2]) { row() { insert(); } row() { insert(); insert(); } }");

	difference() {
		for (i = [0:$children-1]) {
			tY = cellOffsetY(i, changeCellOrder);
			translate([(cellD - cellD / 4) * i, tY, 0]) children(i);
		}
		for (i = [0:$children-1]) {

			tY = cellOffsetY(i, changeCellOrder); 
			translate([(cellD - cellD / 4) * i, tY  - cellAf, 0]) connectorCutting();

			if (!noRowsInfo) {
				itemsInRow = rows[i];
				for (k=[0:maxRowLength-1]){
					translate([(cellD - cellD / 4) * i, tY  + (k + itemsInRow) * cellAf, 0]) connectorCutting();
				}
			}
		}

		tYUp = cellOffsetY($children, changeCellOrder);
		translate([(cellD - cellD / 4) * $children, -tYUp, 0]){
			for (j=[0:downCutRowCount-1]) {
				translate([0, cellAf * j, 0]) connectorCutting();
			}
		}
		tYDown = cellOffsetY(-1, changeCellOrder);
		translate([-(cellD - cellD / 4), -tYDown, 0])
			for (k=[0:upCutRowCount-1]) {
				translate([0, cellAf * k, 0]) connectorCutting();
			}
	}
}

module row(connections=true, decorations = true) {
	if ($children > 0) {
		difference() {
			for (i = [0:$children-1]) 
				translate([0, cellAf * i, 0]) {
					if (connections) connector(false, decorations);
					children(i);
				}
			translate([(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
			translate([0, cellAf * $children, 0]) connectorCutting();
			translate([-(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
		}
	}
}

// utils modules section ----------------------------------------------------

module insertBase(tolerance=0, decorations=true) {
    $fn = 6;
    difference() {
        union() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER-tolerance*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=INSERT_LIP_DIAMETER, h=INSERT_LIP_HEIGHT);
        }
		if (decorations) {
			translate([0,0,-0.1])
				union() {
					difference() {
						cylinder(d = DECORATION_OUTER_DIAMETER, h = DECORATION_DEPTH + 0.1);
						cylinder(d = DECORATION_INNER_DIAMETER, h = DECORATION_DEPTH + 0.1);
					}
				}

			translate([0,0,DECORATEION_FACET_HEIGHT]) cutFacet(INSERT_LIP_DIAMETER, inverse=true);
		}
        translate([0,0,INSERT_LIP_HEIGHT])
        rotate(90,[0,0,1])
        difference() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=af_to_diameter(INSERT_MAIN_OUTER_DIAMETER-tolerance*2) - 0.12 * 2, h=INSERT_TOTAL_HEIGHT);
        }
        cutFacetBottom();
    }
}

module cutFacet(diameter, inverse=false) {
	h = diameter / 2 * tan(45);
	z = inverse ? -h : 0;
	translate([0,0,z])
		difference() {
			cylinder(d=diameter*2, h = h);
			if (inverse)
				cylinder(d2=diameter, d1=0, h = h);
			else
				cylinder(d1=diameter, d2=0, h = h);
		}
}

module cutFacetBottom() {
	translate([0,0,INSERT_TOTAL_HEIGHT-DECORATEION_FACET_HEIGHT])
		cutFacet(INSERT_MAIN_OUTER_DIAMETER);
}

module cutHexagon(inner_tolerance, indent = 0) {
	// remove preview artifacts
	z = indent == 0 ? -0.5 : indent;
	addH = indent == 0 ? 1 : 0;
	translate([0,0,z]) 
		cylinder(d=INSERT_MAIN_INNER_DIAMETER + inner_tolerance*2, h=INSERT_TOTAL_HEIGHT + addH, $fn=6);
}

module insertMX(diameter,  nutWidth, tolerance = 0, decorations = true) {
	spacer = 0.2;
	holeD = min(maxInnerDiameter, diameter + spacer);
	facet = holeD / 8;
	facetH = 0.3;
	nutW = min(maxInnerDiameter, nutWidth + spacer);
	aboveNutW = min(maxInnerDiameter, nutW + 6);

	difference() {
		insert(tolerance, decorations = decorations);
		translate([0,0,-0.1]) // remove preview artifacts
			cylinder(d1 = holeD + facet * 2, d2 = holeD, h = facetH + 0.1);
		cylinder(d = holeD, h = INSERT_TOTAL_HEIGHT);
		translate([0, 0, 4])
		cylinder(d = nutW, h = INSERT_TOTAL_HEIGHT, $fn=6);
		translate([0, 0, 7])
		cylinder(d = aboveNutW, h = INSERT_TOTAL_HEIGHT + 0.1, $fn=6);
	}
}

module connector(forCutting=false, decorations = true) {
	connectorW = (cellAf-INSERT_LIP_AF_DISTANCE);
	connectorH = decorations ? INSERT_LIP_HEIGHT - DECORATEION_FACET_HEIGHT : INSERT_LIP_HEIGHT;
	connectorL = INSERT_LIP_DIAMETER/2;
	cuttingTranslateZ = forCutting ? -2 : 0;
	cuttingScaleZ = forCutting ? 2 : 1;

	translate([0,0,cuttingTranslateZ])
		scale([1,1,cuttingScaleZ]) 
			for (a=[0:60:300])
			rotate(a,[0,0,1])
				translate([-connectorL/2, -INSERT_LIP_AF_DISTANCE/2 - connectorW, decorations ? DECORATEION_FACET_HEIGHT : 0]) {
				points = [
					[0, addCutting(connectorW)],
					[connectorL, addCutting(connectorW)],
					[connectorL, 0],
					[0, 0],
					[-(connectorW*sin(60)), connectorW/2]
				];
				linear_extrude(height = connectorH) polygon(points);
			}

	function addCutting(value) = forCutting ? value + 0.1 : value;
}

module connectorCutting() connector(true, true);
function cellOrder(i, change) = change ? i % 2 == 0 : i % 2 != 0;
function cellOffsetY(i, change) = cellOrder(i, change) ? 0 : cellAf / 2;

/* converts an 'across flats' dimension to a maximum diameter — useful for openScad */
function af_to_diameter(af) = af / sqrt(3) * 2;
function diameter_to_af(diameter) = diameter * sqrt(3) / 2;

// ---- part ----
insertM2_5();
`);

Open in editor →

HSW M3 nut insert

A wall insert with a captive M3 nut pocket and screw clearance for bolting accessories to the wall.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
/* Library of hex wall bits */
/* updated */
$fn = 64;  // curve smoothness

/* Constants relating to the insert part */
INSERT_MAIN_OUTER_AF_DISTANCE = 19.7;
INSERT_MAIN_INNER_AF_DISTANCE = 13.4;
INSERT_LIP_AF_DISTANCE = 22.5;
INSERT_MAIN_OUTER_DIAMETER = af_to_diameter(INSERT_MAIN_OUTER_AF_DISTANCE);
INSERT_MAIN_INNER_DIAMETER = af_to_diameter(INSERT_MAIN_INNER_AF_DISTANCE);
INSERT_LIP_DIAMETER = af_to_diameter(INSERT_LIP_AF_DISTANCE);
INSERT_TOTAL_HEIGHT = 10;
INSERT_LIP_HEIGHT = 2.5;
INSERT_LIP_PROTRUSION = (INSERT_LIP_AF_DISTANCE - INSERT_MAIN_OUTER_AF_DISTANCE)/2;

/* Constants relating to the honeycomb itself */
HEXAGON_WIDTH = 20;
HEX_WALL_THICKNESS = 3.6;
HEX_SEPARATION = HEXAGON_WIDTH + HEX_WALL_THICKNESS;
HORIZONTAL_HEX_SEPARATION = HEX_SEPARATION * 2 / sqrt(3) + af_to_diameter(HEXAGON_WIDTH + HEX_WALL_THICKNESS)/2;

/* Constants relating to the plug that can go into an empty insert */
PLUG_HEXAGON_DIAMETER = 14.7;
PLUG_AF_SIZE = PLUG_HEXAGON_DIAMETER * sqrt(3) / 2;
PLUG_LENGTH = 13;

DECORATION_OUTER_DIAMETER = 21.362;
DECORATION_INNER_DIAMETER = 19.053;
DECORATION_DEPTH = 0.3;
DECORATEION_FACET_HEIGHT = 0.35;

tiny_distance = .001;
maxInnerDiameter = 16.5;

cellAf = 23.6;
cellD = af_to_diameter(cellAf);

// insert_empty();
// insert_with_plate();
// insert_horizontal();
// hexagon_plug();
// hexagon_plug_horizontal();
// ^ this items has no decorations for compatibility

//insert(); 		// same as insert_with_plate(); but no cut hexagon underneeze
//insertEmpty(); 	// same as insert_empty();
//insertM2_5();
//insertM3();
//insertM4();
//insertM5();
//insertM6();
//insertM8();
//insertM10();
//insertAttachToWall(5, facetHeight = 1, bottomThickness = 1.5, translateHole = [2.5,-3.5], decorations=false);
//insertAttachToWallEmpty(3.5, facetHeight = 2, bottomThickness = 3, withLatch = false, decorations = true, supportless = true);
//hexagonPlug();
//hexagonPlugHorizontal();

//makeInsertHorizontal() insertEmpty(); // <- any insert 


/*
grid(changeCellOrder=false) {
	row(decorations = false) {
		insertAttachToWallEmpty(4, decorations=false, withLatch=true, facetHeight = 1.6);
		insertEmpty(decorations=false);
	}
	row(decorations = false) {
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
	}
}
//*/

module insert_empty(tolerance = 0, inner_tolerance = 0) insertEmpty(tolerance, inner_tolerance, decorations=false);

module insert_with_plate(tolerance = 0, inner_tolerance = 0) { 
	difference() {
		insert(tolerance, decorations=false);
		cutHexagon(inner_tolerance, INSERT_LIP_HEIGHT);
	}
}

module insert_horizontal(tolerance = 0, inner_tolerance = 0) {
	makeInsertHorizontal(tolerance) insert_with_plate(tolerance);
}

module hexagon_plug(tolerance = 0) {
    cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
}

module hexagon_plug_horizontal(tolerance = 0) {
    translate([0, 0, PLUG_AF_SIZE/2 - tolerance])
        rotate([90, 0, 0]) 
			hexagon_plug(tolerance);
}

module insert(tolerance = 0, decorations = true) {
	$fn = 6;
    WALL_SIDE_GAP_START_HEIGHT = 6.5;
    WALL_SIDE_GAP_WIDTH = 1;
    WALL_TOP_GAP_WIDTH = 0.8;
    WALL_GAP_LENGTH = 8;
    WALL_TOP_GAP_RADIUS = 8.25;
    TAB_STICKS_OUT_BY = 0.5;
    TAB_LENGTH = 2;


	difference() {
		union() {
			for (i=[0:5]) {
					rotate([0, 0, i*60]) {
					translate([0, INSERT_MAIN_OUTER_AF_DISTANCE/2 - tolerance, 0]) {
						hull() {
							translate([0, 0, WALL_SIDE_GAP_START_HEIGHT + WALL_SIDE_GAP_WIDTH + TAB_STICKS_OUT_BY]) {
								rotate([0,90,0]){
									cylinder(r=TAB_STICKS_OUT_BY, h=TAB_LENGTH, center=true, $fn=20);
								}
							}
							translate([0, 0, INSERT_TOTAL_HEIGHT - tiny_distance]) {
								rotate([0, 90, 0]) {
									cylinder(r=0.2, h=TAB_LENGTH, center=true, $fn=20);  // rounded retention-tab tip
								}
							}
						}
					}
				}
			}
			difference() {
				insertBase(tolerance, decorations);
				for (i=[0:5]) {
					rotate([0, 0, i*60]) {
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS - tolerance, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, WALL_TOP_GAP_WIDTH, 10]);
						}
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, 10, WALL_SIDE_GAP_WIDTH]);
						}
					}
				}
			}
		}
		cutFacetBottom();
	}
}

module insertEmpty(tolerance = 0, inner_tolerance = 0, decorations = true) {
	difference() {
		insert(tolerance, decorations);
		cutHexagon(inner_tolerance);
	}
}

module insertM2_5(tolerance=0, decorations=true) insertMX(2.5, 5.77, tolerance=tolerance, decorations=decorations);
module insertM3(tolerance=0, decorations=true)   insertMX(3, 6.35, tolerance=tolerance, decorations=decorations);
module insertM4(tolerance=0, decorations=true)   insertMX(4, 8.08, tolerance=tolerance, decorations=decorations);
module insertM5(tolerance=0, decorations=true)   insertMX(5, 9.24, tolerance=tolerance, decorations=decorations);
module insertM6(tolerance=0, decorations=true)   insertMX(6, 11.55, tolerance=tolerance, decorations=decorations);
module insertM8(tolerance=0, decorations=true)   insertMX(8, 15.01, tolerance=tolerance, decorations=decorations);
module insertM10(tolerance=0, decorations=true)  insertMX(10, 17.32, tolerance=tolerance, decorations=decorations);

function calculateFacetDiameter(holeD, facetHeight) = facetHeight * 2 + holeD;

module insertAttachToWall(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 1.5, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, // <- I think there is no need latch, but you can turn it on
	translateHole = [0,0], // <- if you drill hole not accurate, you can move it by [x, y],
	decorations = true
) {
	$fn=64;
	isTranslateHole = translateHole[0] != 0 || translateHole[1] != 0;
	spacer = 0.2;
	holeD = holeDiameter + spacer;
	outHoleDiameter = isTranslateHole ? maxInnerDiameter : holeD + 4;
	facetD = calculateFacetDiameter(holeD, facetHeight);

	difference() {
		if (withLatch)  
			insert(tolerance, decorations = decorations);
		 else  
			insertBase(tolerance, decorations = decorations);

		translate([0, 0, -bottomThickness]) cylinder(d = outHoleDiameter, h = INSERT_TOTAL_HEIGHT); 

		if (isTranslateHole) 
			translate([translateHole[0], translateHole[1], 0]) hole();
		else 
			hole();
	}

	module hole() {
		translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness - 0.1]) cylinder(d1 = facetD, d2 = holeD, h = facetHeight + 0.1); 
		cylinder(d = holeD, INSERT_TOTAL_HEIGHT + 0.1); 
	}
}

module insertAttachToWallEmpty(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 2, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, 
	decorations = true,
    supportless = false,
) {
    layerThickness = 0.2;

	difference() {
		insertAttachToWall(holeDiameter, facetHeight, bottomThickness, tolerance, inner_tolerance, withLatch, decorations = decorations);
		cutHexagon(inner_tolerance, -bottomThickness);
	}
    if (supportless) {
        translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness]) 
            difference() {
                cylinder(d = PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 2, $fn = 6, center = true);  
                cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight), layerThickness * 4], center = true);  
            }
        translate([0,0,INSERT_TOTAL_HEIGHT-bottomThickness]) 
            difference() {
                cylinder(d=PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 4, $fn = 6, center = true);  
                rotate(90, [0, 0, 1]) 
                    cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight),layerThickness* 2 * 2 * 2], center = true);  
            }
    }
}

module hexagonPlug(tolerance=0, decorations=true) {
	if (decorations) {
		D = PLUG_HEXAGON_DIAMETER - tolerance*2;
		intersection() {
			cylinder(d=D, h=PLUG_LENGTH, $fn=6);
			translate([0,0,-0.75])
				cylinder(r1=PLUG_LENGTH + D/2, r2=0, h = PLUG_LENGTH + D/2, $fn=6); 
			translate([0,0,-D/2 + 0.75])
				cylinder(r2=PLUG_LENGTH + D/2, r1=0, h = PLUG_LENGTH + D/2, $fn=6); 
		}
	} else {
		cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
	}
}

module hexagonPlugHorizontal(tolerance=0, decorations=true) {
	translate([0,0, PLUG_AF_SIZE/2] )
	translate([0,0,-INSERT_MAIN_OUTER_AF_DISTANCE/2] )
	makeInsertHorizontal() hexagonPlug(tolerance, decorations);
}

module makeInsertHorizontal(tolerance=0) {
    large_distance=10;
    difference() {
        translate([0, 0, INSERT_MAIN_OUTER_AF_DISTANCE/2]) 
            rotate([90, 0, 0])
                children();
        translate([-large_distance, -INSERT_TOTAL_HEIGHT - 0.1, -large_distance + tolerance]) 
            cube([large_distance*2, INSERT_TOTAL_HEIGHT + 0.2, large_distance]);
    }
}

module grid(rows=[], changeCellOrder = false, maxRowLength = 10) {
	noRowsInfo = len(rows) == 0;
	upCutRowCount = noRowsInfo ? maxRowLength : rows[0];
	downCutRowCount = noRowsInfo ? maxRowLength : rows[len(rows)-1];
	
	assert( !(!noRowsInfo && len(rows) != $children), 
		"rows info if specified must describe all rows! Example: grid(rows=[1,2]) { row() { insert(); } row() { insert(); insert(); } }");

	difference() {
		for (i = [0:$children-1]) {
			tY = cellOffsetY(i, changeCellOrder);
			translate([(cellD - cellD / 4) * i, tY, 0]) children(i);
		}
		for (i = [0:$children-1]) {

			tY = cellOffsetY(i, changeCellOrder); 
			translate([(cellD - cellD / 4) * i, tY  - cellAf, 0]) connectorCutting();

			if (!noRowsInfo) {
				itemsInRow = rows[i];
				for (k=[0:maxRowLength-1]){
					translate([(cellD - cellD / 4) * i, tY  + (k + itemsInRow) * cellAf, 0]) connectorCutting();
				}
			}
		}

		tYUp = cellOffsetY($children, changeCellOrder);
		translate([(cellD - cellD / 4) * $children, -tYUp, 0]){
			for (j=[0:downCutRowCount-1]) {
				translate([0, cellAf * j, 0]) connectorCutting();
			}
		}
		tYDown = cellOffsetY(-1, changeCellOrder);
		translate([-(cellD - cellD / 4), -tYDown, 0])
			for (k=[0:upCutRowCount-1]) {
				translate([0, cellAf * k, 0]) connectorCutting();
			}
	}
}

module row(connections=true, decorations = true) {
	if ($children > 0) {
		difference() {
			for (i = [0:$children-1]) 
				translate([0, cellAf * i, 0]) {
					if (connections) connector(false, decorations);
					children(i);
				}
			translate([(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
			translate([0, cellAf * $children, 0]) connectorCutting();
			translate([-(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
		}
	}
}

// utils modules section ----------------------------------------------------

module insertBase(tolerance=0, decorations=true) {
    $fn = 6;
    difference() {
        union() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER-tolerance*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=INSERT_LIP_DIAMETER, h=INSERT_LIP_HEIGHT);
        }
		if (decorations) {
			translate([0,0,-0.1])
				union() {
					difference() {
						cylinder(d = DECORATION_OUTER_DIAMETER, h = DECORATION_DEPTH + 0.1);
						cylinder(d = DECORATION_INNER_DIAMETER, h = DECORATION_DEPTH + 0.1);
					}
				}

			translate([0,0,DECORATEION_FACET_HEIGHT]) cutFacet(INSERT_LIP_DIAMETER, inverse=true);
		}
        translate([0,0,INSERT_LIP_HEIGHT])
        rotate(90,[0,0,1])
        difference() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=af_to_diameter(INSERT_MAIN_OUTER_DIAMETER-tolerance*2) - 0.12 * 2, h=INSERT_TOTAL_HEIGHT);
        }
        cutFacetBottom();
    }
}

module cutFacet(diameter, inverse=false) {
	h = diameter / 2 * tan(45);
	z = inverse ? -h : 0;
	translate([0,0,z])
		difference() {
			cylinder(d=diameter*2, h = h);
			if (inverse)
				cylinder(d2=diameter, d1=0, h = h);
			else
				cylinder(d1=diameter, d2=0, h = h);
		}
}

module cutFacetBottom() {
	translate([0,0,INSERT_TOTAL_HEIGHT-DECORATEION_FACET_HEIGHT])
		cutFacet(INSERT_MAIN_OUTER_DIAMETER);
}

module cutHexagon(inner_tolerance, indent = 0) {
	// remove preview artifacts
	z = indent == 0 ? -0.5 : indent;
	addH = indent == 0 ? 1 : 0;
	translate([0,0,z]) 
		cylinder(d=INSERT_MAIN_INNER_DIAMETER + inner_tolerance*2, h=INSERT_TOTAL_HEIGHT + addH, $fn=6);
}

module insertMX(diameter,  nutWidth, tolerance = 0, decorations = true) {
	spacer = 0.2;
	holeD = min(maxInnerDiameter, diameter + spacer);
	facet = holeD / 8;
	facetH = 0.3;
	nutW = min(maxInnerDiameter, nutWidth + spacer);
	aboveNutW = min(maxInnerDiameter, nutW + 6);

	difference() {
		insert(tolerance, decorations = decorations);
		translate([0,0,-0.1]) // remove preview artifacts
			cylinder(d1 = holeD + facet * 2, d2 = holeD, h = facetH + 0.1);
		cylinder(d = holeD, h = INSERT_TOTAL_HEIGHT);
		translate([0, 0, 4])
		cylinder(d = nutW, h = INSERT_TOTAL_HEIGHT, $fn=6);
		translate([0, 0, 7])
		cylinder(d = aboveNutW, h = INSERT_TOTAL_HEIGHT + 0.1, $fn=6);
	}
}

module connector(forCutting=false, decorations = true) {
	connectorW = (cellAf-INSERT_LIP_AF_DISTANCE);
	connectorH = decorations ? INSERT_LIP_HEIGHT - DECORATEION_FACET_HEIGHT : INSERT_LIP_HEIGHT;
	connectorL = INSERT_LIP_DIAMETER/2;
	cuttingTranslateZ = forCutting ? -2 : 0;
	cuttingScaleZ = forCutting ? 2 : 1;

	translate([0,0,cuttingTranslateZ])
		scale([1,1,cuttingScaleZ]) 
			for (a=[0:60:300])
			rotate(a,[0,0,1])
				translate([-connectorL/2, -INSERT_LIP_AF_DISTANCE/2 - connectorW, decorations ? DECORATEION_FACET_HEIGHT : 0]) {
				points = [
					[0, addCutting(connectorW)],
					[connectorL, addCutting(connectorW)],
					[connectorL, 0],
					[0, 0],
					[-(connectorW*sin(60)), connectorW/2]
				];
				linear_extrude(height = connectorH) polygon(points);
			}

	function addCutting(value) = forCutting ? value + 0.1 : value;
}

module connectorCutting() connector(true, true);
function cellOrder(i, change) = change ? i % 2 == 0 : i % 2 != 0;
function cellOffsetY(i, change) = cellOrder(i, change) ? 0 : cellAf / 2;

/* converts an 'across flats' dimension to a maximum diameter — useful for openScad */
function af_to_diameter(af) = af / sqrt(3) * 2;
function diameter_to_af(diameter) = diameter * sqrt(3) / 2;

// ---- part ----
insertM3();
`);

Open in editor →

HSW M4 nut insert

A wall insert with a captive M4 nut pocket and screw clearance for bolting accessories to the wall.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
/* Library of hex wall bits */
/* updated */
$fn = 64;  // curve smoothness

/* Constants relating to the insert part */
INSERT_MAIN_OUTER_AF_DISTANCE = 19.7;
INSERT_MAIN_INNER_AF_DISTANCE = 13.4;
INSERT_LIP_AF_DISTANCE = 22.5;
INSERT_MAIN_OUTER_DIAMETER = af_to_diameter(INSERT_MAIN_OUTER_AF_DISTANCE);
INSERT_MAIN_INNER_DIAMETER = af_to_diameter(INSERT_MAIN_INNER_AF_DISTANCE);
INSERT_LIP_DIAMETER = af_to_diameter(INSERT_LIP_AF_DISTANCE);
INSERT_TOTAL_HEIGHT = 10;
INSERT_LIP_HEIGHT = 2.5;
INSERT_LIP_PROTRUSION = (INSERT_LIP_AF_DISTANCE - INSERT_MAIN_OUTER_AF_DISTANCE)/2;

/* Constants relating to the honeycomb itself */
HEXAGON_WIDTH = 20;
HEX_WALL_THICKNESS = 3.6;
HEX_SEPARATION = HEXAGON_WIDTH + HEX_WALL_THICKNESS;
HORIZONTAL_HEX_SEPARATION = HEX_SEPARATION * 2 / sqrt(3) + af_to_diameter(HEXAGON_WIDTH + HEX_WALL_THICKNESS)/2;

/* Constants relating to the plug that can go into an empty insert */
PLUG_HEXAGON_DIAMETER = 14.7;
PLUG_AF_SIZE = PLUG_HEXAGON_DIAMETER * sqrt(3) / 2;
PLUG_LENGTH = 13;

DECORATION_OUTER_DIAMETER = 21.362;
DECORATION_INNER_DIAMETER = 19.053;
DECORATION_DEPTH = 0.3;
DECORATEION_FACET_HEIGHT = 0.35;

tiny_distance = .001;
maxInnerDiameter = 16.5;

cellAf = 23.6;
cellD = af_to_diameter(cellAf);

// insert_empty();
// insert_with_plate();
// insert_horizontal();
// hexagon_plug();
// hexagon_plug_horizontal();
// ^ this items has no decorations for compatibility

//insert(); 		// same as insert_with_plate(); but no cut hexagon underneeze
//insertEmpty(); 	// same as insert_empty();
//insertM2_5();
//insertM3();
//insertM4();
//insertM5();
//insertM6();
//insertM8();
//insertM10();
//insertAttachToWall(5, facetHeight = 1, bottomThickness = 1.5, translateHole = [2.5,-3.5], decorations=false);
//insertAttachToWallEmpty(3.5, facetHeight = 2, bottomThickness = 3, withLatch = false, decorations = true, supportless = true);
//hexagonPlug();
//hexagonPlugHorizontal();

//makeInsertHorizontal() insertEmpty(); // <- any insert 


/*
grid(changeCellOrder=false) {
	row(decorations = false) {
		insertAttachToWallEmpty(4, decorations=false, withLatch=true, facetHeight = 1.6);
		insertEmpty(decorations=false);
	}
	row(decorations = false) {
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
	}
}
//*/

module insert_empty(tolerance = 0, inner_tolerance = 0) insertEmpty(tolerance, inner_tolerance, decorations=false);

module insert_with_plate(tolerance = 0, inner_tolerance = 0) { 
	difference() {
		insert(tolerance, decorations=false);
		cutHexagon(inner_tolerance, INSERT_LIP_HEIGHT);
	}
}

module insert_horizontal(tolerance = 0, inner_tolerance = 0) {
	makeInsertHorizontal(tolerance) insert_with_plate(tolerance);
}

module hexagon_plug(tolerance = 0) {
    cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
}

module hexagon_plug_horizontal(tolerance = 0) {
    translate([0, 0, PLUG_AF_SIZE/2 - tolerance])
        rotate([90, 0, 0]) 
			hexagon_plug(tolerance);
}

module insert(tolerance = 0, decorations = true) {
	$fn = 6;
    WALL_SIDE_GAP_START_HEIGHT = 6.5;
    WALL_SIDE_GAP_WIDTH = 1;
    WALL_TOP_GAP_WIDTH = 0.8;
    WALL_GAP_LENGTH = 8;
    WALL_TOP_GAP_RADIUS = 8.25;
    TAB_STICKS_OUT_BY = 0.5;
    TAB_LENGTH = 2;


	difference() {
		union() {
			for (i=[0:5]) {
					rotate([0, 0, i*60]) {
					translate([0, INSERT_MAIN_OUTER_AF_DISTANCE/2 - tolerance, 0]) {
						hull() {
							translate([0, 0, WALL_SIDE_GAP_START_HEIGHT + WALL_SIDE_GAP_WIDTH + TAB_STICKS_OUT_BY]) {
								rotate([0,90,0]){
									cylinder(r=TAB_STICKS_OUT_BY, h=TAB_LENGTH, center=true, $fn=20);
								}
							}
							translate([0, 0, INSERT_TOTAL_HEIGHT - tiny_distance]) {
								rotate([0, 90, 0]) {
									cylinder(r=0.2, h=TAB_LENGTH, center=true, $fn=20);  // rounded retention-tab tip
								}
							}
						}
					}
				}
			}
			difference() {
				insertBase(tolerance, decorations);
				for (i=[0:5]) {
					rotate([0, 0, i*60]) {
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS - tolerance, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, WALL_TOP_GAP_WIDTH, 10]);
						}
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, 10, WALL_SIDE_GAP_WIDTH]);
						}
					}
				}
			}
		}
		cutFacetBottom();
	}
}

module insertEmpty(tolerance = 0, inner_tolerance = 0, decorations = true) {
	difference() {
		insert(tolerance, decorations);
		cutHexagon(inner_tolerance);
	}
}

module insertM2_5(tolerance=0, decorations=true) insertMX(2.5, 5.77, tolerance=tolerance, decorations=decorations);
module insertM3(tolerance=0, decorations=true)   insertMX(3, 6.35, tolerance=tolerance, decorations=decorations);
module insertM4(tolerance=0, decorations=true)   insertMX(4, 8.08, tolerance=tolerance, decorations=decorations);
module insertM5(tolerance=0, decorations=true)   insertMX(5, 9.24, tolerance=tolerance, decorations=decorations);
module insertM6(tolerance=0, decorations=true)   insertMX(6, 11.55, tolerance=tolerance, decorations=decorations);
module insertM8(tolerance=0, decorations=true)   insertMX(8, 15.01, tolerance=tolerance, decorations=decorations);
module insertM10(tolerance=0, decorations=true)  insertMX(10, 17.32, tolerance=tolerance, decorations=decorations);

function calculateFacetDiameter(holeD, facetHeight) = facetHeight * 2 + holeD;

module insertAttachToWall(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 1.5, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, // <- I think there is no need latch, but you can turn it on
	translateHole = [0,0], // <- if you drill hole not accurate, you can move it by [x, y],
	decorations = true
) {
	$fn=64;
	isTranslateHole = translateHole[0] != 0 || translateHole[1] != 0;
	spacer = 0.2;
	holeD = holeDiameter + spacer;
	outHoleDiameter = isTranslateHole ? maxInnerDiameter : holeD + 4;
	facetD = calculateFacetDiameter(holeD, facetHeight);

	difference() {
		if (withLatch)  
			insert(tolerance, decorations = decorations);
		 else  
			insertBase(tolerance, decorations = decorations);

		translate([0, 0, -bottomThickness]) cylinder(d = outHoleDiameter, h = INSERT_TOTAL_HEIGHT); 

		if (isTranslateHole) 
			translate([translateHole[0], translateHole[1], 0]) hole();
		else 
			hole();
	}

	module hole() {
		translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness - 0.1]) cylinder(d1 = facetD, d2 = holeD, h = facetHeight + 0.1); 
		cylinder(d = holeD, INSERT_TOTAL_HEIGHT + 0.1); 
	}
}

module insertAttachToWallEmpty(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 2, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, 
	decorations = true,
    supportless = false,
) {
    layerThickness = 0.2;

	difference() {
		insertAttachToWall(holeDiameter, facetHeight, bottomThickness, tolerance, inner_tolerance, withLatch, decorations = decorations);
		cutHexagon(inner_tolerance, -bottomThickness);
	}
    if (supportless) {
        translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness]) 
            difference() {
                cylinder(d = PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 2, $fn = 6, center = true);  
                cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight), layerThickness * 4], center = true);  
            }
        translate([0,0,INSERT_TOTAL_HEIGHT-bottomThickness]) 
            difference() {
                cylinder(d=PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 4, $fn = 6, center = true);  
                rotate(90, [0, 0, 1]) 
                    cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight),layerThickness* 2 * 2 * 2], center = true);  
            }
    }
}

module hexagonPlug(tolerance=0, decorations=true) {
	if (decorations) {
		D = PLUG_HEXAGON_DIAMETER - tolerance*2;
		intersection() {
			cylinder(d=D, h=PLUG_LENGTH, $fn=6);
			translate([0,0,-0.75])
				cylinder(r1=PLUG_LENGTH + D/2, r2=0, h = PLUG_LENGTH + D/2, $fn=6); 
			translate([0,0,-D/2 + 0.75])
				cylinder(r2=PLUG_LENGTH + D/2, r1=0, h = PLUG_LENGTH + D/2, $fn=6); 
		}
	} else {
		cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
	}
}

module hexagonPlugHorizontal(tolerance=0, decorations=true) {
	translate([0,0, PLUG_AF_SIZE/2] )
	translate([0,0,-INSERT_MAIN_OUTER_AF_DISTANCE/2] )
	makeInsertHorizontal() hexagonPlug(tolerance, decorations);
}

module makeInsertHorizontal(tolerance=0) {
    large_distance=10;
    difference() {
        translate([0, 0, INSERT_MAIN_OUTER_AF_DISTANCE/2]) 
            rotate([90, 0, 0])
                children();
        translate([-large_distance, -INSERT_TOTAL_HEIGHT - 0.1, -large_distance + tolerance]) 
            cube([large_distance*2, INSERT_TOTAL_HEIGHT + 0.2, large_distance]);
    }
}

module grid(rows=[], changeCellOrder = false, maxRowLength = 10) {
	noRowsInfo = len(rows) == 0;
	upCutRowCount = noRowsInfo ? maxRowLength : rows[0];
	downCutRowCount = noRowsInfo ? maxRowLength : rows[len(rows)-1];
	
	assert( !(!noRowsInfo && len(rows) != $children), 
		"rows info if specified must describe all rows! Example: grid(rows=[1,2]) { row() { insert(); } row() { insert(); insert(); } }");

	difference() {
		for (i = [0:$children-1]) {
			tY = cellOffsetY(i, changeCellOrder);
			translate([(cellD - cellD / 4) * i, tY, 0]) children(i);
		}
		for (i = [0:$children-1]) {

			tY = cellOffsetY(i, changeCellOrder); 
			translate([(cellD - cellD / 4) * i, tY  - cellAf, 0]) connectorCutting();

			if (!noRowsInfo) {
				itemsInRow = rows[i];
				for (k=[0:maxRowLength-1]){
					translate([(cellD - cellD / 4) * i, tY  + (k + itemsInRow) * cellAf, 0]) connectorCutting();
				}
			}
		}

		tYUp = cellOffsetY($children, changeCellOrder);
		translate([(cellD - cellD / 4) * $children, -tYUp, 0]){
			for (j=[0:downCutRowCount-1]) {
				translate([0, cellAf * j, 0]) connectorCutting();
			}
		}
		tYDown = cellOffsetY(-1, changeCellOrder);
		translate([-(cellD - cellD / 4), -tYDown, 0])
			for (k=[0:upCutRowCount-1]) {
				translate([0, cellAf * k, 0]) connectorCutting();
			}
	}
}

module row(connections=true, decorations = true) {
	if ($children > 0) {
		difference() {
			for (i = [0:$children-1]) 
				translate([0, cellAf * i, 0]) {
					if (connections) connector(false, decorations);
					children(i);
				}
			translate([(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
			translate([0, cellAf * $children, 0]) connectorCutting();
			translate([-(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
		}
	}
}

// utils modules section ----------------------------------------------------

module insertBase(tolerance=0, decorations=true) {
    $fn = 6;
    difference() {
        union() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER-tolerance*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=INSERT_LIP_DIAMETER, h=INSERT_LIP_HEIGHT);
        }
		if (decorations) {
			translate([0,0,-0.1])
				union() {
					difference() {
						cylinder(d = DECORATION_OUTER_DIAMETER, h = DECORATION_DEPTH + 0.1);
						cylinder(d = DECORATION_INNER_DIAMETER, h = DECORATION_DEPTH + 0.1);
					}
				}

			translate([0,0,DECORATEION_FACET_HEIGHT]) cutFacet(INSERT_LIP_DIAMETER, inverse=true);
		}
        translate([0,0,INSERT_LIP_HEIGHT])
        rotate(90,[0,0,1])
        difference() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=af_to_diameter(INSERT_MAIN_OUTER_DIAMETER-tolerance*2) - 0.12 * 2, h=INSERT_TOTAL_HEIGHT);
        }
        cutFacetBottom();
    }
}

module cutFacet(diameter, inverse=false) {
	h = diameter / 2 * tan(45);
	z = inverse ? -h : 0;
	translate([0,0,z])
		difference() {
			cylinder(d=diameter*2, h = h);
			if (inverse)
				cylinder(d2=diameter, d1=0, h = h);
			else
				cylinder(d1=diameter, d2=0, h = h);
		}
}

module cutFacetBottom() {
	translate([0,0,INSERT_TOTAL_HEIGHT-DECORATEION_FACET_HEIGHT])
		cutFacet(INSERT_MAIN_OUTER_DIAMETER);
}

module cutHexagon(inner_tolerance, indent = 0) {
	// remove preview artifacts
	z = indent == 0 ? -0.5 : indent;
	addH = indent == 0 ? 1 : 0;
	translate([0,0,z]) 
		cylinder(d=INSERT_MAIN_INNER_DIAMETER + inner_tolerance*2, h=INSERT_TOTAL_HEIGHT + addH, $fn=6);
}

module insertMX(diameter,  nutWidth, tolerance = 0, decorations = true) {
	spacer = 0.2;
	holeD = min(maxInnerDiameter, diameter + spacer);
	facet = holeD / 8;
	facetH = 0.3;
	nutW = min(maxInnerDiameter, nutWidth + spacer);
	aboveNutW = min(maxInnerDiameter, nutW + 6);

	difference() {
		insert(tolerance, decorations = decorations);
		translate([0,0,-0.1]) // remove preview artifacts
			cylinder(d1 = holeD + facet * 2, d2 = holeD, h = facetH + 0.1);
		cylinder(d = holeD, h = INSERT_TOTAL_HEIGHT);
		translate([0, 0, 4])
		cylinder(d = nutW, h = INSERT_TOTAL_HEIGHT, $fn=6);
		translate([0, 0, 7])
		cylinder(d = aboveNutW, h = INSERT_TOTAL_HEIGHT + 0.1, $fn=6);
	}
}

module connector(forCutting=false, decorations = true) {
	connectorW = (cellAf-INSERT_LIP_AF_DISTANCE);
	connectorH = decorations ? INSERT_LIP_HEIGHT - DECORATEION_FACET_HEIGHT : INSERT_LIP_HEIGHT;
	connectorL = INSERT_LIP_DIAMETER/2;
	cuttingTranslateZ = forCutting ? -2 : 0;
	cuttingScaleZ = forCutting ? 2 : 1;

	translate([0,0,cuttingTranslateZ])
		scale([1,1,cuttingScaleZ]) 
			for (a=[0:60:300])
			rotate(a,[0,0,1])
				translate([-connectorL/2, -INSERT_LIP_AF_DISTANCE/2 - connectorW, decorations ? DECORATEION_FACET_HEIGHT : 0]) {
				points = [
					[0, addCutting(connectorW)],
					[connectorL, addCutting(connectorW)],
					[connectorL, 0],
					[0, 0],
					[-(connectorW*sin(60)), connectorW/2]
				];
				linear_extrude(height = connectorH) polygon(points);
			}

	function addCutting(value) = forCutting ? value + 0.1 : value;
}

module connectorCutting() connector(true, true);
function cellOrder(i, change) = change ? i % 2 == 0 : i % 2 != 0;
function cellOffsetY(i, change) = cellOrder(i, change) ? 0 : cellAf / 2;

/* converts an 'across flats' dimension to a maximum diameter — useful for openScad */
function af_to_diameter(af) = af / sqrt(3) * 2;
function diameter_to_af(diameter) = diameter * sqrt(3) / 2;

// ---- part ----
insertM4();
`);

Open in editor →

HSW M5 nut insert

A wall insert with a captive M5 nut pocket and screw clearance for bolting accessories to the wall.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
/* Library of hex wall bits */
/* updated */
$fn = 64;  // curve smoothness

/* Constants relating to the insert part */
INSERT_MAIN_OUTER_AF_DISTANCE = 19.7;
INSERT_MAIN_INNER_AF_DISTANCE = 13.4;
INSERT_LIP_AF_DISTANCE = 22.5;
INSERT_MAIN_OUTER_DIAMETER = af_to_diameter(INSERT_MAIN_OUTER_AF_DISTANCE);
INSERT_MAIN_INNER_DIAMETER = af_to_diameter(INSERT_MAIN_INNER_AF_DISTANCE);
INSERT_LIP_DIAMETER = af_to_diameter(INSERT_LIP_AF_DISTANCE);
INSERT_TOTAL_HEIGHT = 10;
INSERT_LIP_HEIGHT = 2.5;
INSERT_LIP_PROTRUSION = (INSERT_LIP_AF_DISTANCE - INSERT_MAIN_OUTER_AF_DISTANCE)/2;

/* Constants relating to the honeycomb itself */
HEXAGON_WIDTH = 20;
HEX_WALL_THICKNESS = 3.6;
HEX_SEPARATION = HEXAGON_WIDTH + HEX_WALL_THICKNESS;
HORIZONTAL_HEX_SEPARATION = HEX_SEPARATION * 2 / sqrt(3) + af_to_diameter(HEXAGON_WIDTH + HEX_WALL_THICKNESS)/2;

/* Constants relating to the plug that can go into an empty insert */
PLUG_HEXAGON_DIAMETER = 14.7;
PLUG_AF_SIZE = PLUG_HEXAGON_DIAMETER * sqrt(3) / 2;
PLUG_LENGTH = 13;

DECORATION_OUTER_DIAMETER = 21.362;
DECORATION_INNER_DIAMETER = 19.053;
DECORATION_DEPTH = 0.3;
DECORATEION_FACET_HEIGHT = 0.35;

tiny_distance = .001;
maxInnerDiameter = 16.5;

cellAf = 23.6;
cellD = af_to_diameter(cellAf);

// insert_empty();
// insert_with_plate();
// insert_horizontal();
// hexagon_plug();
// hexagon_plug_horizontal();
// ^ this items has no decorations for compatibility

//insert(); 		// same as insert_with_plate(); but no cut hexagon underneeze
//insertEmpty(); 	// same as insert_empty();
//insertM2_5();
//insertM3();
//insertM4();
//insertM5();
//insertM6();
//insertM8();
//insertM10();
//insertAttachToWall(5, facetHeight = 1, bottomThickness = 1.5, translateHole = [2.5,-3.5], decorations=false);
//insertAttachToWallEmpty(3.5, facetHeight = 2, bottomThickness = 3, withLatch = false, decorations = true, supportless = true);
//hexagonPlug();
//hexagonPlugHorizontal();

//makeInsertHorizontal() insertEmpty(); // <- any insert 


/*
grid(changeCellOrder=false) {
	row(decorations = false) {
		insertAttachToWallEmpty(4, decorations=false, withLatch=true, facetHeight = 1.6);
		insertEmpty(decorations=false);
	}
	row(decorations = false) {
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
	}
}
//*/

module insert_empty(tolerance = 0, inner_tolerance = 0) insertEmpty(tolerance, inner_tolerance, decorations=false);

module insert_with_plate(tolerance = 0, inner_tolerance = 0) { 
	difference() {
		insert(tolerance, decorations=false);
		cutHexagon(inner_tolerance, INSERT_LIP_HEIGHT);
	}
}

module insert_horizontal(tolerance = 0, inner_tolerance = 0) {
	makeInsertHorizontal(tolerance) insert_with_plate(tolerance);
}

module hexagon_plug(tolerance = 0) {
    cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
}

module hexagon_plug_horizontal(tolerance = 0) {
    translate([0, 0, PLUG_AF_SIZE/2 - tolerance])
        rotate([90, 0, 0]) 
			hexagon_plug(tolerance);
}

module insert(tolerance = 0, decorations = true) {
	$fn = 6;
    WALL_SIDE_GAP_START_HEIGHT = 6.5;
    WALL_SIDE_GAP_WIDTH = 1;
    WALL_TOP_GAP_WIDTH = 0.8;
    WALL_GAP_LENGTH = 8;
    WALL_TOP_GAP_RADIUS = 8.25;
    TAB_STICKS_OUT_BY = 0.5;
    TAB_LENGTH = 2;


	difference() {
		union() {
			for (i=[0:5]) {
					rotate([0, 0, i*60]) {
					translate([0, INSERT_MAIN_OUTER_AF_DISTANCE/2 - tolerance, 0]) {
						hull() {
							translate([0, 0, WALL_SIDE_GAP_START_HEIGHT + WALL_SIDE_GAP_WIDTH + TAB_STICKS_OUT_BY]) {
								rotate([0,90,0]){
									cylinder(r=TAB_STICKS_OUT_BY, h=TAB_LENGTH, center=true, $fn=20);
								}
							}
							translate([0, 0, INSERT_TOTAL_HEIGHT - tiny_distance]) {
								rotate([0, 90, 0]) {
									cylinder(r=0.2, h=TAB_LENGTH, center=true, $fn=20);  // rounded retention-tab tip
								}
							}
						}
					}
				}
			}
			difference() {
				insertBase(tolerance, decorations);
				for (i=[0:5]) {
					rotate([0, 0, i*60]) {
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS - tolerance, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, WALL_TOP_GAP_WIDTH, 10]);
						}
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, 10, WALL_SIDE_GAP_WIDTH]);
						}
					}
				}
			}
		}
		cutFacetBottom();
	}
}

module insertEmpty(tolerance = 0, inner_tolerance = 0, decorations = true) {
	difference() {
		insert(tolerance, decorations);
		cutHexagon(inner_tolerance);
	}
}

module insertM2_5(tolerance=0, decorations=true) insertMX(2.5, 5.77, tolerance=tolerance, decorations=decorations);
module insertM3(tolerance=0, decorations=true)   insertMX(3, 6.35, tolerance=tolerance, decorations=decorations);
module insertM4(tolerance=0, decorations=true)   insertMX(4, 8.08, tolerance=tolerance, decorations=decorations);
module insertM5(tolerance=0, decorations=true)   insertMX(5, 9.24, tolerance=tolerance, decorations=decorations);
module insertM6(tolerance=0, decorations=true)   insertMX(6, 11.55, tolerance=tolerance, decorations=decorations);
module insertM8(tolerance=0, decorations=true)   insertMX(8, 15.01, tolerance=tolerance, decorations=decorations);
module insertM10(tolerance=0, decorations=true)  insertMX(10, 17.32, tolerance=tolerance, decorations=decorations);

function calculateFacetDiameter(holeD, facetHeight) = facetHeight * 2 + holeD;

module insertAttachToWall(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 1.5, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, // <- I think there is no need latch, but you can turn it on
	translateHole = [0,0], // <- if you drill hole not accurate, you can move it by [x, y],
	decorations = true
) {
	$fn=64;
	isTranslateHole = translateHole[0] != 0 || translateHole[1] != 0;
	spacer = 0.2;
	holeD = holeDiameter + spacer;
	outHoleDiameter = isTranslateHole ? maxInnerDiameter : holeD + 4;
	facetD = calculateFacetDiameter(holeD, facetHeight);

	difference() {
		if (withLatch)  
			insert(tolerance, decorations = decorations);
		 else  
			insertBase(tolerance, decorations = decorations);

		translate([0, 0, -bottomThickness]) cylinder(d = outHoleDiameter, h = INSERT_TOTAL_HEIGHT); 

		if (isTranslateHole) 
			translate([translateHole[0], translateHole[1], 0]) hole();
		else 
			hole();
	}

	module hole() {
		translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness - 0.1]) cylinder(d1 = facetD, d2 = holeD, h = facetHeight + 0.1); 
		cylinder(d = holeD, INSERT_TOTAL_HEIGHT + 0.1); 
	}
}

module insertAttachToWallEmpty(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 2, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, 
	decorations = true,
    supportless = false,
) {
    layerThickness = 0.2;

	difference() {
		insertAttachToWall(holeDiameter, facetHeight, bottomThickness, tolerance, inner_tolerance, withLatch, decorations = decorations);
		cutHexagon(inner_tolerance, -bottomThickness);
	}
    if (supportless) {
        translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness]) 
            difference() {
                cylinder(d = PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 2, $fn = 6, center = true);  
                cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight), layerThickness * 4], center = true);  
            }
        translate([0,0,INSERT_TOTAL_HEIGHT-bottomThickness]) 
            difference() {
                cylinder(d=PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 4, $fn = 6, center = true);  
                rotate(90, [0, 0, 1]) 
                    cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight),layerThickness* 2 * 2 * 2], center = true);  
            }
    }
}

module hexagonPlug(tolerance=0, decorations=true) {
	if (decorations) {
		D = PLUG_HEXAGON_DIAMETER - tolerance*2;
		intersection() {
			cylinder(d=D, h=PLUG_LENGTH, $fn=6);
			translate([0,0,-0.75])
				cylinder(r1=PLUG_LENGTH + D/2, r2=0, h = PLUG_LENGTH + D/2, $fn=6); 
			translate([0,0,-D/2 + 0.75])
				cylinder(r2=PLUG_LENGTH + D/2, r1=0, h = PLUG_LENGTH + D/2, $fn=6); 
		}
	} else {
		cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
	}
}

module hexagonPlugHorizontal(tolerance=0, decorations=true) {
	translate([0,0, PLUG_AF_SIZE/2] )
	translate([0,0,-INSERT_MAIN_OUTER_AF_DISTANCE/2] )
	makeInsertHorizontal() hexagonPlug(tolerance, decorations);
}

module makeInsertHorizontal(tolerance=0) {
    large_distance=10;
    difference() {
        translate([0, 0, INSERT_MAIN_OUTER_AF_DISTANCE/2]) 
            rotate([90, 0, 0])
                children();
        translate([-large_distance, -INSERT_TOTAL_HEIGHT - 0.1, -large_distance + tolerance]) 
            cube([large_distance*2, INSERT_TOTAL_HEIGHT + 0.2, large_distance]);
    }
}

module grid(rows=[], changeCellOrder = false, maxRowLength = 10) {
	noRowsInfo = len(rows) == 0;
	upCutRowCount = noRowsInfo ? maxRowLength : rows[0];
	downCutRowCount = noRowsInfo ? maxRowLength : rows[len(rows)-1];
	
	assert( !(!noRowsInfo && len(rows) != $children), 
		"rows info if specified must describe all rows! Example: grid(rows=[1,2]) { row() { insert(); } row() { insert(); insert(); } }");

	difference() {
		for (i = [0:$children-1]) {
			tY = cellOffsetY(i, changeCellOrder);
			translate([(cellD - cellD / 4) * i, tY, 0]) children(i);
		}
		for (i = [0:$children-1]) {

			tY = cellOffsetY(i, changeCellOrder); 
			translate([(cellD - cellD / 4) * i, tY  - cellAf, 0]) connectorCutting();

			if (!noRowsInfo) {
				itemsInRow = rows[i];
				for (k=[0:maxRowLength-1]){
					translate([(cellD - cellD / 4) * i, tY  + (k + itemsInRow) * cellAf, 0]) connectorCutting();
				}
			}
		}

		tYUp = cellOffsetY($children, changeCellOrder);
		translate([(cellD - cellD / 4) * $children, -tYUp, 0]){
			for (j=[0:downCutRowCount-1]) {
				translate([0, cellAf * j, 0]) connectorCutting();
			}
		}
		tYDown = cellOffsetY(-1, changeCellOrder);
		translate([-(cellD - cellD / 4), -tYDown, 0])
			for (k=[0:upCutRowCount-1]) {
				translate([0, cellAf * k, 0]) connectorCutting();
			}
	}
}

module row(connections=true, decorations = true) {
	if ($children > 0) {
		difference() {
			for (i = [0:$children-1]) 
				translate([0, cellAf * i, 0]) {
					if (connections) connector(false, decorations);
					children(i);
				}
			translate([(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
			translate([0, cellAf * $children, 0]) connectorCutting();
			translate([-(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
		}
	}
}

// utils modules section ----------------------------------------------------

module insertBase(tolerance=0, decorations=true) {
    $fn = 6;
    difference() {
        union() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER-tolerance*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=INSERT_LIP_DIAMETER, h=INSERT_LIP_HEIGHT);
        }
		if (decorations) {
			translate([0,0,-0.1])
				union() {
					difference() {
						cylinder(d = DECORATION_OUTER_DIAMETER, h = DECORATION_DEPTH + 0.1);
						cylinder(d = DECORATION_INNER_DIAMETER, h = DECORATION_DEPTH + 0.1);
					}
				}

			translate([0,0,DECORATEION_FACET_HEIGHT]) cutFacet(INSERT_LIP_DIAMETER, inverse=true);
		}
        translate([0,0,INSERT_LIP_HEIGHT])
        rotate(90,[0,0,1])
        difference() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=af_to_diameter(INSERT_MAIN_OUTER_DIAMETER-tolerance*2) - 0.12 * 2, h=INSERT_TOTAL_HEIGHT);
        }
        cutFacetBottom();
    }
}

module cutFacet(diameter, inverse=false) {
	h = diameter / 2 * tan(45);
	z = inverse ? -h : 0;
	translate([0,0,z])
		difference() {
			cylinder(d=diameter*2, h = h);
			if (inverse)
				cylinder(d2=diameter, d1=0, h = h);
			else
				cylinder(d1=diameter, d2=0, h = h);
		}
}

module cutFacetBottom() {
	translate([0,0,INSERT_TOTAL_HEIGHT-DECORATEION_FACET_HEIGHT])
		cutFacet(INSERT_MAIN_OUTER_DIAMETER);
}

module cutHexagon(inner_tolerance, indent = 0) {
	// remove preview artifacts
	z = indent == 0 ? -0.5 : indent;
	addH = indent == 0 ? 1 : 0;
	translate([0,0,z]) 
		cylinder(d=INSERT_MAIN_INNER_DIAMETER + inner_tolerance*2, h=INSERT_TOTAL_HEIGHT + addH, $fn=6);
}

module insertMX(diameter,  nutWidth, tolerance = 0, decorations = true) {
	spacer = 0.2;
	holeD = min(maxInnerDiameter, diameter + spacer);
	facet = holeD / 8;
	facetH = 0.3;
	nutW = min(maxInnerDiameter, nutWidth + spacer);
	aboveNutW = min(maxInnerDiameter, nutW + 6);

	difference() {
		insert(tolerance, decorations = decorations);
		translate([0,0,-0.1]) // remove preview artifacts
			cylinder(d1 = holeD + facet * 2, d2 = holeD, h = facetH + 0.1);
		cylinder(d = holeD, h = INSERT_TOTAL_HEIGHT);
		translate([0, 0, 4])
		cylinder(d = nutW, h = INSERT_TOTAL_HEIGHT, $fn=6);
		translate([0, 0, 7])
		cylinder(d = aboveNutW, h = INSERT_TOTAL_HEIGHT + 0.1, $fn=6);
	}
}

module connector(forCutting=false, decorations = true) {
	connectorW = (cellAf-INSERT_LIP_AF_DISTANCE);
	connectorH = decorations ? INSERT_LIP_HEIGHT - DECORATEION_FACET_HEIGHT : INSERT_LIP_HEIGHT;
	connectorL = INSERT_LIP_DIAMETER/2;
	cuttingTranslateZ = forCutting ? -2 : 0;
	cuttingScaleZ = forCutting ? 2 : 1;

	translate([0,0,cuttingTranslateZ])
		scale([1,1,cuttingScaleZ]) 
			for (a=[0:60:300])
			rotate(a,[0,0,1])
				translate([-connectorL/2, -INSERT_LIP_AF_DISTANCE/2 - connectorW, decorations ? DECORATEION_FACET_HEIGHT : 0]) {
				points = [
					[0, addCutting(connectorW)],
					[connectorL, addCutting(connectorW)],
					[connectorL, 0],
					[0, 0],
					[-(connectorW*sin(60)), connectorW/2]
				];
				linear_extrude(height = connectorH) polygon(points);
			}

	function addCutting(value) = forCutting ? value + 0.1 : value;
}

module connectorCutting() connector(true, true);
function cellOrder(i, change) = change ? i % 2 == 0 : i % 2 != 0;
function cellOffsetY(i, change) = cellOrder(i, change) ? 0 : cellAf / 2;

/* converts an 'across flats' dimension to a maximum diameter — useful for openScad */
function af_to_diameter(af) = af / sqrt(3) * 2;
function diameter_to_af(diameter) = diameter * sqrt(3) / 2;

// ---- part ----
insertM5();
`);

Open in editor →

HSW M6 nut insert

A wall insert with a captive M6 nut pocket and screw clearance for bolting accessories to the wall.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
/* Library of hex wall bits */
/* updated */
$fn = 64;  // curve smoothness

/* Constants relating to the insert part */
INSERT_MAIN_OUTER_AF_DISTANCE = 19.7;
INSERT_MAIN_INNER_AF_DISTANCE = 13.4;
INSERT_LIP_AF_DISTANCE = 22.5;
INSERT_MAIN_OUTER_DIAMETER = af_to_diameter(INSERT_MAIN_OUTER_AF_DISTANCE);
INSERT_MAIN_INNER_DIAMETER = af_to_diameter(INSERT_MAIN_INNER_AF_DISTANCE);
INSERT_LIP_DIAMETER = af_to_diameter(INSERT_LIP_AF_DISTANCE);
INSERT_TOTAL_HEIGHT = 10;
INSERT_LIP_HEIGHT = 2.5;
INSERT_LIP_PROTRUSION = (INSERT_LIP_AF_DISTANCE - INSERT_MAIN_OUTER_AF_DISTANCE)/2;

/* Constants relating to the honeycomb itself */
HEXAGON_WIDTH = 20;
HEX_WALL_THICKNESS = 3.6;
HEX_SEPARATION = HEXAGON_WIDTH + HEX_WALL_THICKNESS;
HORIZONTAL_HEX_SEPARATION = HEX_SEPARATION * 2 / sqrt(3) + af_to_diameter(HEXAGON_WIDTH + HEX_WALL_THICKNESS)/2;

/* Constants relating to the plug that can go into an empty insert */
PLUG_HEXAGON_DIAMETER = 14.7;
PLUG_AF_SIZE = PLUG_HEXAGON_DIAMETER * sqrt(3) / 2;
PLUG_LENGTH = 13;

DECORATION_OUTER_DIAMETER = 21.362;
DECORATION_INNER_DIAMETER = 19.053;
DECORATION_DEPTH = 0.3;
DECORATEION_FACET_HEIGHT = 0.35;

tiny_distance = .001;
maxInnerDiameter = 16.5;

cellAf = 23.6;
cellD = af_to_diameter(cellAf);

// insert_empty();
// insert_with_plate();
// insert_horizontal();
// hexagon_plug();
// hexagon_plug_horizontal();
// ^ this items has no decorations for compatibility

//insert(); 		// same as insert_with_plate(); but no cut hexagon underneeze
//insertEmpty(); 	// same as insert_empty();
//insertM2_5();
//insertM3();
//insertM4();
//insertM5();
//insertM6();
//insertM8();
//insertM10();
//insertAttachToWall(5, facetHeight = 1, bottomThickness = 1.5, translateHole = [2.5,-3.5], decorations=false);
//insertAttachToWallEmpty(3.5, facetHeight = 2, bottomThickness = 3, withLatch = false, decorations = true, supportless = true);
//hexagonPlug();
//hexagonPlugHorizontal();

//makeInsertHorizontal() insertEmpty(); // <- any insert 


/*
grid(changeCellOrder=false) {
	row(decorations = false) {
		insertAttachToWallEmpty(4, decorations=false, withLatch=true, facetHeight = 1.6);
		insertEmpty(decorations=false);
	}
	row(decorations = false) {
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
	}
}
//*/

module insert_empty(tolerance = 0, inner_tolerance = 0) insertEmpty(tolerance, inner_tolerance, decorations=false);

module insert_with_plate(tolerance = 0, inner_tolerance = 0) { 
	difference() {
		insert(tolerance, decorations=false);
		cutHexagon(inner_tolerance, INSERT_LIP_HEIGHT);
	}
}

module insert_horizontal(tolerance = 0, inner_tolerance = 0) {
	makeInsertHorizontal(tolerance) insert_with_plate(tolerance);
}

module hexagon_plug(tolerance = 0) {
    cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
}

module hexagon_plug_horizontal(tolerance = 0) {
    translate([0, 0, PLUG_AF_SIZE/2 - tolerance])
        rotate([90, 0, 0]) 
			hexagon_plug(tolerance);
}

module insert(tolerance = 0, decorations = true) {
	$fn = 6;
    WALL_SIDE_GAP_START_HEIGHT = 6.5;
    WALL_SIDE_GAP_WIDTH = 1;
    WALL_TOP_GAP_WIDTH = 0.8;
    WALL_GAP_LENGTH = 8;
    WALL_TOP_GAP_RADIUS = 8.25;
    TAB_STICKS_OUT_BY = 0.5;
    TAB_LENGTH = 2;


	difference() {
		union() {
			for (i=[0:5]) {
					rotate([0, 0, i*60]) {
					translate([0, INSERT_MAIN_OUTER_AF_DISTANCE/2 - tolerance, 0]) {
						hull() {
							translate([0, 0, WALL_SIDE_GAP_START_HEIGHT + WALL_SIDE_GAP_WIDTH + TAB_STICKS_OUT_BY]) {
								rotate([0,90,0]){
									cylinder(r=TAB_STICKS_OUT_BY, h=TAB_LENGTH, center=true, $fn=20);
								}
							}
							translate([0, 0, INSERT_TOTAL_HEIGHT - tiny_distance]) {
								rotate([0, 90, 0]) {
									cylinder(r=0.2, h=TAB_LENGTH, center=true, $fn=20);  // rounded retention-tab tip
								}
							}
						}
					}
				}
			}
			difference() {
				insertBase(tolerance, decorations);
				for (i=[0:5]) {
					rotate([0, 0, i*60]) {
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS - tolerance, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, WALL_TOP_GAP_WIDTH, 10]);
						}
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, 10, WALL_SIDE_GAP_WIDTH]);
						}
					}
				}
			}
		}
		cutFacetBottom();
	}
}

module insertEmpty(tolerance = 0, inner_tolerance = 0, decorations = true) {
	difference() {
		insert(tolerance, decorations);
		cutHexagon(inner_tolerance);
	}
}

module insertM2_5(tolerance=0, decorations=true) insertMX(2.5, 5.77, tolerance=tolerance, decorations=decorations);
module insertM3(tolerance=0, decorations=true)   insertMX(3, 6.35, tolerance=tolerance, decorations=decorations);
module insertM4(tolerance=0, decorations=true)   insertMX(4, 8.08, tolerance=tolerance, decorations=decorations);
module insertM5(tolerance=0, decorations=true)   insertMX(5, 9.24, tolerance=tolerance, decorations=decorations);
module insertM6(tolerance=0, decorations=true)   insertMX(6, 11.55, tolerance=tolerance, decorations=decorations);
module insertM8(tolerance=0, decorations=true)   insertMX(8, 15.01, tolerance=tolerance, decorations=decorations);
module insertM10(tolerance=0, decorations=true)  insertMX(10, 17.32, tolerance=tolerance, decorations=decorations);

function calculateFacetDiameter(holeD, facetHeight) = facetHeight * 2 + holeD;

module insertAttachToWall(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 1.5, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, // <- I think there is no need latch, but you can turn it on
	translateHole = [0,0], // <- if you drill hole not accurate, you can move it by [x, y],
	decorations = true
) {
	$fn=64;
	isTranslateHole = translateHole[0] != 0 || translateHole[1] != 0;
	spacer = 0.2;
	holeD = holeDiameter + spacer;
	outHoleDiameter = isTranslateHole ? maxInnerDiameter : holeD + 4;
	facetD = calculateFacetDiameter(holeD, facetHeight);

	difference() {
		if (withLatch)  
			insert(tolerance, decorations = decorations);
		 else  
			insertBase(tolerance, decorations = decorations);

		translate([0, 0, -bottomThickness]) cylinder(d = outHoleDiameter, h = INSERT_TOTAL_HEIGHT); 

		if (isTranslateHole) 
			translate([translateHole[0], translateHole[1], 0]) hole();
		else 
			hole();
	}

	module hole() {
		translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness - 0.1]) cylinder(d1 = facetD, d2 = holeD, h = facetHeight + 0.1); 
		cylinder(d = holeD, INSERT_TOTAL_HEIGHT + 0.1); 
	}
}

module insertAttachToWallEmpty(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 2, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, 
	decorations = true,
    supportless = false,
) {
    layerThickness = 0.2;

	difference() {
		insertAttachToWall(holeDiameter, facetHeight, bottomThickness, tolerance, inner_tolerance, withLatch, decorations = decorations);
		cutHexagon(inner_tolerance, -bottomThickness);
	}
    if (supportless) {
        translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness]) 
            difference() {
                cylinder(d = PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 2, $fn = 6, center = true);  
                cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight), layerThickness * 4], center = true);  
            }
        translate([0,0,INSERT_TOTAL_HEIGHT-bottomThickness]) 
            difference() {
                cylinder(d=PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 4, $fn = 6, center = true);  
                rotate(90, [0, 0, 1]) 
                    cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight),layerThickness* 2 * 2 * 2], center = true);  
            }
    }
}

module hexagonPlug(tolerance=0, decorations=true) {
	if (decorations) {
		D = PLUG_HEXAGON_DIAMETER - tolerance*2;
		intersection() {
			cylinder(d=D, h=PLUG_LENGTH, $fn=6);
			translate([0,0,-0.75])
				cylinder(r1=PLUG_LENGTH + D/2, r2=0, h = PLUG_LENGTH + D/2, $fn=6); 
			translate([0,0,-D/2 + 0.75])
				cylinder(r2=PLUG_LENGTH + D/2, r1=0, h = PLUG_LENGTH + D/2, $fn=6); 
		}
	} else {
		cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
	}
}

module hexagonPlugHorizontal(tolerance=0, decorations=true) {
	translate([0,0, PLUG_AF_SIZE/2] )
	translate([0,0,-INSERT_MAIN_OUTER_AF_DISTANCE/2] )
	makeInsertHorizontal() hexagonPlug(tolerance, decorations);
}

module makeInsertHorizontal(tolerance=0) {
    large_distance=10;
    difference() {
        translate([0, 0, INSERT_MAIN_OUTER_AF_DISTANCE/2]) 
            rotate([90, 0, 0])
                children();
        translate([-large_distance, -INSERT_TOTAL_HEIGHT - 0.1, -large_distance + tolerance]) 
            cube([large_distance*2, INSERT_TOTAL_HEIGHT + 0.2, large_distance]);
    }
}

module grid(rows=[], changeCellOrder = false, maxRowLength = 10) {
	noRowsInfo = len(rows) == 0;
	upCutRowCount = noRowsInfo ? maxRowLength : rows[0];
	downCutRowCount = noRowsInfo ? maxRowLength : rows[len(rows)-1];
	
	assert( !(!noRowsInfo && len(rows) != $children), 
		"rows info if specified must describe all rows! Example: grid(rows=[1,2]) { row() { insert(); } row() { insert(); insert(); } }");

	difference() {
		for (i = [0:$children-1]) {
			tY = cellOffsetY(i, changeCellOrder);
			translate([(cellD - cellD / 4) * i, tY, 0]) children(i);
		}
		for (i = [0:$children-1]) {

			tY = cellOffsetY(i, changeCellOrder); 
			translate([(cellD - cellD / 4) * i, tY  - cellAf, 0]) connectorCutting();

			if (!noRowsInfo) {
				itemsInRow = rows[i];
				for (k=[0:maxRowLength-1]){
					translate([(cellD - cellD / 4) * i, tY  + (k + itemsInRow) * cellAf, 0]) connectorCutting();
				}
			}
		}

		tYUp = cellOffsetY($children, changeCellOrder);
		translate([(cellD - cellD / 4) * $children, -tYUp, 0]){
			for (j=[0:downCutRowCount-1]) {
				translate([0, cellAf * j, 0]) connectorCutting();
			}
		}
		tYDown = cellOffsetY(-1, changeCellOrder);
		translate([-(cellD - cellD / 4), -tYDown, 0])
			for (k=[0:upCutRowCount-1]) {
				translate([0, cellAf * k, 0]) connectorCutting();
			}
	}
}

module row(connections=true, decorations = true) {
	if ($children > 0) {
		difference() {
			for (i = [0:$children-1]) 
				translate([0, cellAf * i, 0]) {
					if (connections) connector(false, decorations);
					children(i);
				}
			translate([(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
			translate([0, cellAf * $children, 0]) connectorCutting();
			translate([-(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
		}
	}
}

// utils modules section ----------------------------------------------------

module insertBase(tolerance=0, decorations=true) {
    $fn = 6;
    difference() {
        union() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER-tolerance*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=INSERT_LIP_DIAMETER, h=INSERT_LIP_HEIGHT);
        }
		if (decorations) {
			translate([0,0,-0.1])
				union() {
					difference() {
						cylinder(d = DECORATION_OUTER_DIAMETER, h = DECORATION_DEPTH + 0.1);
						cylinder(d = DECORATION_INNER_DIAMETER, h = DECORATION_DEPTH + 0.1);
					}
				}

			translate([0,0,DECORATEION_FACET_HEIGHT]) cutFacet(INSERT_LIP_DIAMETER, inverse=true);
		}
        translate([0,0,INSERT_LIP_HEIGHT])
        rotate(90,[0,0,1])
        difference() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=af_to_diameter(INSERT_MAIN_OUTER_DIAMETER-tolerance*2) - 0.12 * 2, h=INSERT_TOTAL_HEIGHT);
        }
        cutFacetBottom();
    }
}

module cutFacet(diameter, inverse=false) {
	h = diameter / 2 * tan(45);
	z = inverse ? -h : 0;
	translate([0,0,z])
		difference() {
			cylinder(d=diameter*2, h = h);
			if (inverse)
				cylinder(d2=diameter, d1=0, h = h);
			else
				cylinder(d1=diameter, d2=0, h = h);
		}
}

module cutFacetBottom() {
	translate([0,0,INSERT_TOTAL_HEIGHT-DECORATEION_FACET_HEIGHT])
		cutFacet(INSERT_MAIN_OUTER_DIAMETER);
}

module cutHexagon(inner_tolerance, indent = 0) {
	// remove preview artifacts
	z = indent == 0 ? -0.5 : indent;
	addH = indent == 0 ? 1 : 0;
	translate([0,0,z]) 
		cylinder(d=INSERT_MAIN_INNER_DIAMETER + inner_tolerance*2, h=INSERT_TOTAL_HEIGHT + addH, $fn=6);
}

module insertMX(diameter,  nutWidth, tolerance = 0, decorations = true) {
	spacer = 0.2;
	holeD = min(maxInnerDiameter, diameter + spacer);
	facet = holeD / 8;
	facetH = 0.3;
	nutW = min(maxInnerDiameter, nutWidth + spacer);
	aboveNutW = min(maxInnerDiameter, nutW + 6);

	difference() {
		insert(tolerance, decorations = decorations);
		translate([0,0,-0.1]) // remove preview artifacts
			cylinder(d1 = holeD + facet * 2, d2 = holeD, h = facetH + 0.1);
		cylinder(d = holeD, h = INSERT_TOTAL_HEIGHT);
		translate([0, 0, 4])
		cylinder(d = nutW, h = INSERT_TOTAL_HEIGHT, $fn=6);
		translate([0, 0, 7])
		cylinder(d = aboveNutW, h = INSERT_TOTAL_HEIGHT + 0.1, $fn=6);
	}
}

module connector(forCutting=false, decorations = true) {
	connectorW = (cellAf-INSERT_LIP_AF_DISTANCE);
	connectorH = decorations ? INSERT_LIP_HEIGHT - DECORATEION_FACET_HEIGHT : INSERT_LIP_HEIGHT;
	connectorL = INSERT_LIP_DIAMETER/2;
	cuttingTranslateZ = forCutting ? -2 : 0;
	cuttingScaleZ = forCutting ? 2 : 1;

	translate([0,0,cuttingTranslateZ])
		scale([1,1,cuttingScaleZ]) 
			for (a=[0:60:300])
			rotate(a,[0,0,1])
				translate([-connectorL/2, -INSERT_LIP_AF_DISTANCE/2 - connectorW, decorations ? DECORATEION_FACET_HEIGHT : 0]) {
				points = [
					[0, addCutting(connectorW)],
					[connectorL, addCutting(connectorW)],
					[connectorL, 0],
					[0, 0],
					[-(connectorW*sin(60)), connectorW/2]
				];
				linear_extrude(height = connectorH) polygon(points);
			}

	function addCutting(value) = forCutting ? value + 0.1 : value;
}

module connectorCutting() connector(true, true);
function cellOrder(i, change) = change ? i % 2 == 0 : i % 2 != 0;
function cellOffsetY(i, change) = cellOrder(i, change) ? 0 : cellAf / 2;

/* converts an 'across flats' dimension to a maximum diameter — useful for openScad */
function af_to_diameter(af) = af / sqrt(3) * 2;
function diameter_to_af(diameter) = diameter * sqrt(3) / 2;

// ---- part ----
insertM6();
`);

Open in editor →

HSW M8 nut insert

A wall insert with a captive M8 nut pocket and screw clearance for bolting accessories to the wall.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
/* Library of hex wall bits */
/* updated */
$fn = 64;  // curve smoothness

/* Constants relating to the insert part */
INSERT_MAIN_OUTER_AF_DISTANCE = 19.7;
INSERT_MAIN_INNER_AF_DISTANCE = 13.4;
INSERT_LIP_AF_DISTANCE = 22.5;
INSERT_MAIN_OUTER_DIAMETER = af_to_diameter(INSERT_MAIN_OUTER_AF_DISTANCE);
INSERT_MAIN_INNER_DIAMETER = af_to_diameter(INSERT_MAIN_INNER_AF_DISTANCE);
INSERT_LIP_DIAMETER = af_to_diameter(INSERT_LIP_AF_DISTANCE);
INSERT_TOTAL_HEIGHT = 10;
INSERT_LIP_HEIGHT = 2.5;
INSERT_LIP_PROTRUSION = (INSERT_LIP_AF_DISTANCE - INSERT_MAIN_OUTER_AF_DISTANCE)/2;

/* Constants relating to the honeycomb itself */
HEXAGON_WIDTH = 20;
HEX_WALL_THICKNESS = 3.6;
HEX_SEPARATION = HEXAGON_WIDTH + HEX_WALL_THICKNESS;
HORIZONTAL_HEX_SEPARATION = HEX_SEPARATION * 2 / sqrt(3) + af_to_diameter(HEXAGON_WIDTH + HEX_WALL_THICKNESS)/2;

/* Constants relating to the plug that can go into an empty insert */
PLUG_HEXAGON_DIAMETER = 14.7;
PLUG_AF_SIZE = PLUG_HEXAGON_DIAMETER * sqrt(3) / 2;
PLUG_LENGTH = 13;

DECORATION_OUTER_DIAMETER = 21.362;
DECORATION_INNER_DIAMETER = 19.053;
DECORATION_DEPTH = 0.3;
DECORATEION_FACET_HEIGHT = 0.35;

tiny_distance = .001;
maxInnerDiameter = 16.5;

cellAf = 23.6;
cellD = af_to_diameter(cellAf);

// insert_empty();
// insert_with_plate();
// insert_horizontal();
// hexagon_plug();
// hexagon_plug_horizontal();
// ^ this items has no decorations for compatibility

//insert(); 		// same as insert_with_plate(); but no cut hexagon underneeze
//insertEmpty(); 	// same as insert_empty();
//insertM2_5();
//insertM3();
//insertM4();
//insertM5();
//insertM6();
//insertM8();
//insertM10();
//insertAttachToWall(5, facetHeight = 1, bottomThickness = 1.5, translateHole = [2.5,-3.5], decorations=false);
//insertAttachToWallEmpty(3.5, facetHeight = 2, bottomThickness = 3, withLatch = false, decorations = true, supportless = true);
//hexagonPlug();
//hexagonPlugHorizontal();

//makeInsertHorizontal() insertEmpty(); // <- any insert 


/*
grid(changeCellOrder=false) {
	row(decorations = false) {
		insertAttachToWallEmpty(4, decorations=false, withLatch=true, facetHeight = 1.6);
		insertEmpty(decorations=false);
	}
	row(decorations = false) {
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
	}
}
//*/

module insert_empty(tolerance = 0, inner_tolerance = 0) insertEmpty(tolerance, inner_tolerance, decorations=false);

module insert_with_plate(tolerance = 0, inner_tolerance = 0) { 
	difference() {
		insert(tolerance, decorations=false);
		cutHexagon(inner_tolerance, INSERT_LIP_HEIGHT);
	}
}

module insert_horizontal(tolerance = 0, inner_tolerance = 0) {
	makeInsertHorizontal(tolerance) insert_with_plate(tolerance);
}

module hexagon_plug(tolerance = 0) {
    cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
}

module hexagon_plug_horizontal(tolerance = 0) {
    translate([0, 0, PLUG_AF_SIZE/2 - tolerance])
        rotate([90, 0, 0]) 
			hexagon_plug(tolerance);
}

module insert(tolerance = 0, decorations = true) {
	$fn = 6;
    WALL_SIDE_GAP_START_HEIGHT = 6.5;
    WALL_SIDE_GAP_WIDTH = 1;
    WALL_TOP_GAP_WIDTH = 0.8;
    WALL_GAP_LENGTH = 8;
    WALL_TOP_GAP_RADIUS = 8.25;
    TAB_STICKS_OUT_BY = 0.5;
    TAB_LENGTH = 2;


	difference() {
		union() {
			for (i=[0:5]) {
					rotate([0, 0, i*60]) {
					translate([0, INSERT_MAIN_OUTER_AF_DISTANCE/2 - tolerance, 0]) {
						hull() {
							translate([0, 0, WALL_SIDE_GAP_START_HEIGHT + WALL_SIDE_GAP_WIDTH + TAB_STICKS_OUT_BY]) {
								rotate([0,90,0]){
									cylinder(r=TAB_STICKS_OUT_BY, h=TAB_LENGTH, center=true, $fn=20);
								}
							}
							translate([0, 0, INSERT_TOTAL_HEIGHT - tiny_distance]) {
								rotate([0, 90, 0]) {
									cylinder(r=0.2, h=TAB_LENGTH, center=true, $fn=20);  // rounded retention-tab tip
								}
							}
						}
					}
				}
			}
			difference() {
				insertBase(tolerance, decorations);
				for (i=[0:5]) {
					rotate([0, 0, i*60]) {
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS - tolerance, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, WALL_TOP_GAP_WIDTH, 10]);
						}
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, 10, WALL_SIDE_GAP_WIDTH]);
						}
					}
				}
			}
		}
		cutFacetBottom();
	}
}

module insertEmpty(tolerance = 0, inner_tolerance = 0, decorations = true) {
	difference() {
		insert(tolerance, decorations);
		cutHexagon(inner_tolerance);
	}
}

module insertM2_5(tolerance=0, decorations=true) insertMX(2.5, 5.77, tolerance=tolerance, decorations=decorations);
module insertM3(tolerance=0, decorations=true)   insertMX(3, 6.35, tolerance=tolerance, decorations=decorations);
module insertM4(tolerance=0, decorations=true)   insertMX(4, 8.08, tolerance=tolerance, decorations=decorations);
module insertM5(tolerance=0, decorations=true)   insertMX(5, 9.24, tolerance=tolerance, decorations=decorations);
module insertM6(tolerance=0, decorations=true)   insertMX(6, 11.55, tolerance=tolerance, decorations=decorations);
module insertM8(tolerance=0, decorations=true)   insertMX(8, 15.01, tolerance=tolerance, decorations=decorations);
module insertM10(tolerance=0, decorations=true)  insertMX(10, 17.32, tolerance=tolerance, decorations=decorations);

function calculateFacetDiameter(holeD, facetHeight) = facetHeight * 2 + holeD;

module insertAttachToWall(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 1.5, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, // <- I think there is no need latch, but you can turn it on
	translateHole = [0,0], // <- if you drill hole not accurate, you can move it by [x, y],
	decorations = true
) {
	$fn=64;
	isTranslateHole = translateHole[0] != 0 || translateHole[1] != 0;
	spacer = 0.2;
	holeD = holeDiameter + spacer;
	outHoleDiameter = isTranslateHole ? maxInnerDiameter : holeD + 4;
	facetD = calculateFacetDiameter(holeD, facetHeight);

	difference() {
		if (withLatch)  
			insert(tolerance, decorations = decorations);
		 else  
			insertBase(tolerance, decorations = decorations);

		translate([0, 0, -bottomThickness]) cylinder(d = outHoleDiameter, h = INSERT_TOTAL_HEIGHT); 

		if (isTranslateHole) 
			translate([translateHole[0], translateHole[1], 0]) hole();
		else 
			hole();
	}

	module hole() {
		translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness - 0.1]) cylinder(d1 = facetD, d2 = holeD, h = facetHeight + 0.1); 
		cylinder(d = holeD, INSERT_TOTAL_HEIGHT + 0.1); 
	}
}

module insertAttachToWallEmpty(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 2, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, 
	decorations = true,
    supportless = false,
) {
    layerThickness = 0.2;

	difference() {
		insertAttachToWall(holeDiameter, facetHeight, bottomThickness, tolerance, inner_tolerance, withLatch, decorations = decorations);
		cutHexagon(inner_tolerance, -bottomThickness);
	}
    if (supportless) {
        translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness]) 
            difference() {
                cylinder(d = PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 2, $fn = 6, center = true);  
                cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight), layerThickness * 4], center = true);  
            }
        translate([0,0,INSERT_TOTAL_HEIGHT-bottomThickness]) 
            difference() {
                cylinder(d=PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 4, $fn = 6, center = true);  
                rotate(90, [0, 0, 1]) 
                    cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight),layerThickness* 2 * 2 * 2], center = true);  
            }
    }
}

module hexagonPlug(tolerance=0, decorations=true) {
	if (decorations) {
		D = PLUG_HEXAGON_DIAMETER - tolerance*2;
		intersection() {
			cylinder(d=D, h=PLUG_LENGTH, $fn=6);
			translate([0,0,-0.75])
				cylinder(r1=PLUG_LENGTH + D/2, r2=0, h = PLUG_LENGTH + D/2, $fn=6); 
			translate([0,0,-D/2 + 0.75])
				cylinder(r2=PLUG_LENGTH + D/2, r1=0, h = PLUG_LENGTH + D/2, $fn=6); 
		}
	} else {
		cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
	}
}

module hexagonPlugHorizontal(tolerance=0, decorations=true) {
	translate([0,0, PLUG_AF_SIZE/2] )
	translate([0,0,-INSERT_MAIN_OUTER_AF_DISTANCE/2] )
	makeInsertHorizontal() hexagonPlug(tolerance, decorations);
}

module makeInsertHorizontal(tolerance=0) {
    large_distance=10;
    difference() {
        translate([0, 0, INSERT_MAIN_OUTER_AF_DISTANCE/2]) 
            rotate([90, 0, 0])
                children();
        translate([-large_distance, -INSERT_TOTAL_HEIGHT - 0.1, -large_distance + tolerance]) 
            cube([large_distance*2, INSERT_TOTAL_HEIGHT + 0.2, large_distance]);
    }
}

module grid(rows=[], changeCellOrder = false, maxRowLength = 10) {
	noRowsInfo = len(rows) == 0;
	upCutRowCount = noRowsInfo ? maxRowLength : rows[0];
	downCutRowCount = noRowsInfo ? maxRowLength : rows[len(rows)-1];
	
	assert( !(!noRowsInfo && len(rows) != $children), 
		"rows info if specified must describe all rows! Example: grid(rows=[1,2]) { row() { insert(); } row() { insert(); insert(); } }");

	difference() {
		for (i = [0:$children-1]) {
			tY = cellOffsetY(i, changeCellOrder);
			translate([(cellD - cellD / 4) * i, tY, 0]) children(i);
		}
		for (i = [0:$children-1]) {

			tY = cellOffsetY(i, changeCellOrder); 
			translate([(cellD - cellD / 4) * i, tY  - cellAf, 0]) connectorCutting();

			if (!noRowsInfo) {
				itemsInRow = rows[i];
				for (k=[0:maxRowLength-1]){
					translate([(cellD - cellD / 4) * i, tY  + (k + itemsInRow) * cellAf, 0]) connectorCutting();
				}
			}
		}

		tYUp = cellOffsetY($children, changeCellOrder);
		translate([(cellD - cellD / 4) * $children, -tYUp, 0]){
			for (j=[0:downCutRowCount-1]) {
				translate([0, cellAf * j, 0]) connectorCutting();
			}
		}
		tYDown = cellOffsetY(-1, changeCellOrder);
		translate([-(cellD - cellD / 4), -tYDown, 0])
			for (k=[0:upCutRowCount-1]) {
				translate([0, cellAf * k, 0]) connectorCutting();
			}
	}
}

module row(connections=true, decorations = true) {
	if ($children > 0) {
		difference() {
			for (i = [0:$children-1]) 
				translate([0, cellAf * i, 0]) {
					if (connections) connector(false, decorations);
					children(i);
				}
			translate([(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
			translate([0, cellAf * $children, 0]) connectorCutting();
			translate([-(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
		}
	}
}

// utils modules section ----------------------------------------------------

module insertBase(tolerance=0, decorations=true) {
    $fn = 6;
    difference() {
        union() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER-tolerance*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=INSERT_LIP_DIAMETER, h=INSERT_LIP_HEIGHT);
        }
		if (decorations) {
			translate([0,0,-0.1])
				union() {
					difference() {
						cylinder(d = DECORATION_OUTER_DIAMETER, h = DECORATION_DEPTH + 0.1);
						cylinder(d = DECORATION_INNER_DIAMETER, h = DECORATION_DEPTH + 0.1);
					}
				}

			translate([0,0,DECORATEION_FACET_HEIGHT]) cutFacet(INSERT_LIP_DIAMETER, inverse=true);
		}
        translate([0,0,INSERT_LIP_HEIGHT])
        rotate(90,[0,0,1])
        difference() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=af_to_diameter(INSERT_MAIN_OUTER_DIAMETER-tolerance*2) - 0.12 * 2, h=INSERT_TOTAL_HEIGHT);
        }
        cutFacetBottom();
    }
}

module cutFacet(diameter, inverse=false) {
	h = diameter / 2 * tan(45);
	z = inverse ? -h : 0;
	translate([0,0,z])
		difference() {
			cylinder(d=diameter*2, h = h);
			if (inverse)
				cylinder(d2=diameter, d1=0, h = h);
			else
				cylinder(d1=diameter, d2=0, h = h);
		}
}

module cutFacetBottom() {
	translate([0,0,INSERT_TOTAL_HEIGHT-DECORATEION_FACET_HEIGHT])
		cutFacet(INSERT_MAIN_OUTER_DIAMETER);
}

module cutHexagon(inner_tolerance, indent = 0) {
	// remove preview artifacts
	z = indent == 0 ? -0.5 : indent;
	addH = indent == 0 ? 1 : 0;
	translate([0,0,z]) 
		cylinder(d=INSERT_MAIN_INNER_DIAMETER + inner_tolerance*2, h=INSERT_TOTAL_HEIGHT + addH, $fn=6);
}

module insertMX(diameter,  nutWidth, tolerance = 0, decorations = true) {
	spacer = 0.2;
	holeD = min(maxInnerDiameter, diameter + spacer);
	facet = holeD / 8;
	facetH = 0.3;
	nutW = min(maxInnerDiameter, nutWidth + spacer);
	aboveNutW = min(maxInnerDiameter, nutW + 6);

	difference() {
		insert(tolerance, decorations = decorations);
		translate([0,0,-0.1]) // remove preview artifacts
			cylinder(d1 = holeD + facet * 2, d2 = holeD, h = facetH + 0.1);
		cylinder(d = holeD, h = INSERT_TOTAL_HEIGHT);
		translate([0, 0, 4])
		cylinder(d = nutW, h = INSERT_TOTAL_HEIGHT, $fn=6);
		translate([0, 0, 7])
		cylinder(d = aboveNutW, h = INSERT_TOTAL_HEIGHT + 0.1, $fn=6);
	}
}

module connector(forCutting=false, decorations = true) {
	connectorW = (cellAf-INSERT_LIP_AF_DISTANCE);
	connectorH = decorations ? INSERT_LIP_HEIGHT - DECORATEION_FACET_HEIGHT : INSERT_LIP_HEIGHT;
	connectorL = INSERT_LIP_DIAMETER/2;
	cuttingTranslateZ = forCutting ? -2 : 0;
	cuttingScaleZ = forCutting ? 2 : 1;

	translate([0,0,cuttingTranslateZ])
		scale([1,1,cuttingScaleZ]) 
			for (a=[0:60:300])
			rotate(a,[0,0,1])
				translate([-connectorL/2, -INSERT_LIP_AF_DISTANCE/2 - connectorW, decorations ? DECORATEION_FACET_HEIGHT : 0]) {
				points = [
					[0, addCutting(connectorW)],
					[connectorL, addCutting(connectorW)],
					[connectorL, 0],
					[0, 0],
					[-(connectorW*sin(60)), connectorW/2]
				];
				linear_extrude(height = connectorH) polygon(points);
			}

	function addCutting(value) = forCutting ? value + 0.1 : value;
}

module connectorCutting() connector(true, true);
function cellOrder(i, change) = change ? i % 2 == 0 : i % 2 != 0;
function cellOffsetY(i, change) = cellOrder(i, change) ? 0 : cellAf / 2;

/* converts an 'across flats' dimension to a maximum diameter — useful for openScad */
function af_to_diameter(af) = af / sqrt(3) * 2;
function diameter_to_af(diameter) = diameter * sqrt(3) / 2;

// ---- part ----
insertM8();
`);

Open in editor →

HSW M10 nut insert

A wall insert with a captive M10 nut pocket and screw clearance for bolting accessories to the wall.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
/* Library of hex wall bits */
/* updated */
$fn = 64;  // curve smoothness

/* Constants relating to the insert part */
INSERT_MAIN_OUTER_AF_DISTANCE = 19.7;
INSERT_MAIN_INNER_AF_DISTANCE = 13.4;
INSERT_LIP_AF_DISTANCE = 22.5;
INSERT_MAIN_OUTER_DIAMETER = af_to_diameter(INSERT_MAIN_OUTER_AF_DISTANCE);
INSERT_MAIN_INNER_DIAMETER = af_to_diameter(INSERT_MAIN_INNER_AF_DISTANCE);
INSERT_LIP_DIAMETER = af_to_diameter(INSERT_LIP_AF_DISTANCE);
INSERT_TOTAL_HEIGHT = 10;
INSERT_LIP_HEIGHT = 2.5;
INSERT_LIP_PROTRUSION = (INSERT_LIP_AF_DISTANCE - INSERT_MAIN_OUTER_AF_DISTANCE)/2;

/* Constants relating to the honeycomb itself */
HEXAGON_WIDTH = 20;
HEX_WALL_THICKNESS = 3.6;
HEX_SEPARATION = HEXAGON_WIDTH + HEX_WALL_THICKNESS;
HORIZONTAL_HEX_SEPARATION = HEX_SEPARATION * 2 / sqrt(3) + af_to_diameter(HEXAGON_WIDTH + HEX_WALL_THICKNESS)/2;

/* Constants relating to the plug that can go into an empty insert */
PLUG_HEXAGON_DIAMETER = 14.7;
PLUG_AF_SIZE = PLUG_HEXAGON_DIAMETER * sqrt(3) / 2;
PLUG_LENGTH = 13;

DECORATION_OUTER_DIAMETER = 21.362;
DECORATION_INNER_DIAMETER = 19.053;
DECORATION_DEPTH = 0.3;
DECORATEION_FACET_HEIGHT = 0.35;

tiny_distance = .001;
maxInnerDiameter = 16.5;

cellAf = 23.6;
cellD = af_to_diameter(cellAf);

// insert_empty();
// insert_with_plate();
// insert_horizontal();
// hexagon_plug();
// hexagon_plug_horizontal();
// ^ this items has no decorations for compatibility

//insert(); 		// same as insert_with_plate(); but no cut hexagon underneeze
//insertEmpty(); 	// same as insert_empty();
//insertM2_5();
//insertM3();
//insertM4();
//insertM5();
//insertM6();
//insertM8();
//insertM10();
//insertAttachToWall(5, facetHeight = 1, bottomThickness = 1.5, translateHole = [2.5,-3.5], decorations=false);
//insertAttachToWallEmpty(3.5, facetHeight = 2, bottomThickness = 3, withLatch = false, decorations = true, supportless = true);
//hexagonPlug();
//hexagonPlugHorizontal();

//makeInsertHorizontal() insertEmpty(); // <- any insert 


/*
grid(changeCellOrder=false) {
	row(decorations = false) {
		insertAttachToWallEmpty(4, decorations=false, withLatch=true, facetHeight = 1.6);
		insertEmpty(decorations=false);
	}
	row(decorations = false) {
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
	}
}
//*/

module insert_empty(tolerance = 0, inner_tolerance = 0) insertEmpty(tolerance, inner_tolerance, decorations=false);

module insert_with_plate(tolerance = 0, inner_tolerance = 0) { 
	difference() {
		insert(tolerance, decorations=false);
		cutHexagon(inner_tolerance, INSERT_LIP_HEIGHT);
	}
}

module insert_horizontal(tolerance = 0, inner_tolerance = 0) {
	makeInsertHorizontal(tolerance) insert_with_plate(tolerance);
}

module hexagon_plug(tolerance = 0) {
    cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
}

module hexagon_plug_horizontal(tolerance = 0) {
    translate([0, 0, PLUG_AF_SIZE/2 - tolerance])
        rotate([90, 0, 0]) 
			hexagon_plug(tolerance);
}

module insert(tolerance = 0, decorations = true) {
	$fn = 6;
    WALL_SIDE_GAP_START_HEIGHT = 6.5;
    WALL_SIDE_GAP_WIDTH = 1;
    WALL_TOP_GAP_WIDTH = 0.8;
    WALL_GAP_LENGTH = 8;
    WALL_TOP_GAP_RADIUS = 8.25;
    TAB_STICKS_OUT_BY = 0.5;
    TAB_LENGTH = 2;


	difference() {
		union() {
			for (i=[0:5]) {
					rotate([0, 0, i*60]) {
					translate([0, INSERT_MAIN_OUTER_AF_DISTANCE/2 - tolerance, 0]) {
						hull() {
							translate([0, 0, WALL_SIDE_GAP_START_HEIGHT + WALL_SIDE_GAP_WIDTH + TAB_STICKS_OUT_BY]) {
								rotate([0,90,0]){
									cylinder(r=TAB_STICKS_OUT_BY, h=TAB_LENGTH, center=true, $fn=20);
								}
							}
							translate([0, 0, INSERT_TOTAL_HEIGHT - tiny_distance]) {
								rotate([0, 90, 0]) {
									cylinder(r=0.2, h=TAB_LENGTH, center=true, $fn=20);  // rounded retention-tab tip
								}
							}
						}
					}
				}
			}
			difference() {
				insertBase(tolerance, decorations);
				for (i=[0:5]) {
					rotate([0, 0, i*60]) {
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS - tolerance, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, WALL_TOP_GAP_WIDTH, 10]);
						}
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, 10, WALL_SIDE_GAP_WIDTH]);
						}
					}
				}
			}
		}
		cutFacetBottom();
	}
}

module insertEmpty(tolerance = 0, inner_tolerance = 0, decorations = true) {
	difference() {
		insert(tolerance, decorations);
		cutHexagon(inner_tolerance);
	}
}

module insertM2_5(tolerance=0, decorations=true) insertMX(2.5, 5.77, tolerance=tolerance, decorations=decorations);
module insertM3(tolerance=0, decorations=true)   insertMX(3, 6.35, tolerance=tolerance, decorations=decorations);
module insertM4(tolerance=0, decorations=true)   insertMX(4, 8.08, tolerance=tolerance, decorations=decorations);
module insertM5(tolerance=0, decorations=true)   insertMX(5, 9.24, tolerance=tolerance, decorations=decorations);
module insertM6(tolerance=0, decorations=true)   insertMX(6, 11.55, tolerance=tolerance, decorations=decorations);
module insertM8(tolerance=0, decorations=true)   insertMX(8, 15.01, tolerance=tolerance, decorations=decorations);
module insertM10(tolerance=0, decorations=true)  insertMX(10, 17.32, tolerance=tolerance, decorations=decorations);

function calculateFacetDiameter(holeD, facetHeight) = facetHeight * 2 + holeD;

module insertAttachToWall(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 1.5, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, // <- I think there is no need latch, but you can turn it on
	translateHole = [0,0], // <- if you drill hole not accurate, you can move it by [x, y],
	decorations = true
) {
	$fn=64;
	isTranslateHole = translateHole[0] != 0 || translateHole[1] != 0;
	spacer = 0.2;
	holeD = holeDiameter + spacer;
	outHoleDiameter = isTranslateHole ? maxInnerDiameter : holeD + 4;
	facetD = calculateFacetDiameter(holeD, facetHeight);

	difference() {
		if (withLatch)  
			insert(tolerance, decorations = decorations);
		 else  
			insertBase(tolerance, decorations = decorations);

		translate([0, 0, -bottomThickness]) cylinder(d = outHoleDiameter, h = INSERT_TOTAL_HEIGHT); 

		if (isTranslateHole) 
			translate([translateHole[0], translateHole[1], 0]) hole();
		else 
			hole();
	}

	module hole() {
		translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness - 0.1]) cylinder(d1 = facetD, d2 = holeD, h = facetHeight + 0.1); 
		cylinder(d = holeD, INSERT_TOTAL_HEIGHT + 0.1); 
	}
}

module insertAttachToWallEmpty(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 2, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, 
	decorations = true,
    supportless = false,
) {
    layerThickness = 0.2;

	difference() {
		insertAttachToWall(holeDiameter, facetHeight, bottomThickness, tolerance, inner_tolerance, withLatch, decorations = decorations);
		cutHexagon(inner_tolerance, -bottomThickness);
	}
    if (supportless) {
        translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness]) 
            difference() {
                cylinder(d = PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 2, $fn = 6, center = true);  
                cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight), layerThickness * 4], center = true);  
            }
        translate([0,0,INSERT_TOTAL_HEIGHT-bottomThickness]) 
            difference() {
                cylinder(d=PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 4, $fn = 6, center = true);  
                rotate(90, [0, 0, 1]) 
                    cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight),layerThickness* 2 * 2 * 2], center = true);  
            }
    }
}

module hexagonPlug(tolerance=0, decorations=true) {
	if (decorations) {
		D = PLUG_HEXAGON_DIAMETER - tolerance*2;
		intersection() {
			cylinder(d=D, h=PLUG_LENGTH, $fn=6);
			translate([0,0,-0.75])
				cylinder(r1=PLUG_LENGTH + D/2, r2=0, h = PLUG_LENGTH + D/2, $fn=6); 
			translate([0,0,-D/2 + 0.75])
				cylinder(r2=PLUG_LENGTH + D/2, r1=0, h = PLUG_LENGTH + D/2, $fn=6); 
		}
	} else {
		cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
	}
}

module hexagonPlugHorizontal(tolerance=0, decorations=true) {
	translate([0,0, PLUG_AF_SIZE/2] )
	translate([0,0,-INSERT_MAIN_OUTER_AF_DISTANCE/2] )
	makeInsertHorizontal() hexagonPlug(tolerance, decorations);
}

module makeInsertHorizontal(tolerance=0) {
    large_distance=10;
    difference() {
        translate([0, 0, INSERT_MAIN_OUTER_AF_DISTANCE/2]) 
            rotate([90, 0, 0])
                children();
        translate([-large_distance, -INSERT_TOTAL_HEIGHT - 0.1, -large_distance + tolerance]) 
            cube([large_distance*2, INSERT_TOTAL_HEIGHT + 0.2, large_distance]);
    }
}

module grid(rows=[], changeCellOrder = false, maxRowLength = 10) {
	noRowsInfo = len(rows) == 0;
	upCutRowCount = noRowsInfo ? maxRowLength : rows[0];
	downCutRowCount = noRowsInfo ? maxRowLength : rows[len(rows)-1];
	
	assert( !(!noRowsInfo && len(rows) != $children), 
		"rows info if specified must describe all rows! Example: grid(rows=[1,2]) { row() { insert(); } row() { insert(); insert(); } }");

	difference() {
		for (i = [0:$children-1]) {
			tY = cellOffsetY(i, changeCellOrder);
			translate([(cellD - cellD / 4) * i, tY, 0]) children(i);
		}
		for (i = [0:$children-1]) {

			tY = cellOffsetY(i, changeCellOrder); 
			translate([(cellD - cellD / 4) * i, tY  - cellAf, 0]) connectorCutting();

			if (!noRowsInfo) {
				itemsInRow = rows[i];
				for (k=[0:maxRowLength-1]){
					translate([(cellD - cellD / 4) * i, tY  + (k + itemsInRow) * cellAf, 0]) connectorCutting();
				}
			}
		}

		tYUp = cellOffsetY($children, changeCellOrder);
		translate([(cellD - cellD / 4) * $children, -tYUp, 0]){
			for (j=[0:downCutRowCount-1]) {
				translate([0, cellAf * j, 0]) connectorCutting();
			}
		}
		tYDown = cellOffsetY(-1, changeCellOrder);
		translate([-(cellD - cellD / 4), -tYDown, 0])
			for (k=[0:upCutRowCount-1]) {
				translate([0, cellAf * k, 0]) connectorCutting();
			}
	}
}

module row(connections=true, decorations = true) {
	if ($children > 0) {
		difference() {
			for (i = [0:$children-1]) 
				translate([0, cellAf * i, 0]) {
					if (connections) connector(false, decorations);
					children(i);
				}
			translate([(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
			translate([0, cellAf * $children, 0]) connectorCutting();
			translate([-(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
		}
	}
}

// utils modules section ----------------------------------------------------

module insertBase(tolerance=0, decorations=true) {
    $fn = 6;
    difference() {
        union() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER-tolerance*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=INSERT_LIP_DIAMETER, h=INSERT_LIP_HEIGHT);
        }
		if (decorations) {
			translate([0,0,-0.1])
				union() {
					difference() {
						cylinder(d = DECORATION_OUTER_DIAMETER, h = DECORATION_DEPTH + 0.1);
						cylinder(d = DECORATION_INNER_DIAMETER, h = DECORATION_DEPTH + 0.1);
					}
				}

			translate([0,0,DECORATEION_FACET_HEIGHT]) cutFacet(INSERT_LIP_DIAMETER, inverse=true);
		}
        translate([0,0,INSERT_LIP_HEIGHT])
        rotate(90,[0,0,1])
        difference() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=af_to_diameter(INSERT_MAIN_OUTER_DIAMETER-tolerance*2) - 0.12 * 2, h=INSERT_TOTAL_HEIGHT);
        }
        cutFacetBottom();
    }
}

module cutFacet(diameter, inverse=false) {
	h = diameter / 2 * tan(45);
	z = inverse ? -h : 0;
	translate([0,0,z])
		difference() {
			cylinder(d=diameter*2, h = h);
			if (inverse)
				cylinder(d2=diameter, d1=0, h = h);
			else
				cylinder(d1=diameter, d2=0, h = h);
		}
}

module cutFacetBottom() {
	translate([0,0,INSERT_TOTAL_HEIGHT-DECORATEION_FACET_HEIGHT])
		cutFacet(INSERT_MAIN_OUTER_DIAMETER);
}

module cutHexagon(inner_tolerance, indent = 0) {
	// remove preview artifacts
	z = indent == 0 ? -0.5 : indent;
	addH = indent == 0 ? 1 : 0;
	translate([0,0,z]) 
		cylinder(d=INSERT_MAIN_INNER_DIAMETER + inner_tolerance*2, h=INSERT_TOTAL_HEIGHT + addH, $fn=6);
}

module insertMX(diameter,  nutWidth, tolerance = 0, decorations = true) {
	spacer = 0.2;
	holeD = min(maxInnerDiameter, diameter + spacer);
	facet = holeD / 8;
	facetH = 0.3;
	nutW = min(maxInnerDiameter, nutWidth + spacer);
	aboveNutW = min(maxInnerDiameter, nutW + 6);

	difference() {
		insert(tolerance, decorations = decorations);
		translate([0,0,-0.1]) // remove preview artifacts
			cylinder(d1 = holeD + facet * 2, d2 = holeD, h = facetH + 0.1);
		cylinder(d = holeD, h = INSERT_TOTAL_HEIGHT);
		translate([0, 0, 4])
		cylinder(d = nutW, h = INSERT_TOTAL_HEIGHT, $fn=6);
		translate([0, 0, 7])
		cylinder(d = aboveNutW, h = INSERT_TOTAL_HEIGHT + 0.1, $fn=6);
	}
}

module connector(forCutting=false, decorations = true) {
	connectorW = (cellAf-INSERT_LIP_AF_DISTANCE);
	connectorH = decorations ? INSERT_LIP_HEIGHT - DECORATEION_FACET_HEIGHT : INSERT_LIP_HEIGHT;
	connectorL = INSERT_LIP_DIAMETER/2;
	cuttingTranslateZ = forCutting ? -2 : 0;
	cuttingScaleZ = forCutting ? 2 : 1;

	translate([0,0,cuttingTranslateZ])
		scale([1,1,cuttingScaleZ]) 
			for (a=[0:60:300])
			rotate(a,[0,0,1])
				translate([-connectorL/2, -INSERT_LIP_AF_DISTANCE/2 - connectorW, decorations ? DECORATEION_FACET_HEIGHT : 0]) {
				points = [
					[0, addCutting(connectorW)],
					[connectorL, addCutting(connectorW)],
					[connectorL, 0],
					[0, 0],
					[-(connectorW*sin(60)), connectorW/2]
				];
				linear_extrude(height = connectorH) polygon(points);
			}

	function addCutting(value) = forCutting ? value + 0.1 : value;
}

module connectorCutting() connector(true, true);
function cellOrder(i, change) = change ? i % 2 == 0 : i % 2 != 0;
function cellOffsetY(i, change) = cellOrder(i, change) ? 0 : cellAf / 2;

/* converts an 'across flats' dimension to a maximum diameter — useful for openScad */
function af_to_diameter(af) = af / sqrt(3) * 2;
function diameter_to_af(diameter) = diameter * sqrt(3) / 2;

// ---- part ----
insertM10();
`);

Open in editor →

HSW Attach-to-wall insert (screw-through)

A latching insert with a countersunk screw hole through its base - screw any flat object onto the honeycomb wall. Tune holeDiameter / facetHeight / bottomThickness.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
/* Library of hex wall bits */
/* updated */
$fn = 64;  // curve smoothness

/* Constants relating to the insert part */
INSERT_MAIN_OUTER_AF_DISTANCE = 19.7;
INSERT_MAIN_INNER_AF_DISTANCE = 13.4;
INSERT_LIP_AF_DISTANCE = 22.5;
INSERT_MAIN_OUTER_DIAMETER = af_to_diameter(INSERT_MAIN_OUTER_AF_DISTANCE);
INSERT_MAIN_INNER_DIAMETER = af_to_diameter(INSERT_MAIN_INNER_AF_DISTANCE);
INSERT_LIP_DIAMETER = af_to_diameter(INSERT_LIP_AF_DISTANCE);
INSERT_TOTAL_HEIGHT = 10;
INSERT_LIP_HEIGHT = 2.5;
INSERT_LIP_PROTRUSION = (INSERT_LIP_AF_DISTANCE - INSERT_MAIN_OUTER_AF_DISTANCE)/2;

/* Constants relating to the honeycomb itself */
HEXAGON_WIDTH = 20;
HEX_WALL_THICKNESS = 3.6;
HEX_SEPARATION = HEXAGON_WIDTH + HEX_WALL_THICKNESS;
HORIZONTAL_HEX_SEPARATION = HEX_SEPARATION * 2 / sqrt(3) + af_to_diameter(HEXAGON_WIDTH + HEX_WALL_THICKNESS)/2;

/* Constants relating to the plug that can go into an empty insert */
PLUG_HEXAGON_DIAMETER = 14.7;
PLUG_AF_SIZE = PLUG_HEXAGON_DIAMETER * sqrt(3) / 2;
PLUG_LENGTH = 13;

DECORATION_OUTER_DIAMETER = 21.362;
DECORATION_INNER_DIAMETER = 19.053;
DECORATION_DEPTH = 0.3;
DECORATEION_FACET_HEIGHT = 0.35;

tiny_distance = .001;
maxInnerDiameter = 16.5;

cellAf = 23.6;
cellD = af_to_diameter(cellAf);

// insert_empty();
// insert_with_plate();
// insert_horizontal();
// hexagon_plug();
// hexagon_plug_horizontal();
// ^ this items has no decorations for compatibility

//insert(); 		// same as insert_with_plate(); but no cut hexagon underneeze
//insertEmpty(); 	// same as insert_empty();
//insertM2_5();
//insertM3();
//insertM4();
//insertM5();
//insertM6();
//insertM8();
//insertM10();
//insertAttachToWall(5, facetHeight = 1, bottomThickness = 1.5, translateHole = [2.5,-3.5], decorations=false);
//insertAttachToWallEmpty(3.5, facetHeight = 2, bottomThickness = 3, withLatch = false, decorations = true, supportless = true);
//hexagonPlug();
//hexagonPlugHorizontal();

//makeInsertHorizontal() insertEmpty(); // <- any insert 


/*
grid(changeCellOrder=false) {
	row(decorations = false) {
		insertAttachToWallEmpty(4, decorations=false, withLatch=true, facetHeight = 1.6);
		insertEmpty(decorations=false);
	}
	row(decorations = false) {
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
	}
}
//*/

module insert_empty(tolerance = 0, inner_tolerance = 0) insertEmpty(tolerance, inner_tolerance, decorations=false);

module insert_with_plate(tolerance = 0, inner_tolerance = 0) { 
	difference() {
		insert(tolerance, decorations=false);
		cutHexagon(inner_tolerance, INSERT_LIP_HEIGHT);
	}
}

module insert_horizontal(tolerance = 0, inner_tolerance = 0) {
	makeInsertHorizontal(tolerance) insert_with_plate(tolerance);
}

module hexagon_plug(tolerance = 0) {
    cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
}

module hexagon_plug_horizontal(tolerance = 0) {
    translate([0, 0, PLUG_AF_SIZE/2 - tolerance])
        rotate([90, 0, 0]) 
			hexagon_plug(tolerance);
}

module insert(tolerance = 0, decorations = true) {
	$fn = 6;
    WALL_SIDE_GAP_START_HEIGHT = 6.5;
    WALL_SIDE_GAP_WIDTH = 1;
    WALL_TOP_GAP_WIDTH = 0.8;
    WALL_GAP_LENGTH = 8;
    WALL_TOP_GAP_RADIUS = 8.25;
    TAB_STICKS_OUT_BY = 0.5;
    TAB_LENGTH = 2;


	difference() {
		union() {
			for (i=[0:5]) {
					rotate([0, 0, i*60]) {
					translate([0, INSERT_MAIN_OUTER_AF_DISTANCE/2 - tolerance, 0]) {
						hull() {
							translate([0, 0, WALL_SIDE_GAP_START_HEIGHT + WALL_SIDE_GAP_WIDTH + TAB_STICKS_OUT_BY]) {
								rotate([0,90,0]){
									cylinder(r=TAB_STICKS_OUT_BY, h=TAB_LENGTH, center=true, $fn=20);
								}
							}
							translate([0, 0, INSERT_TOTAL_HEIGHT - tiny_distance]) {
								rotate([0, 90, 0]) {
									cylinder(r=0.2, h=TAB_LENGTH, center=true, $fn=20);  // rounded retention-tab tip
								}
							}
						}
					}
				}
			}
			difference() {
				insertBase(tolerance, decorations);
				for (i=[0:5]) {
					rotate([0, 0, i*60]) {
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS - tolerance, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, WALL_TOP_GAP_WIDTH, 10]);
						}
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, 10, WALL_SIDE_GAP_WIDTH]);
						}
					}
				}
			}
		}
		cutFacetBottom();
	}
}

module insertEmpty(tolerance = 0, inner_tolerance = 0, decorations = true) {
	difference() {
		insert(tolerance, decorations);
		cutHexagon(inner_tolerance);
	}
}

module insertM2_5(tolerance=0, decorations=true) insertMX(2.5, 5.77, tolerance=tolerance, decorations=decorations);
module insertM3(tolerance=0, decorations=true)   insertMX(3, 6.35, tolerance=tolerance, decorations=decorations);
module insertM4(tolerance=0, decorations=true)   insertMX(4, 8.08, tolerance=tolerance, decorations=decorations);
module insertM5(tolerance=0, decorations=true)   insertMX(5, 9.24, tolerance=tolerance, decorations=decorations);
module insertM6(tolerance=0, decorations=true)   insertMX(6, 11.55, tolerance=tolerance, decorations=decorations);
module insertM8(tolerance=0, decorations=true)   insertMX(8, 15.01, tolerance=tolerance, decorations=decorations);
module insertM10(tolerance=0, decorations=true)  insertMX(10, 17.32, tolerance=tolerance, decorations=decorations);

function calculateFacetDiameter(holeD, facetHeight) = facetHeight * 2 + holeD;

module insertAttachToWall(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 1.5, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, // <- I think there is no need latch, but you can turn it on
	translateHole = [0,0], // <- if you drill hole not accurate, you can move it by [x, y],
	decorations = true
) {
	$fn=64;
	isTranslateHole = translateHole[0] != 0 || translateHole[1] != 0;
	spacer = 0.2;
	holeD = holeDiameter + spacer;
	outHoleDiameter = isTranslateHole ? maxInnerDiameter : holeD + 4;
	facetD = calculateFacetDiameter(holeD, facetHeight);

	difference() {
		if (withLatch)  
			insert(tolerance, decorations = decorations);
		 else  
			insertBase(tolerance, decorations = decorations);

		translate([0, 0, -bottomThickness]) cylinder(d = outHoleDiameter, h = INSERT_TOTAL_HEIGHT); 

		if (isTranslateHole) 
			translate([translateHole[0], translateHole[1], 0]) hole();
		else 
			hole();
	}

	module hole() {
		translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness - 0.1]) cylinder(d1 = facetD, d2 = holeD, h = facetHeight + 0.1); 
		cylinder(d = holeD, INSERT_TOTAL_HEIGHT + 0.1); 
	}
}

module insertAttachToWallEmpty(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 2, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, 
	decorations = true,
    supportless = false,
) {
    layerThickness = 0.2;

	difference() {
		insertAttachToWall(holeDiameter, facetHeight, bottomThickness, tolerance, inner_tolerance, withLatch, decorations = decorations);
		cutHexagon(inner_tolerance, -bottomThickness);
	}
    if (supportless) {
        translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness]) 
            difference() {
                cylinder(d = PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 2, $fn = 6, center = true);  
                cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight), layerThickness * 4], center = true);  
            }
        translate([0,0,INSERT_TOTAL_HEIGHT-bottomThickness]) 
            difference() {
                cylinder(d=PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 4, $fn = 6, center = true);  
                rotate(90, [0, 0, 1]) 
                    cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight),layerThickness* 2 * 2 * 2], center = true);  
            }
    }
}

module hexagonPlug(tolerance=0, decorations=true) {
	if (decorations) {
		D = PLUG_HEXAGON_DIAMETER - tolerance*2;
		intersection() {
			cylinder(d=D, h=PLUG_LENGTH, $fn=6);
			translate([0,0,-0.75])
				cylinder(r1=PLUG_LENGTH + D/2, r2=0, h = PLUG_LENGTH + D/2, $fn=6); 
			translate([0,0,-D/2 + 0.75])
				cylinder(r2=PLUG_LENGTH + D/2, r1=0, h = PLUG_LENGTH + D/2, $fn=6); 
		}
	} else {
		cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
	}
}

module hexagonPlugHorizontal(tolerance=0, decorations=true) {
	translate([0,0, PLUG_AF_SIZE/2] )
	translate([0,0,-INSERT_MAIN_OUTER_AF_DISTANCE/2] )
	makeInsertHorizontal() hexagonPlug(tolerance, decorations);
}

module makeInsertHorizontal(tolerance=0) {
    large_distance=10;
    difference() {
        translate([0, 0, INSERT_MAIN_OUTER_AF_DISTANCE/2]) 
            rotate([90, 0, 0])
                children();
        translate([-large_distance, -INSERT_TOTAL_HEIGHT - 0.1, -large_distance + tolerance]) 
            cube([large_distance*2, INSERT_TOTAL_HEIGHT + 0.2, large_distance]);
    }
}

module grid(rows=[], changeCellOrder = false, maxRowLength = 10) {
	noRowsInfo = len(rows) == 0;
	upCutRowCount = noRowsInfo ? maxRowLength : rows[0];
	downCutRowCount = noRowsInfo ? maxRowLength : rows[len(rows)-1];
	
	assert( !(!noRowsInfo && len(rows) != $children), 
		"rows info if specified must describe all rows! Example: grid(rows=[1,2]) { row() { insert(); } row() { insert(); insert(); } }");

	difference() {
		for (i = [0:$children-1]) {
			tY = cellOffsetY(i, changeCellOrder);
			translate([(cellD - cellD / 4) * i, tY, 0]) children(i);
		}
		for (i = [0:$children-1]) {

			tY = cellOffsetY(i, changeCellOrder); 
			translate([(cellD - cellD / 4) * i, tY  - cellAf, 0]) connectorCutting();

			if (!noRowsInfo) {
				itemsInRow = rows[i];
				for (k=[0:maxRowLength-1]){
					translate([(cellD - cellD / 4) * i, tY  + (k + itemsInRow) * cellAf, 0]) connectorCutting();
				}
			}
		}

		tYUp = cellOffsetY($children, changeCellOrder);
		translate([(cellD - cellD / 4) * $children, -tYUp, 0]){
			for (j=[0:downCutRowCount-1]) {
				translate([0, cellAf * j, 0]) connectorCutting();
			}
		}
		tYDown = cellOffsetY(-1, changeCellOrder);
		translate([-(cellD - cellD / 4), -tYDown, 0])
			for (k=[0:upCutRowCount-1]) {
				translate([0, cellAf * k, 0]) connectorCutting();
			}
	}
}

module row(connections=true, decorations = true) {
	if ($children > 0) {
		difference() {
			for (i = [0:$children-1]) 
				translate([0, cellAf * i, 0]) {
					if (connections) connector(false, decorations);
					children(i);
				}
			translate([(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
			translate([0, cellAf * $children, 0]) connectorCutting();
			translate([-(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
		}
	}
}

// utils modules section ----------------------------------------------------

module insertBase(tolerance=0, decorations=true) {
    $fn = 6;
    difference() {
        union() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER-tolerance*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=INSERT_LIP_DIAMETER, h=INSERT_LIP_HEIGHT);
        }
		if (decorations) {
			translate([0,0,-0.1])
				union() {
					difference() {
						cylinder(d = DECORATION_OUTER_DIAMETER, h = DECORATION_DEPTH + 0.1);
						cylinder(d = DECORATION_INNER_DIAMETER, h = DECORATION_DEPTH + 0.1);
					}
				}

			translate([0,0,DECORATEION_FACET_HEIGHT]) cutFacet(INSERT_LIP_DIAMETER, inverse=true);
		}
        translate([0,0,INSERT_LIP_HEIGHT])
        rotate(90,[0,0,1])
        difference() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=af_to_diameter(INSERT_MAIN_OUTER_DIAMETER-tolerance*2) - 0.12 * 2, h=INSERT_TOTAL_HEIGHT);
        }
        cutFacetBottom();
    }
}

module cutFacet(diameter, inverse=false) {
	h = diameter / 2 * tan(45);
	z = inverse ? -h : 0;
	translate([0,0,z])
		difference() {
			cylinder(d=diameter*2, h = h);
			if (inverse)
				cylinder(d2=diameter, d1=0, h = h);
			else
				cylinder(d1=diameter, d2=0, h = h);
		}
}

module cutFacetBottom() {
	translate([0,0,INSERT_TOTAL_HEIGHT-DECORATEION_FACET_HEIGHT])
		cutFacet(INSERT_MAIN_OUTER_DIAMETER);
}

module cutHexagon(inner_tolerance, indent = 0) {
	// remove preview artifacts
	z = indent == 0 ? -0.5 : indent;
	addH = indent == 0 ? 1 : 0;
	translate([0,0,z]) 
		cylinder(d=INSERT_MAIN_INNER_DIAMETER + inner_tolerance*2, h=INSERT_TOTAL_HEIGHT + addH, $fn=6);
}

module insertMX(diameter,  nutWidth, tolerance = 0, decorations = true) {
	spacer = 0.2;
	holeD = min(maxInnerDiameter, diameter + spacer);
	facet = holeD / 8;
	facetH = 0.3;
	nutW = min(maxInnerDiameter, nutWidth + spacer);
	aboveNutW = min(maxInnerDiameter, nutW + 6);

	difference() {
		insert(tolerance, decorations = decorations);
		translate([0,0,-0.1]) // remove preview artifacts
			cylinder(d1 = holeD + facet * 2, d2 = holeD, h = facetH + 0.1);
		cylinder(d = holeD, h = INSERT_TOTAL_HEIGHT);
		translate([0, 0, 4])
		cylinder(d = nutW, h = INSERT_TOTAL_HEIGHT, $fn=6);
		translate([0, 0, 7])
		cylinder(d = aboveNutW, h = INSERT_TOTAL_HEIGHT + 0.1, $fn=6);
	}
}

module connector(forCutting=false, decorations = true) {
	connectorW = (cellAf-INSERT_LIP_AF_DISTANCE);
	connectorH = decorations ? INSERT_LIP_HEIGHT - DECORATEION_FACET_HEIGHT : INSERT_LIP_HEIGHT;
	connectorL = INSERT_LIP_DIAMETER/2;
	cuttingTranslateZ = forCutting ? -2 : 0;
	cuttingScaleZ = forCutting ? 2 : 1;

	translate([0,0,cuttingTranslateZ])
		scale([1,1,cuttingScaleZ]) 
			for (a=[0:60:300])
			rotate(a,[0,0,1])
				translate([-connectorL/2, -INSERT_LIP_AF_DISTANCE/2 - connectorW, decorations ? DECORATEION_FACET_HEIGHT : 0]) {
				points = [
					[0, addCutting(connectorW)],
					[connectorL, addCutting(connectorW)],
					[connectorL, 0],
					[0, 0],
					[-(connectorW*sin(60)), connectorW/2]
				];
				linear_extrude(height = connectorH) polygon(points);
			}

	function addCutting(value) = forCutting ? value + 0.1 : value;
}

module connectorCutting() connector(true, true);
function cellOrder(i, change) = change ? i % 2 == 0 : i % 2 != 0;
function cellOffsetY(i, change) = cellOrder(i, change) ? 0 : cellAf / 2;

/* converts an 'across flats' dimension to a maximum diameter — useful for openScad */
function af_to_diameter(af) = af / sqrt(3) * 2;
function diameter_to_af(diameter) = diameter * sqrt(3) / 2;

// ---- part ----
insertAttachToWall(4, facetHeight = 1, bottomThickness = 1.5);
`);

Open in editor →

HSW Attach-to-wall insert (empty, supportless)

The attach-to-wall insert with the centre bored out and a supportless bridge so it prints cleanly with no supports.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
/* Library of hex wall bits */
/* updated */
$fn = 64;  // curve smoothness

/* Constants relating to the insert part */
INSERT_MAIN_OUTER_AF_DISTANCE = 19.7;
INSERT_MAIN_INNER_AF_DISTANCE = 13.4;
INSERT_LIP_AF_DISTANCE = 22.5;
INSERT_MAIN_OUTER_DIAMETER = af_to_diameter(INSERT_MAIN_OUTER_AF_DISTANCE);
INSERT_MAIN_INNER_DIAMETER = af_to_diameter(INSERT_MAIN_INNER_AF_DISTANCE);
INSERT_LIP_DIAMETER = af_to_diameter(INSERT_LIP_AF_DISTANCE);
INSERT_TOTAL_HEIGHT = 10;
INSERT_LIP_HEIGHT = 2.5;
INSERT_LIP_PROTRUSION = (INSERT_LIP_AF_DISTANCE - INSERT_MAIN_OUTER_AF_DISTANCE)/2;

/* Constants relating to the honeycomb itself */
HEXAGON_WIDTH = 20;
HEX_WALL_THICKNESS = 3.6;
HEX_SEPARATION = HEXAGON_WIDTH + HEX_WALL_THICKNESS;
HORIZONTAL_HEX_SEPARATION = HEX_SEPARATION * 2 / sqrt(3) + af_to_diameter(HEXAGON_WIDTH + HEX_WALL_THICKNESS)/2;

/* Constants relating to the plug that can go into an empty insert */
PLUG_HEXAGON_DIAMETER = 14.7;
PLUG_AF_SIZE = PLUG_HEXAGON_DIAMETER * sqrt(3) / 2;
PLUG_LENGTH = 13;

DECORATION_OUTER_DIAMETER = 21.362;
DECORATION_INNER_DIAMETER = 19.053;
DECORATION_DEPTH = 0.3;
DECORATEION_FACET_HEIGHT = 0.35;

tiny_distance = .001;
maxInnerDiameter = 16.5;

cellAf = 23.6;
cellD = af_to_diameter(cellAf);

// insert_empty();
// insert_with_plate();
// insert_horizontal();
// hexagon_plug();
// hexagon_plug_horizontal();
// ^ this items has no decorations for compatibility

//insert(); 		// same as insert_with_plate(); but no cut hexagon underneeze
//insertEmpty(); 	// same as insert_empty();
//insertM2_5();
//insertM3();
//insertM4();
//insertM5();
//insertM6();
//insertM8();
//insertM10();
//insertAttachToWall(5, facetHeight = 1, bottomThickness = 1.5, translateHole = [2.5,-3.5], decorations=false);
//insertAttachToWallEmpty(3.5, facetHeight = 2, bottomThickness = 3, withLatch = false, decorations = true, supportless = true);
//hexagonPlug();
//hexagonPlugHorizontal();

//makeInsertHorizontal() insertEmpty(); // <- any insert 


/*
grid(changeCellOrder=false) {
	row(decorations = false) {
		insertAttachToWallEmpty(4, decorations=false, withLatch=true, facetHeight = 1.6);
		insertEmpty(decorations=false);
	}
	row(decorations = false) {
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
		insertEmpty(decorations=false);
	}
}
//*/

module insert_empty(tolerance = 0, inner_tolerance = 0) insertEmpty(tolerance, inner_tolerance, decorations=false);

module insert_with_plate(tolerance = 0, inner_tolerance = 0) { 
	difference() {
		insert(tolerance, decorations=false);
		cutHexagon(inner_tolerance, INSERT_LIP_HEIGHT);
	}
}

module insert_horizontal(tolerance = 0, inner_tolerance = 0) {
	makeInsertHorizontal(tolerance) insert_with_plate(tolerance);
}

module hexagon_plug(tolerance = 0) {
    cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
}

module hexagon_plug_horizontal(tolerance = 0) {
    translate([0, 0, PLUG_AF_SIZE/2 - tolerance])
        rotate([90, 0, 0]) 
			hexagon_plug(tolerance);
}

module insert(tolerance = 0, decorations = true) {
	$fn = 6;
    WALL_SIDE_GAP_START_HEIGHT = 6.5;
    WALL_SIDE_GAP_WIDTH = 1;
    WALL_TOP_GAP_WIDTH = 0.8;
    WALL_GAP_LENGTH = 8;
    WALL_TOP_GAP_RADIUS = 8.25;
    TAB_STICKS_OUT_BY = 0.5;
    TAB_LENGTH = 2;


	difference() {
		union() {
			for (i=[0:5]) {
					rotate([0, 0, i*60]) {
					translate([0, INSERT_MAIN_OUTER_AF_DISTANCE/2 - tolerance, 0]) {
						hull() {
							translate([0, 0, WALL_SIDE_GAP_START_HEIGHT + WALL_SIDE_GAP_WIDTH + TAB_STICKS_OUT_BY]) {
								rotate([0,90,0]){
									cylinder(r=TAB_STICKS_OUT_BY, h=TAB_LENGTH, center=true, $fn=20);
								}
							}
							translate([0, 0, INSERT_TOTAL_HEIGHT - tiny_distance]) {
								rotate([0, 90, 0]) {
									cylinder(r=0.2, h=TAB_LENGTH, center=true, $fn=20);  // rounded retention-tab tip
								}
							}
						}
					}
				}
			}
			difference() {
				insertBase(tolerance, decorations);
				for (i=[0:5]) {
					rotate([0, 0, i*60]) {
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS - tolerance, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, WALL_TOP_GAP_WIDTH, 10]);
						}
						translate([-WALL_GAP_LENGTH/2, WALL_TOP_GAP_RADIUS, WALL_SIDE_GAP_START_HEIGHT]) {
							cube([WALL_GAP_LENGTH, 10, WALL_SIDE_GAP_WIDTH]);
						}
					}
				}
			}
		}
		cutFacetBottom();
	}
}

module insertEmpty(tolerance = 0, inner_tolerance = 0, decorations = true) {
	difference() {
		insert(tolerance, decorations);
		cutHexagon(inner_tolerance);
	}
}

module insertM2_5(tolerance=0, decorations=true) insertMX(2.5, 5.77, tolerance=tolerance, decorations=decorations);
module insertM3(tolerance=0, decorations=true)   insertMX(3, 6.35, tolerance=tolerance, decorations=decorations);
module insertM4(tolerance=0, decorations=true)   insertMX(4, 8.08, tolerance=tolerance, decorations=decorations);
module insertM5(tolerance=0, decorations=true)   insertMX(5, 9.24, tolerance=tolerance, decorations=decorations);
module insertM6(tolerance=0, decorations=true)   insertMX(6, 11.55, tolerance=tolerance, decorations=decorations);
module insertM8(tolerance=0, decorations=true)   insertMX(8, 15.01, tolerance=tolerance, decorations=decorations);
module insertM10(tolerance=0, decorations=true)  insertMX(10, 17.32, tolerance=tolerance, decorations=decorations);

function calculateFacetDiameter(holeD, facetHeight) = facetHeight * 2 + holeD;

module insertAttachToWall(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 1.5, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, // <- I think there is no need latch, but you can turn it on
	translateHole = [0,0], // <- if you drill hole not accurate, you can move it by [x, y],
	decorations = true
) {
	$fn=64;
	isTranslateHole = translateHole[0] != 0 || translateHole[1] != 0;
	spacer = 0.2;
	holeD = holeDiameter + spacer;
	outHoleDiameter = isTranslateHole ? maxInnerDiameter : holeD + 4;
	facetD = calculateFacetDiameter(holeD, facetHeight);

	difference() {
		if (withLatch)  
			insert(tolerance, decorations = decorations);
		 else  
			insertBase(tolerance, decorations = decorations);

		translate([0, 0, -bottomThickness]) cylinder(d = outHoleDiameter, h = INSERT_TOTAL_HEIGHT); 

		if (isTranslateHole) 
			translate([translateHole[0], translateHole[1], 0]) hole();
		else 
			hole();
	}

	module hole() {
		translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness - 0.1]) cylinder(d1 = facetD, d2 = holeD, h = facetHeight + 0.1); 
		cylinder(d = holeD, INSERT_TOTAL_HEIGHT + 0.1); 
	}
}

module insertAttachToWallEmpty(
	holeDiameter, 
	facetHeight = 0, 
	bottomThickness = 2, 
	tolerance = 0, 
	inner_tolerance = 0, 
	withLatch = false, 
	decorations = true,
    supportless = false,
) {
    layerThickness = 0.2;

	difference() {
		insertAttachToWall(holeDiameter, facetHeight, bottomThickness, tolerance, inner_tolerance, withLatch, decorations = decorations);
		cutHexagon(inner_tolerance, -bottomThickness);
	}
    if (supportless) {
        translate([0, 0, INSERT_TOTAL_HEIGHT - bottomThickness]) 
            difference() {
                cylinder(d = PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 2, $fn = 6, center = true);  
                cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight), layerThickness * 4], center = true);  
            }
        translate([0,0,INSERT_TOTAL_HEIGHT-bottomThickness]) 
            difference() {
                cylinder(d=PLUG_HEXAGON_DIAMETER * 1.1, h = layerThickness * 4, $fn = 6, center = true);  
                rotate(90, [0, 0, 1]) 
                    cube([PLUG_HEXAGON_DIAMETER + 1, calculateFacetDiameter(holeDiameter, facetHeight),layerThickness* 2 * 2 * 2], center = true);  
            }
    }
}

module hexagonPlug(tolerance=0, decorations=true) {
	if (decorations) {
		D = PLUG_HEXAGON_DIAMETER - tolerance*2;
		intersection() {
			cylinder(d=D, h=PLUG_LENGTH, $fn=6);
			translate([0,0,-0.75])
				cylinder(r1=PLUG_LENGTH + D/2, r2=0, h = PLUG_LENGTH + D/2, $fn=6); 
			translate([0,0,-D/2 + 0.75])
				cylinder(r2=PLUG_LENGTH + D/2, r1=0, h = PLUG_LENGTH + D/2, $fn=6); 
		}
	} else {
		cylinder(d=PLUG_HEXAGON_DIAMETER - tolerance*2, h=PLUG_LENGTH, $fn=6);
	}
}

module hexagonPlugHorizontal(tolerance=0, decorations=true) {
	translate([0,0, PLUG_AF_SIZE/2] )
	translate([0,0,-INSERT_MAIN_OUTER_AF_DISTANCE/2] )
	makeInsertHorizontal() hexagonPlug(tolerance, decorations);
}

module makeInsertHorizontal(tolerance=0) {
    large_distance=10;
    difference() {
        translate([0, 0, INSERT_MAIN_OUTER_AF_DISTANCE/2]) 
            rotate([90, 0, 0])
                children();
        translate([-large_distance, -INSERT_TOTAL_HEIGHT - 0.1, -large_distance + tolerance]) 
            cube([large_distance*2, INSERT_TOTAL_HEIGHT + 0.2, large_distance]);
    }
}

module grid(rows=[], changeCellOrder = false, maxRowLength = 10) {
	noRowsInfo = len(rows) == 0;
	upCutRowCount = noRowsInfo ? maxRowLength : rows[0];
	downCutRowCount = noRowsInfo ? maxRowLength : rows[len(rows)-1];
	
	assert( !(!noRowsInfo && len(rows) != $children), 
		"rows info if specified must describe all rows! Example: grid(rows=[1,2]) { row() { insert(); } row() { insert(); insert(); } }");

	difference() {
		for (i = [0:$children-1]) {
			tY = cellOffsetY(i, changeCellOrder);
			translate([(cellD - cellD / 4) * i, tY, 0]) children(i);
		}
		for (i = [0:$children-1]) {

			tY = cellOffsetY(i, changeCellOrder); 
			translate([(cellD - cellD / 4) * i, tY  - cellAf, 0]) connectorCutting();

			if (!noRowsInfo) {
				itemsInRow = rows[i];
				for (k=[0:maxRowLength-1]){
					translate([(cellD - cellD / 4) * i, tY  + (k + itemsInRow) * cellAf, 0]) connectorCutting();
				}
			}
		}

		tYUp = cellOffsetY($children, changeCellOrder);
		translate([(cellD - cellD / 4) * $children, -tYUp, 0]){
			for (j=[0:downCutRowCount-1]) {
				translate([0, cellAf * j, 0]) connectorCutting();
			}
		}
		tYDown = cellOffsetY(-1, changeCellOrder);
		translate([-(cellD - cellD / 4), -tYDown, 0])
			for (k=[0:upCutRowCount-1]) {
				translate([0, cellAf * k, 0]) connectorCutting();
			}
	}
}

module row(connections=true, decorations = true) {
	if ($children > 0) {
		difference() {
			for (i = [0:$children-1]) 
				translate([0, cellAf * i, 0]) {
					if (connections) connector(false, decorations);
					children(i);
				}
			translate([(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
			translate([0, cellAf * $children, 0]) connectorCutting();
			translate([-(cellD - cellD / 4) , cellAf * $children - cellAf/2, 0]) connectorCutting();
		}
	}
}

// utils modules section ----------------------------------------------------

module insertBase(tolerance=0, decorations=true) {
    $fn = 6;
    difference() {
        union() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER-tolerance*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=INSERT_LIP_DIAMETER, h=INSERT_LIP_HEIGHT);
        }
		if (decorations) {
			translate([0,0,-0.1])
				union() {
					difference() {
						cylinder(d = DECORATION_OUTER_DIAMETER, h = DECORATION_DEPTH + 0.1);
						cylinder(d = DECORATION_INNER_DIAMETER, h = DECORATION_DEPTH + 0.1);
					}
				}

			translate([0,0,DECORATEION_FACET_HEIGHT]) cutFacet(INSERT_LIP_DIAMETER, inverse=true);
		}
        translate([0,0,INSERT_LIP_HEIGHT])
        rotate(90,[0,0,1])
        difference() {
            cylinder(d=INSERT_MAIN_OUTER_DIAMETER*2, h=INSERT_TOTAL_HEIGHT);
            cylinder(d=af_to_diameter(INSERT_MAIN_OUTER_DIAMETER-tolerance*2) - 0.12 * 2, h=INSERT_TOTAL_HEIGHT);
        }
        cutFacetBottom();
    }
}

module cutFacet(diameter, inverse=false) {
	h = diameter / 2 * tan(45);
	z = inverse ? -h : 0;
	translate([0,0,z])
		difference() {
			cylinder(d=diameter*2, h = h);
			if (inverse)
				cylinder(d2=diameter, d1=0, h = h);
			else
				cylinder(d1=diameter, d2=0, h = h);
		}
}

module cutFacetBottom() {
	translate([0,0,INSERT_TOTAL_HEIGHT-DECORATEION_FACET_HEIGHT])
		cutFacet(INSERT_MAIN_OUTER_DIAMETER);
}

module cutHexagon(inner_tolerance, indent = 0) {
	// remove preview artifacts
	z = indent == 0 ? -0.5 : indent;
	addH = indent == 0 ? 1 : 0;
	translate([0,0,z]) 
		cylinder(d=INSERT_MAIN_INNER_DIAMETER + inner_tolerance*2, h=INSERT_TOTAL_HEIGHT + addH, $fn=6);
}

module insertMX(diameter,  nutWidth, tolerance = 0, decorations = true) {
	spacer = 0.2;
	holeD = min(maxInnerDiameter, diameter + spacer);
	facet = holeD / 8;
	facetH = 0.3;
	nutW = min(maxInnerDiameter, nutWidth + spacer);
	aboveNutW = min(maxInnerDiameter, nutW + 6);

	difference() {
		insert(tolerance, decorations = decorations);
		translate([0,0,-0.1]) // remove preview artifacts
			cylinder(d1 = holeD + facet * 2, d2 = holeD, h = facetH + 0.1);
		cylinder(d = holeD, h = INSERT_TOTAL_HEIGHT);
		translate([0, 0, 4])
		cylinder(d = nutW, h = INSERT_TOTAL_HEIGHT, $fn=6);
		translate([0, 0, 7])
		cylinder(d = aboveNutW, h = INSERT_TOTAL_HEIGHT + 0.1, $fn=6);
	}
}

module connector(forCutting=false, decorations = true) {
	connectorW = (cellAf-INSERT_LIP_AF_DISTANCE);
	connectorH = decorations ? INSERT_LIP_HEIGHT - DECORATEION_FACET_HEIGHT : INSERT_LIP_HEIGHT;
	connectorL = INSERT_LIP_DIAMETER/2;
	cuttingTranslateZ = forCutting ? -2 : 0;
	cuttingScaleZ = forCutting ? 2 : 1;

	translate([0,0,cuttingTranslateZ])
		scale([1,1,cuttingScaleZ]) 
			for (a=[0:60:300])
			rotate(a,[0,0,1])
				translate([-connectorL/2, -INSERT_LIP_AF_DISTANCE/2 - connectorW, decorations ? DECORATEION_FACET_HEIGHT : 0]) {
				points = [
					[0, addCutting(connectorW)],
					[connectorL, addCutting(connectorW)],
					[connectorL, 0],
					[0, 0],
					[-(connectorW*sin(60)), connectorW/2]
				];
				linear_extrude(height = connectorH) polygon(points);
			}

	function addCutting(value) = forCutting ? value + 0.1 : value;
}

module connectorCutting() connector(true, true);
function cellOrder(i, change) = change ? i % 2 == 0 : i % 2 != 0;
function cellOffsetY(i, change) = cellOrder(i, change) ? 0 : cellAf / 2;

/* converts an 'across flats' dimension to a maximum diameter — useful for openScad */
function af_to_diameter(af) = af / sqrt(3) * 2;
function diameter_to_af(diameter) = diameter * sqrt(3) / 2;

// ---- part ----
insertAttachToWallEmpty(3.5, facetHeight = 1, bottomThickness = 1.5, supportless = true);
`);

Open in editor →

Gridfinity baseplate 2×2

A 2×2 Gridfinity baseplate — the grid foundation that bins drop into. Built with the kennetek gridfinity-rebuilt library; change gridx/gridy for a larger plate.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Gridfinity baseplate 2×2
//
// Source: gridfinity-rebuilt (kennetek) — MIT
// https://github.com/kennetek/gridfinity-rebuilt-openscad
// Generated from the library above, used under its license.

include <gridfinity-rebuilt/src/core/standard.scad>
include <gridfinity-rebuilt/src/core/gridfinity-baseplate.scad>
use <gridfinity-rebuilt/src/core/gridfinity-rebuilt-utility.scad>
use <gridfinity-rebuilt/src/core/gridfinity-rebuilt-holes.scad>
use <gridfinity-rebuilt/src/helpers/generic-helpers.scad>
use <gridfinity-rebuilt/src/helpers/grid.scad>
use <gridfinity-rebuilt/gridfinity-rebuilt-baseplate.scad>

gridx = 2;  // columns
gridy = 2;  // rows
gridfinityBaseplate([gridx, gridy], 42, [0, 0], 0, bundle_hole_options(), 0, [0, 0]);
`);

Open in editor →

Gridfinity baseplate 3×3

A 3×3 Gridfinity baseplate for a 9-cell organizer foundation. Built with the kennetek gridfinity-rebuilt library.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Gridfinity baseplate 3×3
//
// Source: gridfinity-rebuilt (kennetek) — MIT
// https://github.com/kennetek/gridfinity-rebuilt-openscad
// Generated from the library above, used under its license.

include <gridfinity-rebuilt/src/core/standard.scad>
include <gridfinity-rebuilt/src/core/gridfinity-baseplate.scad>
use <gridfinity-rebuilt/src/core/gridfinity-rebuilt-utility.scad>
use <gridfinity-rebuilt/src/core/gridfinity-rebuilt-holes.scad>
use <gridfinity-rebuilt/src/helpers/generic-helpers.scad>
use <gridfinity-rebuilt/src/helpers/grid.scad>
use <gridfinity-rebuilt/gridfinity-rebuilt-baseplate.scad>

gridx = 3;  // columns
gridy = 3;  // rows
gridfinityBaseplate([gridx, gridy], 42, [0, 0], 0, bundle_hole_options(), 0, [0, 0]);
`);

Open in editor →

Gridfinity bin 1×1

The smallest Gridfinity storage bin — a single 1×1 cell, 3 units tall, with a stacking lip. Built with the kennetek gridfinity-rebuilt library.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Gridfinity bin 1×1
//
// Source: gridfinity-rebuilt (kennetek) — MIT
// https://github.com/kennetek/gridfinity-rebuilt-openscad
// Generated from the library above, used under its license.

include <gridfinity-rebuilt/src/core/standard.scad>
use <gridfinity-rebuilt/src/core/bin.scad>
use <gridfinity-rebuilt/src/core/cutouts.scad>
use <gridfinity-rebuilt/src/core/gridfinity-rebuilt-holes.scad>
use <gridfinity-rebuilt/src/core/gridfinity-rebuilt-utility.scad>
use <gridfinity-rebuilt/src/helpers/generic-helpers.scad>
use <gridfinity-rebuilt/src/helpers/grid.scad>
use <gridfinity-rebuilt/src/helpers/grid_element.scad>

gridx = 1;  // columns
gridy = 1;  // rows
gridz = 3;  // height in 7mm units
divx = 1;  // compartment columns
divy = 1;  // compartment rows

bin1 = new_bin([gridx, gridy], gridz * 7);
bin_render(bin1) {
    bin_subdivide(bin1, [divx, divy]) {
        cut_compartment_auto(cgs(), 5, false, 0);
    }
}
`);

Open in editor →

Gridfinity bin 2×1

A 2×1 Gridfinity storage bin, 6 units tall, one open compartment. Built with the kennetek gridfinity-rebuilt library.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Gridfinity bin 2×1
//
// Source: gridfinity-rebuilt (kennetek) — MIT
// https://github.com/kennetek/gridfinity-rebuilt-openscad
// Generated from the library above, used under its license.

include <gridfinity-rebuilt/src/core/standard.scad>
use <gridfinity-rebuilt/src/core/bin.scad>
use <gridfinity-rebuilt/src/core/cutouts.scad>
use <gridfinity-rebuilt/src/core/gridfinity-rebuilt-holes.scad>
use <gridfinity-rebuilt/src/core/gridfinity-rebuilt-utility.scad>
use <gridfinity-rebuilt/src/helpers/generic-helpers.scad>
use <gridfinity-rebuilt/src/helpers/grid.scad>
use <gridfinity-rebuilt/src/helpers/grid_element.scad>

gridx = 2;  // columns
gridy = 1;  // rows
gridz = 6;  // height in 7mm units
divx = 1;  // compartment columns
divy = 1;  // compartment rows

bin1 = new_bin([gridx, gridy], gridz * 7);
bin_render(bin1) {
    bin_subdivide(bin1, [divx, divy]) {
        cut_compartment_auto(cgs(), 5, false, 0);
    }
}
`);

Open in editor →

Gridfinity bin 2×2

A 2×2 Gridfinity storage bin, 6 units tall, one large compartment. Built with the kennetek gridfinity-rebuilt library.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Gridfinity bin 2×2
//
// Source: gridfinity-rebuilt (kennetek) — MIT
// https://github.com/kennetek/gridfinity-rebuilt-openscad
// Generated from the library above, used under its license.

include <gridfinity-rebuilt/src/core/standard.scad>
use <gridfinity-rebuilt/src/core/bin.scad>
use <gridfinity-rebuilt/src/core/cutouts.scad>
use <gridfinity-rebuilt/src/core/gridfinity-rebuilt-holes.scad>
use <gridfinity-rebuilt/src/core/gridfinity-rebuilt-utility.scad>
use <gridfinity-rebuilt/src/helpers/generic-helpers.scad>
use <gridfinity-rebuilt/src/helpers/grid.scad>
use <gridfinity-rebuilt/src/helpers/grid_element.scad>

gridx = 2;  // columns
gridy = 2;  // rows
gridz = 6;  // height in 7mm units
divx = 1;  // compartment columns
divy = 1;  // compartment rows

bin1 = new_bin([gridx, gridy], gridz * 7);
bin_render(bin1) {
    bin_subdivide(bin1, [divx, divy]) {
        cut_compartment_auto(cgs(), 5, false, 0);
    }
}
`);

Open in editor →

Gridfinity bin 2×2 (4 compartments)

A 2×2 Gridfinity bin subdivided into a 2×2 grid of four compartments for small-parts sorting. Built with the kennetek gridfinity-rebuilt library.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Gridfinity bin 2×2 (4 compartments)
//
// Source: gridfinity-rebuilt (kennetek) — MIT
// https://github.com/kennetek/gridfinity-rebuilt-openscad
// Generated from the library above, used under its license.

include <gridfinity-rebuilt/src/core/standard.scad>
use <gridfinity-rebuilt/src/core/bin.scad>
use <gridfinity-rebuilt/src/core/cutouts.scad>
use <gridfinity-rebuilt/src/core/gridfinity-rebuilt-holes.scad>
use <gridfinity-rebuilt/src/core/gridfinity-rebuilt-utility.scad>
use <gridfinity-rebuilt/src/helpers/generic-helpers.scad>
use <gridfinity-rebuilt/src/helpers/grid.scad>
use <gridfinity-rebuilt/src/helpers/grid_element.scad>

gridx = 2;  // columns
gridy = 2;  // rows
gridz = 6;  // height in 7mm units
divx = 2;  // compartment columns
divy = 2;  // compartment rows

bin1 = new_bin([gridx, gridy], gridz * 7);
bin_render(bin1) {
    bin_subdivide(bin1, [divx, divy]) {
        cut_compartment_auto(cgs(), 5, false, 0);
    }
}
`);

Open in editor →

Gridfinity bin 2×1 (label tab)

A 2×1 Gridfinity bin with an auto label tab ledge for a printed or written label. Built with the kennetek gridfinity-rebuilt library.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Gridfinity bin 2×1 (label tab)
//
// Source: gridfinity-rebuilt (kennetek) — MIT
// https://github.com/kennetek/gridfinity-rebuilt-openscad
// Generated from the library above, used under its license.

include <gridfinity-rebuilt/src/core/standard.scad>
use <gridfinity-rebuilt/src/core/bin.scad>
use <gridfinity-rebuilt/src/core/cutouts.scad>
use <gridfinity-rebuilt/src/core/gridfinity-rebuilt-holes.scad>
use <gridfinity-rebuilt/src/core/gridfinity-rebuilt-utility.scad>
use <gridfinity-rebuilt/src/helpers/generic-helpers.scad>
use <gridfinity-rebuilt/src/helpers/grid.scad>
use <gridfinity-rebuilt/src/helpers/grid_element.scad>

gridx = 2;  // columns
gridy = 1;  // rows
gridz = 6;  // height in 7mm units
divx = 1;  // compartment columns
divy = 1;  // compartment rows

bin1 = new_bin([gridx, gridy], gridz * 7);
bin_render(bin1) {
    bin_subdivide(bin1, [divx, divy]) {
        cut_compartment_auto(cgs(), 1, false, 0);
    }
}
`);

Open in editor →

Gridfinity bin 1×2 (scooped)

A 1×2 Gridfinity bin with a curved front scoop that sweeps parts toward your fingers. Built with the kennetek gridfinity-rebuilt library.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Gridfinity bin 1×2 (scooped)
//
// Source: gridfinity-rebuilt (kennetek) — MIT
// https://github.com/kennetek/gridfinity-rebuilt-openscad
// Generated from the library above, used under its license.

include <gridfinity-rebuilt/src/core/standard.scad>
use <gridfinity-rebuilt/src/core/bin.scad>
use <gridfinity-rebuilt/src/core/cutouts.scad>
use <gridfinity-rebuilt/src/core/gridfinity-rebuilt-holes.scad>
use <gridfinity-rebuilt/src/core/gridfinity-rebuilt-utility.scad>
use <gridfinity-rebuilt/src/helpers/generic-helpers.scad>
use <gridfinity-rebuilt/src/helpers/grid.scad>
use <gridfinity-rebuilt/src/helpers/grid_element.scad>

gridx = 1;  // columns
gridy = 2;  // rows
gridz = 6;  // height in 7mm units
divx = 1;  // compartment columns
divy = 1;  // compartment rows

bin1 = new_bin([gridx, gridy], gridz * 7);
bin_render(bin1) {
    bin_subdivide(bin1, [divx, divy]) {
        cut_compartment_auto(cgs(), 5, false, 1);
    }
}
`);

Open in editor →

2D booleans

Shows union(), difference(), and intersection() applied to 2D circles and squares before a single extrude, so you can see each boolean result as a separate printed tile.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// 2D booleans

/* 2D booleans - union / difference / intersection shown as three side-by-side tiles. */
r         = 18;   // circle radius
sq_side   = 28;   // square side length
thickness =  4;   // extrusion thickness
spacing   = 70;   // horizontal gap between tiles
$fn = 48;

// Helper: a circle and a square overlapping at their centres.
// The circle is offset so roughly half of it overlaps the square.
offset_x = sq_side * 0.3;  // how much to shift the circle right

module circle_shape()  { translate([offset_x, 0]) circle(r = r); }
module square_shape()  { translate([-sq_side / 2, -sq_side / 2]) square(sq_side); }

// --- Tile 1: union (all filled area) ---
translate([-spacing, 0, 0])
    linear_extrude(height = thickness)
        union() { circle_shape(); square_shape(); }

// --- Tile 2: difference (square minus circle) ---
translate([0, 0, 0])
    linear_extrude(height = thickness)
        difference() { square_shape(); circle_shape(); }

// --- Tile 3: intersection (only the overlapping region) ---
translate([spacing, 0, 0])
    linear_extrude(height = thickness)
        intersection() { circle_shape(); square_shape(); }
`);

Open in editor →

circle(), square(), polygon()

Lays the three core 2D primitives side by side and extrudes each to a thin slab so the result is a printable 3D object you can examine from every angle.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// circle(), square(), polygon()

/* OpenSCAD 2D primitives are flat - they need linear_extrude()
   to become solid 3D geometry.
   circle(r)  - disc centred at the origin
   square(s)  - rectangle; center=true to straddle the origin
   polygon(p) - arbitrary shape from a list of [x,y] points      */

thick = 4;    // extrusion thickness (mm)
size  = 24;   // nominal size for each shape
gap   = 12;   // spacing between shapes
$fn   = 48;

// Circle - disc of given radius
color("steelblue")
    linear_extrude(height = thick)
        circle(r = size / 2);

// Square - centred so it sits at the same visual baseline as the circle
translate([size + gap, -size / 2, 0])
    color("tomato")
        linear_extrude(height = thick)
            square([size, size]);

// Polygon - a simple arrow-head shape
arrow = [
    [0,  0],
    [size * 0.6,  size / 2],
    [size * 0.3,  size / 2],
    [size * 0.3,  size],
    [-size * 0.3, size],
    [-size * 0.3, size / 2],
    [-size * 0.6, size / 2]
];

translate([(size + gap) * 2, -size / 2, 0])
    color("gold")
        linear_extrude(height = thick)
            polygon(arrow);
`);

Open in editor →

combining booleans

Shows how nesting union() inside difference() builds a simple mounting bracket from basic shapes. A vertical post and horizontal foot are joined first, then a bolt hole and slot are cut out.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// combining booleans

/* Nested boolean example - a simple L-bracket. All dimensions in mm. */
foot_w    = 60;   // foot (horizontal part) width
foot_d    = 20;   // foot depth
foot_h    = 5;    // foot thickness
post_w    = 10;   // post (vertical part) width
post_h    = 50;   // post height
bolt_d    = 5;    // diameter of bolt holes
slot_w    = 6;    // slot width on the post
slot_len  = 20;   // slot length on the post
$fn = 32;

// Step 1: unite the two solid bodies
module bracket_solid() {
    union() {
        // Horizontal foot
        cube([foot_w, foot_d, foot_h]);

        // Vertical post rising from the left end of the foot
        translate([0, 0, foot_h])
            cube([post_w, foot_d, post_h]);
    }
}

// Step 2: subtract holes and a slot from the solid
difference() {
    bracket_solid();

    // Two bolt holes in the foot, evenly spaced
    for (x = [foot_w * 0.25, foot_w * 0.75])
        translate([x, foot_d / 2, -1])
            cylinder(d = bolt_d, h = foot_h + 2);

    // An adjustment slot centred in the post
    translate([post_w / 2, foot_d / 2, foot_h + (post_h - slot_len) / 2])
        rotate([90, 0, 0])
            // Slot = hull of two cylinders
            hull() {
                translate([0,  slot_len / 2 - slot_w / 2, 0]) cylinder(d = slot_w, h = foot_d + 2, center = true);
                translate([0, -slot_len / 2 + slot_w / 2, 0]) cylinder(d = slot_w, h = foot_d + 2, center = true);
            }
}
`);

Open in editor →

children() in a module

Defines a module that places whatever geometry you pass into it at evenly-spaced positions around a ring, using children() and a for loop with rotate().

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// children() in a module

/* children() lets a module receive geometry from its caller,
   just like a function receives arguments.
   The ring_array module below rotates its child N times around Z,
   each time moving it out to a chosen radius first. */

count  = 6;     // number of copies in the ring
radius = 35;    // ring radius (mm)
peg_d  = 8;     // diameter of each peg
peg_h  = 15;    // height of each peg
$fn    = 32;

// Module: arrange children() in a circular ring
module ring_array(n, r) {
    for (i = [0 : n - 1]) {
        angle = 360 / n * i;
        rotate([0, 0, angle])
            translate([r, 0, 0])
                children();
    }
}

// A thin base plate so the pegs have something to stand on
cylinder(h = 3, d = (radius + peg_d) * 2 + 4, $fn = 64);

// Pass a cylinder peg as the child geometry
color("steelblue")
    ring_array(count, radius)
        cylinder(h = peg_h, d = peg_d);
`);

Open in editor →

circle() and square()

Shows the two core 2D primitives - circle() and square() - combined with 2D union and difference to form a rounded-corner key-tag shape, then extruded into a printable part.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// circle() and square()

/* circle() and square() - core 2D shapes, combined then extruded. */
tag_w     = 50;   // key-tag body width
tag_h     = 28;   // key-tag body height
thickness =  4;   // extrusion thickness
hole_r    =  4;   // hang-hole radius
corner_r  =  6;   // rounded corner radius (approximated with circles at hull)
$fn = 48;

// Build the 2D key-tag outline:
//   1. hull() of four corner circles => rounded rectangle body
//   2. union with a circle at the top for the hang-lug
//   3. difference to punch the hang hole
module key_tag_2d() {
    difference() {
        union() {
            // Rounded rectangle body via hull of corner discs
            hull()
                for (x = [corner_r, tag_w - corner_r], y = [corner_r, tag_h - corner_r])
                    translate([x, y]) circle(r = corner_r);
            // Hang lug: a circle centred above the tag
            translate([tag_w / 2, tag_h + hole_r * 1.5])
                circle(r = hole_r * 1.8);
        }
        // Punch the hang hole
        translate([tag_w / 2, tag_h + hole_r * 1.5])
            circle(r = hole_r);
    }
}

// Extrude the finished 2D shape into a solid tag.
linear_extrude(height = thickness)
    key_tag_2d();
`);

Open in editor →

color()

Demonstrates color() with named CSS colors and an RGBA alpha value. Three spheres overlap: two use named colors and the third is translucent so you can see through it.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// color()

/* color() sets the display colour of its child.
   Use a named colour string: "red", "steelblue", "gold", etc.
   Or pass [r, g, b, a] with values from 0 to 1; alpha < 1 = translucent.
   Note: colour is a preview/render hint - it has no effect on STL export. */

r   = 14;   // sphere radius (mm)
$fn = 40;

// Named colour - solid red
color("crimson")
    translate([-r, 0, r])
        sphere(r = r);

// Named colour - solid teal
color("steelblue")
    translate([r, 0, r])
        sphere(r = r);

// RGBA - semi-transparent gold sphere overlapping both
color([1, 0.84, 0, 0.4])
    translate([0, 0, r * 1.8])
        sphere(r = r);
`);

Open in editor →

cube()

Shows the two common forms of cube(): an uncentered one sitting on the origin and a centered one floating above it. Tune size and spacing to explore the difference.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// cube()

/* cube() - uncentered vs centered.
   The uncentered cube grows into +X +Y +Z from the origin.
   With center=true the cube straddles the origin on all three axes. */

side    = 20;   // cube side length (mm)
gap     = 8;    // space between the two cubes
lift    = 30;   // how high the centered cube floats above the floor

// Uncentered cube: corner at origin, fills +X +Y +Z quadrant
cube([side, side, side], center = false);

// Centered cube: placed above so both are visible in the same view
translate([0, 0, lift])
    cube([side, side, side], center = true);
`);

Open in editor →

cylinder() and cones

Shows three forms of cylinder() standing side by side: a plain cylinder, a sharp cone (r2=0), and a truncated cone (r1 not equal r2). Tune the radii and height freely.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// cylinder() and cones

/* cylinder() supports r/d for uniform radius and r1,r2 (or d1,d2)
   for tapered shapes.  r2=0 makes a pointed cone. */

h    = 30;   // height of all three shapes (mm)
r1   = 12;   // base radius
r2   = 6;    // top radius for the truncated cone
gap  = 10;   // spacing between shapes
$fn  = 40;

// Plain cylinder - equal top and bottom radius
translate([-r1 * 2 - gap, 0, 0])
    cylinder(h = h, r = r1);

// Sharp cone - top radius shrinks to zero
cylinder(h = h, r1 = r1, r2 = 0);

// Truncated cone - different radii at each end
translate([r1 * 2 + gap, 0, 0])
    cylinder(h = h, r1 = r1, r2 = r2);
`);

Open in editor →

difference() with a hole pattern

Shows how difference() combined with a for loop removes a grid of holes from a flat plate. Tune the grid spacing and hole size to create your own custom perforation pattern.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// difference() with a hole pattern

/* difference() with a for-loop hole grid. All dimensions in mm. */
plate_w  = 80;   // plate width  (X)
plate_d  = 60;   // plate depth  (Y)
plate_h  = 4;    // plate thickness
margin   = 10;   // clear border around the hole grid
spacing  = 14;   // centre-to-centre distance between holes
hole_d   = 7;    // diameter of each hole
$fn = 32;

difference() {
    // Base plate
    cube([plate_w, plate_d, plate_h]);

    // Grid of holes: for loops generate a list of children for difference()
    for (x = [margin : spacing : plate_w - margin],
         y = [margin : spacing : plate_d - margin])
        translate([x, y, -1])
            cylinder(d = hole_d, h = plate_h + 2);
}
`);

Open in editor →

difference()

Shows how difference() carves one shape out of another. A cylinder is subtracted from a solid cube to create a round through-hole - the foundation of almost every functional part.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// difference()

/* difference() example - subtracting a cylinder from a cube. All dimensions in mm. */
box_w    = 50;   // cube width (X)
box_d    = 50;   // cube depth (Y)
box_h    = 20;   // cube height (Z)
hole_d   = 18;   // diameter of the hole
wall_min = 5;    // minimum wall thickness around the hole (informational)
$fn = 48;

// difference(): the FIRST child is the base solid;
// all remaining children are subtracted from it.
difference() {
    // Base solid - a plain cube
    cube([box_w, box_d, box_h]);

    // The cylinder to remove - centred in XY, reaching full depth (+1 mm each end avoids z-fighting)
    translate([box_w / 2, box_d / 2, -1])
        cylinder(d = hole_d, h = box_h + 2);
}
`);

Open in editor →

extrude a computed polygon

Shows how a list comprehension builds the [x, y] points for a wavy disc outline, which polygon() then assembles and linear_extrude() lifts into a printable coaster or badge.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// extrude a computed polygon

/* Computed polygon via list comprehension - wavy disc coaster or badge. */
base_r   = 35;   // average radius of the disc
waves    = 12;   // number of wave peaks around the edge
wave_amp =  5;   // amplitude of each wave (mm)
height   =  4;   // extrusion height
steps    = 120;  // polygon resolution (points around the circle)
$fn = 64;

// List comprehension builds one [x, y] point per step.
// The radius oscillates between (base_r - wave_amp) and (base_r + wave_amp).
wavy_pts = [
    for (i = [0 : steps - 1])
        let(
            angle = 360 * i / steps,
            r     = base_r + wave_amp * sin(waves * angle)
        )
        [r * cos(angle), r * sin(angle)]
];

// polygon() accepts our computed points directly.
linear_extrude(height = height)
    polygon(points = wavy_pts);
`);

Open in editor →

$fn, $fa, $fs

Shows three cylinders of the same size rendered with different facet controls - coarse explicit $fn, fine explicit $fn, and angle-driven $fa - so you can see exactly how each setting shapes round geometry.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// $fn, $fa, $fs

/* OpenSCAD uses three special variables to control curve resolution:
     $fn - fixed segment count (overrides $fa and $fs when > 0)
     $fa - minimum angle per segment in degrees (default 12)
     $fs - minimum segment length in mm (default 2)
   When $fn = 0 OpenSCAD picks the segment count from $fa and $fs.
   A larger $fn or smaller $fa/$fs = smoother curves = slower render. */

d  = 30;   // cylinder diameter (mm)
h  = 20;   // cylinder height (mm)
sp = 50;   // spacing between cylinders

// Coarse: only 6 segments - very angular, renders instantly
color("tomato")
    cylinder(h = h, d = d, $fn = 6);

// Fine: 48 segments - nearly smooth, good for most prints
translate([sp, 0, 0])
    color("steelblue")
        cylinder(h = h, d = d, $fn = 48);

// Auto from $fa: 10 degrees per segment = 36 segments for a full circle
// ($fs = 1 keeps the segment limit from kicking in for this diameter)
translate([sp * 2, 0, 0])
    color("gold")
        cylinder(h = h, d = d, $fn = 0, $fa = 10, $fs = 1);
`);

Open in editor →

for loop

A row of cylindrical pillars that grow taller from left to right, showing how a for loop iterates over a range and how loop variable drives both position and size.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// for loop

/* A row of pillars of increasing height - demonstrating the for loop.
   Each pillar index i controls both the x position and the height.
   Great first example for anyone learning parametric loops. */

pillar_count  = 8;      // number of pillars in the row
pillar_d      = 8;      // pillar diameter (mm)
spacing       = 14;     // centre-to-centre spacing (mm)
min_height    = 10;     // shortest pillar height (mm)
height_step   = 8;      // how much taller each successive pillar gets (mm)
$fn = 32;

for (i = [0 : pillar_count - 1]) {
    h = min_height + i * height_step;   // height grows with each step
    translate([i * spacing, 0, 0])
        cylinder(d = pillar_d, h = h);
}
`);

Open in editor →

for + rotate ring

A ring of evenly spaced round pegs arranged in a circle using a for loop combined with rotate. Tune the number of pegs, ring radius, and peg size to explore radial symmetry.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// for + rotate ring

/* Ring of pegs - demonstrating for + rotate to place objects in a circle.
   The loop variable a is the angle step, derived from the total peg count.
   Rotating a translated peg sweeps it around the origin. */

peg_count  = 10;   // how many pegs in the ring
ring_r     = 30;   // radius from centre to peg centre (mm)
peg_d      = 7;    // peg diameter (mm)
peg_h      = 18;   // peg height (mm)
base_h     = 3;    // thin base disk height (mm)
base_d     = ring_r * 2 + peg_d + 4;  // base diameter sized to hold all pegs
$fn = 40;

// flat base disk so the part is printable without support
cylinder(d = base_d, h = base_h);

// place one peg per iteration, rotating it around the Z axis
for (a = [0 : 360 / peg_count : 359]) {
    rotate([0, 0, a])
        translate([ring_r, 0, base_h])
            cylinder(d = peg_d, h = peg_h);
}
`);

Open in editor →

defining a function

A decorative arch whose keystone positions are computed by a user-defined function that evaluates a parametric circle. Shows how functions return values that drive geometry, keeping the math out of the module calls.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// defining a function

/* Arch with mathematically placed keystones - demonstrating user functions.
   arch_pt(angle, r) returns [x, y] on a circle of radius r.
   The for loop calls it to position each voussoir (arch block) correctly. */

arch_r      = 40;    // arch inner radius (mm)
arch_thick  = 10;    // radial thickness of each keystone block (mm)
block_span  = 22;    // angular span of each block (degrees)
num_blocks  = 7;     // number of arch keystones (use an odd number for symmetry)
extrude_d   = 8;     // depth of the arch (mm)
$fn = 48;

// user function: a point on a circle of radius r at the given angle (degrees)
function arch_pt(angle, r) = [r * cos(angle), r * sin(angle)];

// place each keystone as a hull between two arc segments
for (i = [0 : num_blocks - 1]) {
    // centre angle of this block, spread across 180 degrees
    a_mid = 180 * (i + 0.5) / num_blocks;
    a0    = a_mid - block_span / 2;
    a1    = a_mid + block_span / 2;

    inner = arch_r;
    outer = arch_r + arch_thick;

    linear_extrude(height = extrude_d)
        polygon([
            arch_pt(a0, inner),
            arch_pt(a1, inner),
            arch_pt(a1, outer),
            arch_pt(a0, outer)
        ]);
}

// two rectangular piers at the base
translate([-arch_r - arch_thick, -arch_thick * 1.5, 0])
    cube([arch_thick, arch_thick * 1.5, extrude_d]);
translate([arch_r, -arch_thick * 1.5, 0])
    cube([arch_thick, arch_thick * 1.5, extrude_d]);
`);

Open in editor →

hull() in 2D

Shows how hull() wraps a convex skin around a set of 2D circles to create a smooth rounded slot outline. The result is extruded into a printable plate with a slotted hole.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// hull() in 2D

/* hull() in 2D - rounded slot plate. All dimensions in mm. */
plate_w    = 80;   // plate overall width
plate_d    = 50;   // plate overall depth
plate_h    = 4;    // plate thickness
slot_len   = 40;   // centre-to-centre length of the slot
slot_r     = 6;    // slot end radius (half the slot width)
corner_r   = 4;    // plate corner rounding radius
$fn = 48;

module rounded_plate(w, d, h, r) {
    // A plate with rounded corners using hull() around four corner cylinders
    linear_extrude(h)
        hull() for (x = [r, w - r], y = [r, d - r])
            translate([x, y]) circle(r = r);
}

module slot_2d(len, r) {
    // A rounded slot: hull() of two circles gives a stadium / discorectangle
    hull() {
        translate([-len / 2, 0]) circle(r = r);
        translate([ len / 2, 0]) circle(r = r);
    }
}

difference() {
    rounded_plate(plate_w, plate_d, plate_h, corner_r);

    // Slot centred in the plate, punched through with +1 mm clearance
    translate([plate_w / 2, plate_d / 2, -1])
        linear_extrude(plate_h + 2)
            slot_2d(slot_len, slot_r);
}
`);

Open in editor →

hull() in 3D

Shows how hull() wraps a convex skin around spheres placed at the corners of a box to produce a solid with smoothly rounded edges and corners. Tune the box size and corner radius freely.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// hull() in 3D

/* hull() in 3D - a box with fully rounded corners and edges. All dimensions in mm. */
box_w  = 60;   // outer width  (X)
box_d  = 40;   // outer depth  (Y)
box_h  = 25;   // outer height (Z)
r      = 5;    // corner sphere radius (determines how round the edges are)
$fn = 40;

// Place one sphere at each of the 8 corners of the (r-inset) bounding box.
// hull() wraps them all - the result is a box where every edge and corner
// is a smooth arc of radius r.
hull() for (x = [r, box_w - r], y = [r, box_d - r], z = [r, box_h - r])
    translate([x, y, z]) sphere(r = r);
`);

Open in editor →

intersection_for()

A faceted gem-like solid created by intersecting several rotated slabs using intersection_for(). Each iteration rotates a flat slab by an equal angle step, and the intersection keeps only the shared core.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// intersection_for()

/* Faceted gem via intersection_for() - each rotated slab clips the result.
   intersection_for() is like a for loop but AND-s every child together
   instead of union-ing them, producing the overlapping core region. */

slab_count = 7;     // number of rotated slabs (more = rounder gem)
slab_w     = 50;    // slab width (mm)
slab_d     = 50;    // slab depth (mm)
slab_h     = 14;    // slab thickness - controls how "tall" the gem is (mm)
$fn = 32;

intersection_for (i = [0 : slab_count - 1]) {
    angle = i * (180 / slab_count);   // spread slabs evenly through 180 degrees
    rotate([0, angle, 0])
        cube([slab_w, slab_d, slab_h], center = true);
}
`);

Open in editor →

intersection()

Shows how intersection() keeps only the volume shared by all children. A cube and a sphere overlap to produce a rounded cube-corner gem shape - great for learning Boolean logic.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// intersection()

/* intersection() example - only the shared volume survives. All dimensions in mm. */
cube_size  = 45;   // side length of the cube
sphere_d   = 55;   // diameter of the sphere (should be larger than cube for a visible effect)
$fn = 64;

// intersection() keeps only geometry that is INSIDE every child at once.
// The result here is a cube with every face pushed inward by the sphere surface.
intersection() {
    // A centred cube
    translate([-cube_size / 2, -cube_size / 2, -cube_size / 2])
        cube([cube_size, cube_size, cube_size]);

    // A sphere centred at the same origin - rounds all eight corners of the cube
    sphere(d = sphere_d);
}
`);

Open in editor →

let() and assignment

A set of nested hexagonal tiles whose size and position are computed with let() expressions, showing how to name intermediate values inside a comprehension without polluting the outer scope.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// let() and assignment

/* Hexagonal tile grid using let() to name intermediate values.
   let(var = expr, ...) inside a list comprehension keeps each calculation
   readable and avoids repeating the same sub-expression multiple times. */

tile_count  = 4;     // tiles per row and column
hex_r       = 10;    // hexagon circumradius (mm)
gap         = 2;     // gap between tiles (mm)
tile_h      = 3;     // extrude height of each tile (mm)
$fn = 6;             // 6 sides makes cylinder() a hexagonal prism

// generate [x, y, scale] for each tile using let() inside the comprehension
tiles = [
    for (c = [0 : tile_count - 1], r = [0 : tile_count - 1])
        let(
            col_offset = (r % 2 == 0) ? 0 : hex_r * 0.866,   // offset odd rows for hex packing
            x          = c * (hex_r * 1.732 + gap) + col_offset,
            y          = r * (hex_r * 1.5   + gap),
            scale_f    = 0.7 + 0.3 * ((c + r) % 3) / 2       // vary size for visual interest
        )
        [x, y, scale_f]
];

// place a hexagonal prism at each computed position
for (t = tiles) {
    translate([t[0], t[1], 0])
        cylinder(r = hex_r * t[2], h = tile_h);
}
`);

Open in editor →

linear_extrude(scale=)

Shows how scale= in linear_extrude() shrinks the cross-section as it rises, turning a hexagonal base into a tapered obelisk. Tune base size, height, and tip scale.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// linear_extrude(scale=)

/* linear_extrude(scale=) - shrinks (or grows) the cross-section from bottom to top. */
base_r   = 28;   // circumradius of the hexagonal base
height   = 50;   // total height of the obelisk
tip_scale = 0.1; // fraction of the base size at the very top (0.0 = true point)
sides    = 6;    // number of polygon sides
$fn = 64;

// A regular polygon at the base.
module base_profile(r, n) {
    circle(r = r, $fn = n);
}

// Extrude with scale - the cross-section tapers to tip_scale * original at the top.
linear_extrude(
    height = height,
    scale  = tip_scale   // key parameter: shrink top to a near-point
)
    base_profile(base_r, sides);
`);

Open in editor →

linear_extrude(twist=)

Shows how adding a twist= angle to linear_extrude() spirals a square profile into a decorative twisted column. Adjust height, twist degrees, and profile size.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// linear_extrude(twist=)

/* linear_extrude(twist=) - rotates the cross-section as it rises to create a spiral. */
col_size  = 16;   // side length of the square cross-section
col_height = 60;  // total column height
twist_deg = 120;  // total twist in degrees over the height
taper     = 0.85; // slight width reduction at top (scale factor)
$fn = 48;

// A square with notched corners for a more interesting silhouette.
module cross_section(s) {
    r = s * 0.12; // small corner radius expressed as square fraction
    offset(r = r) offset(r = -r)
        square([s, s], center = true);
}

// linear_extrude with twist - the teaching moment.
linear_extrude(
    height = col_height,
    twist  = twist_deg,
    slices = 60,          // more slices = smoother spiral
    scale  = taper
)
    cross_section(col_size);
`);

Open in editor →

linear_extrude()

Shows how linear_extrude() lifts a flat 2D star polygon straight up into a 3D prism. Tune the star size, point count, and height.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// linear_extrude()

/* linear_extrude() - turns a 2D polygon into a 3D solid by pulling it upward. */
outer_r  = 30;   // outer tip radius of the star
inner_r  = 14;   // inner notch radius
points_n = 6;    // number of star points
height   = 20;   // extrusion height
$fn = 64;

// Build the star outline as a polygon from alternating outer/inner vertices.
module star2d(n, ro, ri) {
    step = 360 / n;
    pts = [
        for (i = [0 : n - 1])
            for (pt = [
                [ro * cos(i * step),          ro * sin(i * step)],
                [ri * cos(i * step + step/2), ri * sin(i * step + step/2)]
            ]) pt
    ];
    polygon(pts);
}

// Extrude the star upward - this is the key call being taught.
linear_extrude(height = height)
    star2d(points_n, outer_r, inner_r);
`);

Open in editor →

list comprehension with condition

A sparse grid of pillars where each pillar is placed only when a mathematical condition holds, built with a list comprehension containing an if filter. Shows how to selectively include items in a generated list.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// list comprehension with condition

/* Sparse pillar grid using a list comprehension with an if condition.
   The comprehension produces only the [x, y] positions where the
   sum of grid indices is NOT divisible by 3, giving a pattern with gaps. */

cols     = 7;    // columns in the grid
rows     = 7;    // rows in the grid
spacing  = 14;   // centre-to-centre spacing (mm)
pillar_d = 7;    // pillar diameter (mm)
pillar_h = 20;   // pillar height (mm)
$fn = 24;

// build a list of [x, y] positions satisfying the condition
positions = [
    for (c = [0 : cols - 1], r = [0 : rows - 1])
        if ((c + r) % 3 != 0)        // skip every position where c+r is a multiple of 3
            [c * spacing, r * spacing]
];

// place a pillar at each position in the filtered list
for (pos = positions)
    translate([pos[0], pos[1], 0])
        cylinder(d = pillar_d, h = pillar_h);
`);

Open in editor →

list comprehension

A smooth wave-profile wall built by generating polygon outline points with a list comprehension and then extruding the result. Shows how to build point arrays mathematically rather than typing each coordinate by hand.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// list comprehension

/* Wave-profile wall - demonstrating list comprehension to generate polygon points.
   A list comprehension [ for (var = range) expression ] builds the point list
   for a sine wave cross-section, which is then swept with linear_extrude. */

steps      = 60;    // number of polygon segments (more = smoother wave)
wave_w     = 80;    // total width of one wave cycle (mm)
amplitude  = 8;     // wave peak-to-trough half-height (mm)
mid_h      = 20;    // centre height of the wave profile (mm)
wall_thick = 4;     // wall depth (extrude distance, mm)

// build the closed polygon outline: top wave then bottom straight edge
wave_pts = [
    // top edge: sine wave from left to right
    for (i = [0 : steps])
        [i * wave_w / steps,
         mid_h + amplitude * sin(i * 360 / steps)],
    // bottom-right and bottom-left corners to close the shape
    [wave_w, 0],
    [0,      0]
];

linear_extrude(height = wall_thick)
    polygon(wave_pts);
`);

Open in editor →

minkowski() in 2D

Shows how minkowski() of a 2D square with a circle inflates and rounds the outline uniformly. The resulting smooth 2D profile is extruded into a thick printable pad with softened edges.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// minkowski() in 2D

/* minkowski() in 2D - a rounded rectangle profile extruded into a pad. All dimensions in mm. */
sq_w  = 50;   // inner rectangle width  (final outer = sq_w + 2*r)
sq_d  = 30;   // inner rectangle depth
r     = 6;    // fillet radius - the circle radius used in minkowski
pad_h = 8;    // extrusion height of the finished pad
$fn = 48;

// minkowski() in 2D: sweeping a square through a circle inflates every edge outward
// by r and turns every sharp corner into a circular arc - identical to offset(r=r)
// but expressed as a Minkowski sum, which generalises to non-circular sweepers.
linear_extrude(height = pad_h)
    minkowski() {
        square([sq_w, sq_d]);   // base 2D shape
        circle(r = r);          // circle adds the rounded offset
    }
`);

Open in editor →

minkowski() rounding

Shows how minkowski() of a box with a small sphere rounds every edge and corner simultaneously. The technique generalises to any shape. Note that the overall size grows by the sphere radius on each side.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// minkowski() rounding

/* minkowski() rounding - a box with all edges and corners rounded. All dimensions in mm. */
box_w  = 50;   // inner box width  before rounding (final = box_w + 2*r)
box_d  = 35;   // inner box depth  before rounding
box_h  = 20;   // inner box height before rounding
r      = 4;    // rounding radius applied to ALL edges and corners
$fn = 32;

// minkowski() sweeps every point of the first child through every point of the second.
// A box swept through a sphere produces a box whose corners become spherical and
// whose edges become cylindrical - a perfect all-direction fillet.
minkowski() {
    cube([box_w, box_d, box_h]);   // base shape (un-rounded)
    sphere(r = r);                 // rounding element - radius = fillet size
}
`);

Open in editor →

mirror()

Creates an asymmetric L-shaped bracket and then reflects it across the Y-Z plane using mirror(), producing a matching left-hand part from a single definition.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// mirror()

/* mirror([nx, ny, nz]) reflects geometry through the plane whose
   normal is [nx, ny, nz].  mirror([1,0,0]) reflects across the Y-Z
   plane, turning a right-hand part into a left-hand part. */

thick  = 5;    // material thickness (mm)
foot_w = 30;   // horizontal leg length
foot_h = 8;    // horizontal leg height
wall_h = 25;   // vertical leg height
gap    = 6;    // gap between original and mirrored copy

// Helper module - asymmetric L-bracket
module l_bracket() {
    // Horizontal foot
    cube([foot_w, thick, foot_h]);
    // Vertical wall at the left end of the foot
    cube([thick, thick, wall_h]);
}

// Original bracket
color("steelblue")
    l_bracket();

// Mirrored bracket - reflected across X=0 plane, then shifted right
translate([gap, 0, 0])
    color("tomato")
        mirror([1, 0, 0])
            l_bracket();
`);

Open in editor →

defining a module

A parametric rounded peg module defined once and called multiple times with different sizes. Shows how modules encapsulate reusable geometry so you can place many variations without repeating code.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// defining a module

/* Rounded peg module - demonstrating module definition and reuse.
   The module takes diameter, height, and tip-rounding as parameters.
   Calling it several times with different values shows why modules matter. */

$fn = 40;

// --- module definition ---
module rounded_peg(d, h, tip_r = 2) {
    // cylindrical body
    cylinder(d = d, h = h - tip_r);
    // rounded dome on top
    translate([0, 0, h - tip_r])
        sphere(r = d / 2);
}

// --- place several pegs in a row with varying dimensions ---
rounded_peg(d = 8,  h = 20, tip_r = 4);

translate([14, 0, 0])
    rounded_peg(d = 10, h = 30, tip_r = 5);

translate([28, 0, 0])
    rounded_peg(d = 12, h = 15, tip_r = 3);

translate([46, 0, 0])
    rounded_peg(d = 6,  h = 25, tip_r = 3);
`);

Open in editor →

module default args

A shelf bracket module with sensible default dimensions so it works with no arguments at all, but can be customised with named-argument calls. Demonstrates how default values reduce boilerplate and how named arguments improve readability.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// module default args

/* Shelf bracket with default arguments - demonstrating named-argument calls.
   Call bracket() for a standard bracket, or override any individual
   dimension by name, e.g. bracket(arm = 60, thick = 4). */

module bracket(arm = 50, rise = 40, thick = 3, gusset = true) {
    // horizontal arm
    cube([arm, thick, thick]);
    // vertical rise
    cube([thick, thick, rise]);
    // diagonal gusset (only when requested)
    if (gusset) {
        rotate([0, 0, 0])
        translate([thick, 0, thick])
            rotate([0, 45, 0])
                cube([rise * 0.7, thick, thick]);
    }
}

// call with all defaults
bracket();

// call with a named override - longer arm, no gusset
translate([0, 20, 0])
    bracket(arm = 70, gusset = false);

// call with several named overrides
translate([0, 40, 0])
    bracket(arm = 40, rise = 30, thick = 5, gusset = true);
`);

Open in editor →

multmatrix() shear

Uses multmatrix() to apply a shear transform to a cube, leaning its top face in the X direction - a distortion that cannot be achieved with rotate() or scale() alone.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// multmatrix() shear

/* multmatrix(m) applies a full 4x4 homogeneous matrix to its child.
   This unlocks shear, which tilts one axis relative to another.
   The matrix below shears X by a fraction of Z:
     X' = X + shear * Z,  Y' = Y,  Z' = Z
   So the top face slides sideways while the base stays put. */

side  = 20;   // cube side length (mm)
shear = 0.5;  // how many mm of X shift per mm of Z height

// Shear matrix: identity with shear coefficient in row 0, col 2
shear_matrix = [
    [1, 0, shear, 0],
    [0, 1, 0,     0],
    [0, 0, 1,     0],
    [0, 0, 0,     1]
];

// Reference cube - no transform
color("silver")
    cube([side, side, side]);

// Sheared cube placed to the right so both are visible
translate([side * 2, 0, 0])
    color("steelblue")
        multmatrix(shear_matrix)
            cube([side, side, side]);
`);

Open in editor →

nested for

A checkerboard grid of short square pillars built with two nested for loops, one for columns and one for rows. Shows how to iterate over two axes at once and skip alternating cells.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// nested for

/* Checkerboard grid of pillars - demonstrating nested for loops.
   The outer loop walks columns (x), the inner loop walks rows (y).
   A modulo test skips every other cell to create the checkerboard pattern. */

cols     = 6;    // number of columns
rows     = 6;    // number of rows
cell     = 14;   // grid cell size (mm)
pillar_w = 9;    // pillar side length (mm)
pillar_h = 12;   // pillar height (mm)

for (c = [0 : cols - 1]) {
    for (r = [0 : rows - 1]) {
        // place a pillar only on "white" squares of the checkerboard
        if ((c + r) % 2 == 0) {
            translate([c * cell, r * cell, 0])
                cube([pillar_w, pillar_w, pillar_h]);
        }
    }
}
`);

Open in editor →

offset() delta + chamfer

Shows how offset(delta=, chamfer=true) shifts a 2D outline by a fixed amount and adds sharp 45-degree chamfers at corners instead of arcs. An outer and inset shell are stacked to show the contrast.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// offset() delta + chamfer

/* offset(delta=, chamfer=) - sharp inset and outset chamfered outlines. All dimensions in mm. */
base_w  = 60;   // base rectangle width
base_d  = 45;   // base rectangle depth
delta   = 5;    // offset amount (positive = outward, negative = inward)
h_outer = 6;    // height of outer extruded ring
h_inner = 10;   // height of inner extruded post
$fn = 32;

module base_2d() {
    // A simple rectangle - the shape we will offset
    square([base_w, base_d]);
}

// --- Outer chamfered ring ---
// offset(delta=+d, chamfer=true) grows the outline and chamfers convex corners at 45 deg.
// Subtracting the original leaves only the chamfered border ring.
linear_extrude(height = h_outer)
    difference() {
        offset(delta = delta, chamfer = true) base_2d();
        base_2d();
    }

// --- Inner chamfered post ---
// offset(delta=-d, chamfer=true) shrinks the outline inward with chamfered corners.
translate([0, 0, h_outer])
    linear_extrude(height = h_inner)
        offset(delta = -delta, chamfer = true) base_2d();
`);

Open in editor →

offset() rounded

Shows how offset(r=) inflates a 2D polygon outward and smoothly rounds every concave and convex corner. An L-shaped profile is offset then extruded into a printable bracket tile.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// offset() rounded

/* offset(r=) rounding - an L-shape inflated with smooth corners. All dimensions in mm. */
arm_w  = 12;   // width of each arm of the L
arm_l  = 40;   // length of each arm
r      = 4;    // rounding radius (positive = outward + rounded corners)
h      = 6;    // extrusion height
$fn = 48;

// The raw L-shape as a polygon (two rectangles forming an L)
module l_shape_2d(aw, al) {
    polygon([
        [0,  0],
        [al, 0],
        [al, aw],
        [aw, aw],
        [aw, al],
        [0,  al]
    ]);
}

// offset(r=) with a positive radius rounds ALL corners (concave ones become fillets,
// convex ones become circular arcs) and inflates the outline by r.
linear_extrude(height = h)
    offset(r = r)
        l_shape_2d(arm_w, arm_l);
`);

Open in editor →

polygon() from points

Shows how polygon() takes an explicit list of [x, y] points to define any custom shape - here a bold right-pointing arrow - then extrudes it into a printable marker.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// polygon() from points

/* polygon() with explicit points - a bold arrow head extruded into a flat marker. */
arrow_w   = 60;   // total width (left edge to arrow tip)
arrow_h   = 40;   // total height (top to bottom of the shaft + head)
shaft_h   = 16;   // height of the rectangular shaft
head_inset = 20;  // how far the arrowhead base is from the left edge
thickness  =  5;  // extrusion depth

// Explicit point list that traces the arrow outline counter-clockwise.
// The shape: a rectangle shaft on the left + a triangle head on the right.
arrow_pts = [
    [0,           (arrow_h - shaft_h) / 2],          // shaft bottom-left
    [head_inset,  (arrow_h - shaft_h) / 2],          // shaft bottom-right / head base-lower
    [head_inset,  0],                                 // head bottom corner
    [arrow_w,     arrow_h / 2],                       // arrow tip
    [head_inset,  arrow_h],                           // head top corner
    [head_inset,  (arrow_h + shaft_h) / 2],           // head base-upper
    [0,           (arrow_h + shaft_h) / 2]            // shaft top-left
];

// polygon() - the focus of this recipe.
linear_extrude(height = thickness)
    polygon(points = arrow_pts);
`);

Open in editor →

polyhedron()

Builds a square pyramid by hand using polyhedron() with a list of 5 corner points and 5 faces. A great introduction to defining arbitrary closed solids vertex by vertex.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// polyhedron()

/* polyhedron() - square pyramid from scratch.
   Points are listed as [x, y, z] coordinates.
   Each face is a list of point indices ordered so the outward
   normal follows the right-hand rule (counter-clockwise when
   viewed from outside). */

base = 30;   // square base side length (mm)
apex = 25;   // pyramid height (mm)

half = base / 2;

// 5 vertices: 4 base corners + 1 apex
pts = [
    [-half, -half, 0],   // 0 - front-left
    [ half, -half, 0],   // 1 - front-right
    [ half,  half, 0],   // 2 - back-right
    [-half,  half, 0],   // 3 - back-left
    [    0,     0, apex] // 4 - apex
];

// 5 faces: 1 square base (split into 2 triangles) + 4 triangular sides
faces = [
    [0, 3, 2, 1],   // base (winding viewed from below)
    [0, 1, 4],      // front face
    [1, 2, 4],      // right face
    [2, 3, 4],      // back face
    [3, 0, 4]       // left face
];

polyhedron(points = pts, faces = faces);
`);

Open in editor →

projection()

Shows how projection() collapses a 3D object down to a flat 2D silhouette in the XY plane, which can then be re-extruded into a thin shadow-stamp. Tune the source shape and stamp thickness.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// projection()

/* projection() - flatten a 3D solid to a 2D outline, then re-extrude as a stamp. */
stamp_thickness = 2.5;  // how thick the re-extruded stamp plate is
cone_r   = 20;          // base radius of the source cone
cone_h   = 30;          // height of the source cone
$fn = 48;

// The 3D shape whose silhouette we want.
// We use it only as input to projection(); it is NOT rendered itself.
module source_shape() {
    // A cone with a small sphere on top - interesting shadow outline.
    cylinder(h = cone_h, r1 = cone_r, r2 = 4);
    translate([0, 0, cone_h]) sphere(r = 6);
}

// projection(cut = false) casts a shadow of the 3D shape down onto Z = 0.
// linear_extrude then lifts that 2D footprint into a flat stamp.
linear_extrude(height = stamp_thickness)
    projection(cut = false)   // false = true silhouette (not a cross-section cut)
        source_shape();
`);

Open in editor →

ranges [a:step:b]

A staircase of rectangular steps generated with a stepped range loop. Each iteration advances by the step size in both height and depth, showing how the three-argument range controls spacing between loop values.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// ranges [a:step:b]

/* Staircase built with a stepped range - demonstrating [start : step : end].
   The loop variable z also drives the y position so each step sits on top
   of the previous one, forming a proper rising stair. */

step_count  = 8;     // total number of steps
step_rise   = 10;    // vertical rise per step (mm)
step_run    = 15;    // horizontal depth per step (mm)
step_width  = 40;    // width of the staircase (mm)

// [0 : step_rise : (step_count-1)*step_rise] steps by step_rise each iteration
for (z = [0 : step_rise : (step_count - 1) * step_rise]) {
    step_index = z / step_rise;           // which step number we are on
    translate([0, step_index * step_run, 0])
        cube([step_width, step_run, z + step_rise]);
}
`);

Open in editor →

recursive module

A branching fractal tree built with a recursive module. Each call draws one branch segment, then calls itself twice at a smaller scale and angle. The 2D tree outline is extruded to a thin slab so it is printable.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// recursive module

/* Branching tree - demonstrating a recursive module.
   branch() calls itself twice with smaller dimensions and opposite angles,
   stopping when the branch becomes shorter than min_len.
   A 2D shape is built and then extruded once at the top level. */

trunk_len   = 30;    // length of the main trunk (mm)
trunk_w     = 5;     // width of the main trunk (mm)
depth       = 3;     // extrude depth for the printable plaque (mm)
split_angle = 28;    // angle each child branch fans outward (degrees)
shrink      = 0.65;  // child branch length as a fraction of parent length
min_len     = 4;     // stop recursing when branch length drops below this (mm)

// 2D recursive branch - uses square() so it works inside linear_extrude
module branch2d(len, w) {
    square([w, len]);
    if (len * shrink > min_len) {
        child_len = len * shrink;
        child_w   = max(1, w * shrink);
        // left child
        translate([w / 2, len, 0])
            rotate(split_angle)
                translate([-child_w / 2, 0, 0])
                    branch2d(child_len, child_w);
        // right child
        translate([w / 2, len, 0])
            rotate(-split_angle)
                translate([-child_w / 2, 0, 0])
                    branch2d(child_len, child_w);
    }
}

linear_extrude(height = depth)
    translate([-trunk_w / 2, 0])
        branch2d(trunk_len, trunk_w);
`);

Open in editor →

#, %, ! modifiers note

Demonstrates a solid composed part (a box with a lid) alongside a semi-transparent reference bounding volume drawn with the % modifier. The final render is always the solid geometry only.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// #, %, ! modifiers note

/* Modifier demo - % shows a ghost reference box; the real model renders solid.
   OpenSCAD modifiers:
     %  background (grey ghost, not in final render or export)
     #  highlight   (shown in pink, IS included in geometry)
     !  root        (render ONLY this child, ignoring everything else)
     *  disable     (ignore this child entirely)
   Only % is used here so the part stays clean and printable.
   All dimensions in mm. */
box_w   = 50;   // main box width
box_d   = 35;   // main box depth
box_h   = 30;   // main box height
wall    = 2.5;  // wall thickness
lid_h   = 8;    // lid height
gap     = 0.3;  // clearance between box lip and lid
$fn = 32;

// --- Hollow box body ---
module box_body() {
    difference() {
        cube([box_w, box_d, box_h]);
        translate([wall, wall, wall])
            cube([box_w - 2*wall, box_d - 2*wall, box_h]);  // open top
    }
}

// --- Snap-fit lid ---
module lid() {
    difference() {
        cube([box_w, box_d, lid_h]);
        // Inner pocket that drops over the box lip
        translate([wall + gap, wall + gap, wall])
            cube([box_w - 2*(wall+gap), box_d - 2*(wall+gap), lid_h]);
    }
}

// Real geometry - box body and lid sitting side by side
box_body();
translate([box_w + 10, 0, 0]) lid();

// % ghost - a transparent bounding envelope showing the assembled footprint.
// This is NOT exported or printed; it is a visual reference only.
%translate([-2, -2, 0])
    cube([box_w * 2 + 10 + 4, box_d + 4, box_h + 4]);
`);

Open in editor →

rotate_extrude(angle=)

Shows how the angle= parameter stops a rotate_extrude() part-way around, creating a C-shaped arc solid. Adjust the sweep angle and cross-section to explore partial revolves.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// rotate_extrude(angle=)

/* rotate_extrude(angle=) - partial revolution; here a 270-degree C-channel arc. */
sweep_angle = 270;  // degrees of revolution (try 180 for a half-pipe, 360 for a full ring)
ring_r      = 22;   // distance from Z axis to cross-section centre
cs_w        = 9;    // cross-section width (radial direction)
cs_h        = 12;   // cross-section height (axial direction)
$fn = 64;

// L-shaped channel cross-section - gives the arc structural interest.
module channel_profile() {
    wall = 2.0; // channel wall thickness
    translate([ring_r - cs_w / 2, -cs_h / 2, 0]) {
        // outer rectangle
        square([cs_w, cs_h]);
        // subtract the inner hollow to make a U-channel
        translate([wall, wall, 0])
            square([cs_w - wall, cs_h - wall]);
    }
}

// Partial rotate_extrude - angle= is the feature being demonstrated.
rotate_extrude(angle = sweep_angle, $fn = 64)
    difference() {
        translate([ring_r - cs_w / 2, -cs_h / 2, 0]) square([cs_w, cs_h]);
        translate([ring_r - cs_w / 2 + 2, -cs_h / 2 + 2, 0]) square([cs_w - 2, cs_h - 2]);
    }
`);

Open in editor →

rotate_extrude()

Shows how rotate_extrude() sweeps a 2D profile all the way around the Z axis to make a solid of revolution - here a chunky ring with a D-shaped cross-section.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// rotate_extrude()

/* rotate_extrude() - revolves a 2D profile 360 degrees around the Z axis. */
ring_r    = 24;  // distance from Z axis to centre of the cross-section
cs_width  = 10;  // cross-section width (radial)
cs_height = 14;  // cross-section height (axial)
corner_r  = 3;   // rounding on the cross-section corners
$fn = 64;

// A rounded rectangle cross-section sitting to the right of the Z axis.
// Important: every point of the profile must have x >= 0 for rotate_extrude.
module cross_section() {
    translate([ring_r - cs_width / 2, -cs_height / 2, 0])
        offset(r = corner_r) offset(r = -corner_r)
            square([cs_width, cs_height]);
}

// rotate_extrude sweeps the profile all the way around - the key call.
rotate_extrude($fn = 64)
    cross_section();
`);

Open in editor →

rotate()

Shows three elongated bars, each tipped 45 degrees around a different axis using rotate(), so the effect of rotating around X, Y, and Z is immediately visible.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// rotate()

/* rotate([x_deg, y_deg, z_deg]) spins its child around the world axes.
   Each bar below is the same shape but rotated about one axis only.
   Positive angles follow the right-hand rule. */

bar_w  = 6;    // bar cross-section (mm)
bar_l  = 40;   // bar length (mm)
angle  = 45;   // rotation angle to apply (degrees)
spread = 60;   // spacing between the three examples

// Unrotated reference bar (grey in color-aware viewers)
color("silver")
    cube([bar_w, bar_w, bar_l]);

// Rotated 45 degrees around X - bar tilts in the Y-Z plane
translate([spread, 0, 0])
    rotate([angle, 0, 0])
        cube([bar_w, bar_w, bar_l]);

// Rotated 45 degrees around Y - bar tilts in the X-Z plane
translate([spread * 2, 0, 0])
    rotate([0, angle, 0])
        cube([bar_w, bar_w, bar_l]);

// Rotated 45 degrees around Z - bar tips sideways in the X-Y plane
translate([spread * 3, 0, 0])
    rotate([0, 0, angle])
        cube([bar_w, bar_w, bar_l]);
`);

Open in editor →

scale() and resize()

Compares scale() and resize() applied to the same sphere. scale() multiplies the current size by a factor while resize() sets an exact target size in millimetres.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// scale() and resize()

/* scale() multiplies coordinates by a factor vector [sx, sy, sz].
   resize() sets the bounding box to an absolute [x, y, z] size.
   Both can stretch non-uniformly - very useful for turning a sphere
   into an ellipsoid without defining new geometry. */

base_r  = 12;   // radius of the original sphere (mm)
$fn     = 40;
spacing = 50;   // gap between examples

// Original sphere for reference
color("silver")
    sphere(r = base_r);

// scale() - multiply each axis: 1x on X, 2x on Y, 0.5x on Z
translate([spacing, 0, 0])
    color("steelblue")
        scale([1, 2, 0.5])
            sphere(r = base_r);

// resize() - force the bounding box to exactly 50 x 20 x 30 mm
translate([spacing * 2.5, 0, 0])
    color("tomato")
        resize([50, 20, 30])
            sphere(r = base_r);
`);

Open in editor →

sphere()

Places two spheres of the same radius side by side to show how $fn controls smoothness - the left sphere is coarse and blocky while the right one is nearly smooth.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// sphere()

/* sphere() - facet count comparison.
   $fn sets the number of longitude AND latitude segments.
   Low $fn = fast but faceted; high $fn = smooth but slower to render. */

r   = 15;    // sphere radius (mm)
gap = 10;    // gap between the two spheres

// Coarse sphere - clearly faceted, renders instantly
translate([-r - gap / 2, 0, r])
    sphere(r = r, $fn = 8);

// Smooth sphere - 48 segments, much rounder
translate([ r + gap / 2, 0, r])
    sphere(r = r, $fn = 48);
`);

Open in editor →

text() 2D

Shows how text() creates a 2D letter outline that linear_extrude() lifts into raised 3D lettering on a name-badge plate. Change the label, font size, and thickness to customise.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// text() 2D

/* text() as 2D letters raised above a badge plate. */
label      = "OpenSCAD";  // the text string (change me!)
font_size  = 11;           // character height in mm
raise      =  3;           // how tall the raised letters are above the plate
plate_w    = 90;           // badge plate width
plate_d    = 28;           // badge plate depth
plate_h    =  3;           // badge plate base thickness

// Base plate - ensures non-empty geometry even if the font system is unavailable.
cube([plate_w, plate_d, plate_h], center = true);

// Raised lettering on top of the plate.
// text() defines the 2D outline; linear_extrude lifts it above the plate surface.
translate([0, 0, plate_h / 2])
    linear_extrude(height = raise)
        text(
            label,
            size   = font_size,
            halign = "center",
            valign = "center"
        );
`);

Open in editor →

engraving text

Shows how to engrave text into a flat plate using difference() - the text shape is subtracted from the plate solid. Tune the plate size, engraving depth, and label.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// engraving text

/* Engraving text into a plate with difference(). */
plate_w   = 80;   // plate width
plate_d   = 40;   // plate depth (Y)
plate_h   =  6;   // plate total thickness
engrave_d =  1.5; // how deep the text is cut in
font_size = 10;   // character height
label     = "MADE WITH";  // first line of text
label2    = "OPENSCAD";   // second line of text
font_name = "Liberation Sans:style=Bold";
$fn = 32;

difference() {
    // The solid plate
    cube([plate_w, plate_d, plate_h], center = true);

    // Engrave first line - translate up from plate surface by (plate_h/2 - engrave_d)
    translate([0, 5, plate_h / 2 - engrave_d])
        linear_extrude(height = engrave_d + 0.1)   // +0.1 ensures clean boolean cut
            text(label,  size = font_size, font = font_name, halign = "center", valign = "center");

    // Engrave second line below the first
    translate([0, -8, plate_h / 2 - engrave_d])
        linear_extrude(height = engrave_d + 0.1)
            text(label2, size = font_size, font = font_name, halign = "center", valign = "center");
}
`);

Open in editor →

translate()

Places four identical cubes at different positions using translate() to show how moving along X, Y, and Z works independently and in combination.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// translate()

/* translate([x, y, z]) shifts its child geometry in space.
   Here the same 15 mm cube appears at four different locations
   so you can see how each axis affects placement. */

s   = 15;   // cube side (mm)
gap = 8;    // extra space between cubes

// Reference cube at the origin
cube([s, s, s]);

// Shifted along +X
translate([s + gap, 0, 0])
    cube([s, s, s]);

// Shifted along +Y
translate([0, s + gap, 0])
    cube([s, s, s]);

// Shifted along +Z
translate([0, 0, s + gap])
    cube([s, s, s]);
`);

Open in editor →

union()

Shows how union() merges two overlapping solids into a single seamless body. Adjust the box size, cylinder radius, and overlap to explore how the shapes combine.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// union()

/* union() example - two overlapping shapes become one solid. All dimensions in mm. */
box_w   = 40;   // box width (X)
box_d   = 30;   // box depth (Y)
box_h   = 20;   // box height (Z)
cyl_r   = 12;   // cylinder radius
cyl_h   = 35;   // cylinder height
overlap = 10;   // how far the cylinder overlaps into the box
$fn = 48;

// union() is actually the default when you list children side by side,
// but writing it explicitly makes the intent crystal-clear.
union() {
    // A rounded-end horizontal bar
    cube([box_w, box_d, box_h]);

    // A vertical cylinder that overlaps the box - together they become one solid
    translate([box_w - overlap, box_d / 2, 0])
        cylinder(r = cyl_r, h = cyl_h);
}
`);

Open in editor →

608 bearing footprint ring

A solid printable ring matching the footprint of a standard 608 skate/skateboard ball bearing (22 mm OD, 8 mm bore, 7 mm wide). Use it as a press-fit spacer, a bearing-seat gauge, or a drop-in dummy bearing. The outer and inner edges are lightly chamfered so it seats cleanly. Tune the diameters and width to gauge other bearing sizes.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// 608 bearing footprint ring
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

outer_d  = 22;   // outer diameter (608 = 22 mm)
bore_d   = 8;    // inner bore diameter (608 = 8 mm)
width    = 7;    // axial width (608 = 7 mm)
edge_cf  = 0.6;  // chamfer on outer + bore edges
$fn = 96;

tube(h = width, od = outer_d, id = bore_d, chamfer = edge_cf, anchor = BOTTOM);
`);

Open in editor →

Bevel gear

A straight-cut bevel gear that transmits motion between two shafts meeting at 90 degrees. Print one of these plus a mating bevel gear (swap teeth and mate_teeth) to build a right-angle drive. Tune the module, tooth count, mate tooth count, face width, and bore.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Bevel gear
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/gears.scad>

teeth       = 24;  // teeth on THIS gear
mate_teeth  = 24;  // teeth on the mating gear (sets the cone angle)
gear_mod    = 2;   // tooth module in mm
face_w      = 8;   // face width (tooth length along the cone) in mm
shaft_d     = 6;   // center shaft bore diameter in mm
$fn = 48;

bevel_gear(mod = gear_mod, teeth = teeth, mate_teeth = mate_teeth,
           face_width = face_w, shaft_diam = shaft_d, shaft_angle = 90,
           pressure_angle = 20, spiral = 0);
`);

Open in editor →

Generic threaded bottle cap

A generic screw-on bottle cap that mates with the generic threaded bottle neck, built by the BOSL2 bottlecaps library. Tune the cap height, thread depth, thread outer diameter, and pitch (keep them matched to your neck) for a snug fit. Pairs with the generic bottle neck recipe.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Generic threaded bottle cap
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/bottlecaps.scad>

cap_h        = 11.2;   // cap height (mm)
cap_wall     = 2;      // wall thickness (mm)
thread_depth = 2.34;   // thread depth (mm) — match the neck thread
thread_od    = 28.58;  // thread outer diameter (mm) — match the neck
pitch        = 4;      // thread pitch (mm) — match the neck
$fn = 96;

generic_bottle_cap(
    height       = cap_h,
    wall         = cap_wall,
    thread_depth = thread_depth,
    thread_od    = thread_od,
    pitch        = pitch,
    texture      = "knurled"
);
`);

Open in editor →

Generic threaded bottle neck

A generic threaded bottle neck finish with a support ring, built by the BOSL2 bottlecaps library. Pairs with the matching generic bottle cap. Tune the neck diameter, thread outer diameter, height, and thread pitch to design your own container opening.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Generic threaded bottle neck
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/bottlecaps.scad>

neck_diam = 25;      // outer diameter of the neck wall (mm)
inner_id  = 21.4;    // inner bore diameter (mm)
thread_od = 27.2;    // outer diameter over the threads (mm)
neck_h    = 17;      // neck height (mm)
pitch     = 3.2;     // thread pitch (mm)
$fn = 96;

generic_bottle_neck(
    neck_d    = neck_diam,
    id        = inner_id,
    thread_od = thread_od,
    height    = neck_h,
    pitch     = pitch
);
`);

Open in editor →

Wall cable clip

A small screw- or adhesive-mount cable clip: a flat backing pad with a rounded C-shaped catch that snaps over a cable to route it along a wall or desk edge. The catch mouth is narrower than the cable so it grips. Tune the cable diameter, mouth opening, backing size, and wall thickness.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Wall cable clip
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

cable_d  = 6;    // diameter of the cable to hold
gap      = 3.5;  // mouth opening width (under cable_d so it grips)
wall     = 2;    // catch wall thickness
pad_w    = 16;   // backing pad width
pad_t    = 3;    // backing pad thickness
clip_len = 12;   // depth of the clip along the cable
$fn = 72;

bore_r  = cable_d / 2;
outer_r = bore_r + wall;
// Catch centre is lowered so the outer body overlaps (fuses with) the pad,
// while the bore floor stays a touch above the pad's top surface.
overlap  = wall * 0.75;
catch_cz = pad_t + outer_r - overlap;

union() {
    // Flat backing pad against the wall, vertical corners rounded.
    cuboid([pad_w, clip_len, pad_t], rounding = 1.5, edges = "Y", anchor = BOTTOM);

    // C-shaped catch: outer cylinder, bore removed, plus a front mouth slot.
    translate([0, 0, catch_cz])
        difference() {
            // Outer body of the catch (axis along Y / cable direction).
            xrot(90) cyl(h = clip_len, r = outer_r, rounding = 0.8);
            // Cable bore.
            xrot(90) cyl(h = clip_len + 0.4, r = bore_r);
            // Mouth slot opening upward (away from the pad).
            up(outer_r / 2)
                cube([gap, clip_len + 0.4, outer_r + 0.2], center = true);
        }
}
`);

Open in editor →

Flat corner brace

A flat L-shaped mending plate that reinforces a 90 degree corner joint. Two perpendicular arms share a rounded outer profile with a screw hole in each arm and the heel. Prints flat as one solid with no supports. Tune the arm length, width, thickness, corner rounding, and screw-hole diameter.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Flat corner brace
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

arm     = 45;   // length of each arm from the heel
width   = 16;   // arm width
thick   = 4;    // plate thickness
round_r = 4;    // outer corner rounding radius
hole_d  = 4.2;  // screw-hole diameter
$fn = 48;

difference() {
    union() {
        // Arm running along +X.
        cuboid([arm, width, thick], rounding = round_r,
               edges = [LEFT + FRONT, LEFT + BACK, RIGHT + FRONT],
               anchor = BOTTOM + LEFT + BACK);
        // Arm running along -Y.
        cuboid([width, arm, thick], rounding = round_r,
               edges = [LEFT + FRONT, RIGHT + FRONT, RIGHT + BACK],
               anchor = BOTTOM + LEFT + BACK);
    }
    // Hole near the end of the X arm.
    translate([arm - width / 2, -width / 2, 0])
        cyl(d = hole_d, h = thick + 2, anchor = CENTER);
    // Hole near the end of the Y arm.
    translate([width / 2, -arm + width / 2, 0])
        cyl(d = hole_d, h = thick + 2, anchor = CENTER);
    // Hole at the heel.
    translate([width / 2, -width / 2, 0])
        cyl(d = hole_d, h = thick + 2, anchor = CENTER);
}
`);

Open in editor →

Rounded decorative bowl

A curved bowl with a flat stable base and a rounded rim, hollowed to a uniform wall and a solid floor. Built by revolving an explicit profile with BOSL2 rotate_sweep. Tune the rim radius, depth, wall and base flat.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Rounded decorative bowl
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

rim_r   = 55;   // outer radius at the rim
depth   = 42;   // bowl depth
wall    = 3;    // wall thickness
floor_t = 4;    // solid floor thickness
base_r  = 24;   // radius of the flat resting base
$fn = 120;

// Outer profile (right half), a smooth curve from base to rim.
outer = [
    [0,            0],
    [base_r,       0],
    [rim_r * 0.78, depth * 0.30],
    [rim_r * 0.97, depth * 0.70],
    [rim_r,        depth],
    [0,            depth],
];
// Inner cavity profile: offset inward by the wall, floor raised by floor_t.
inner = [
    [0,                   floor_t],
    [base_r - wall,       floor_t],
    [rim_r * 0.78 - wall, depth * 0.30 + floor_t * 0.4],
    [rim_r * 0.97 - wall, depth * 0.70],
    [rim_r - wall,        depth],
    [0,                   depth],
];

difference() {
    rotate_sweep(outer, closed = true);
    rotate_sweep(inner, closed = true);
}
`);

Open in editor →

Faceted gem

A solid brilliant-cut style gem: a flat-topped table on a faceted crown over a pointed pavilion, built from stacked BOSL2 regular prisms. Single shell, prints point-down style as one solid (table up). Tune the girdle width, facet count, and crown/pavilion proportions.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Faceted gem
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

sides     = 8;    // number of facets around the girdle
girdle_r  = 26;   // radius at the widest point (girdle)
table_r   = 15;   // radius of the flat top table
crown_h   = 14;   // height of the upper crown (girdle to table)
pavi_h    = 26;   // height of the lower pavilion (girdle to point)
$fn = 8;

union() {
    // Crown: girdle tapering up to the flat table.
    regular_prism(n = sides, r1 = girdle_r, r2 = table_r, h = crown_h, anchor = BOTTOM);
    // Pavilion: girdle tapering down to a near-point, fused at the girdle plane.
    down(pavi_h)
        regular_prism(n = sides, r1 = 0.8, r2 = girdle_r, h = pavi_h, anchor = BOTTOM);
}
`);

Open in editor →

Hanging ornament ball

A solid decorative sphere with an integrated torus hanging loop on top, fused into one printable shell. Tune the ball diameter, the loop size/thickness and the facet count for a smoother surface.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Hanging ornament ball
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

ball_d    = 50;   // sphere diameter
loop_or   = 7;    // loop outer radius (hole size)
loop_thk  = 2.6;  // loop wire thickness (torus minor radius)
$fn = 96;

union() {
    // The decorative ball.
    spheroid(d = ball_d, anchor = CENTER);
    // Hanging loop: a torus standing vertically, overlapping the top of the ball
    // so the two fuse into a single solid (loop sits in the XZ plane).
    up(ball_d / 2 - loop_thk)
        xrot(90)
            torus(or = loop_or, ir = loop_or - 2 * loop_thk);
}
`);

Open in editor →

Picture frame with stand

A desktop photo frame: a rounded rectangular border with a window cut through it, fused to an angled easel leg at the back so it stands on its own. One printable shell, prints flat on its back. Tune the frame size, border width, window and leg angle.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Picture frame with stand
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

frame_w   = 90;   // overall frame width
frame_h   = 120;  // overall frame height
border    = 12;   // border thickness around the photo window
frame_t   = 6;    // frame plate thickness (front to back)
leg_len   = 78;   // length of the easel leg
leg_ang   = 22;   // lean-back angle of the leg (degrees)
$fn = 48;

union() {
    // Frame plate lying in the XY plane (front face up), window cut through.
    difference() {
        cuboid([frame_w, frame_h, frame_t], rounding = 5, edges = "Z", anchor = BOTTOM);
        down(0.5)
            cuboid([frame_w - 2 * border, frame_h - 2 * border, frame_t + 2],
                   rounding = 3, edges = "Z", anchor = BOTTOM);
    }
    // Solid hinge block fused to the lower-back of the frame; the leg grows from it.
    translate([0, -frame_h / 2 + 10, 0])
        union() {
            // Hinge block bridging frame and leg (overlaps the plate solidly).
            cuboid([20, 16, frame_t + 3], rounding = 2, edges = "Z", anchor = BOTTOM);
            // Easel leg leaning out from the hinge block.
            up(frame_t)
                xrot(-leg_ang)
                    cuboid([18, leg_len, 5], rounding = 3, edges = "Z",
                           anchor = FRONT + BOTTOM);
        }
}
`);

Open in editor →

Tealight candle holder

A weighted round holder with a recessed pocket sized for a standard tealight cup and a rounded outer rim. Single shell, prints flat with no supports. Tune the outer diameter, height, the tealight pocket diameter/depth and the rim rounding.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Tealight candle holder
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

outer_d   = 52;   // outer diameter
height    = 26;   // overall height
pocket_d  = 39;   // tealight pocket diameter (standard cup ~38-40mm)
pocket_h  = 13;   // tealight pocket depth (cup height ~10-12mm)
rim_round = 4;    // rounding on the outer top rim
$fn = 96;

difference() {
    // Solid rounded body.
    cyl(d = outer_d, h = height, rounding2 = rim_round,
        chamfer1 = 1, anchor = BOTTOM);
    // Recessed pocket for the tealight cup, open at the top.
    up(height - pocket_h)
        cyl(d = pocket_d, h = pocket_h + 1, rounding1 = 2, anchor = BOTTOM);
}
`);

Open in editor →

Twisted spiral column

A decorative pillar/pedestal with a spiralling fluted shaft between a square base and a square cap, fused into one solid. The shaft is a rounded BOSL2 star profile linearly extruded with a twist. Tune the height, twist, flute count and base size.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Twisted spiral column
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

shaft_h   = 120;  // height of the twisting shaft
twist     = 200;  // total twist over the shaft (degrees)
points    = 6;    // number of flutes around the shaft
shaft_r   = 20;   // outer radius of the shaft
plinth    = 46;   // base/cap square width
$fn = 72;

// Rounded star profile so the twisted flutes have no razor edges (cleaner mesh).
shaft_profile = round_corners(
    star(n = points, r = shaft_r, ir = shaft_r * 0.74),
    radius = 2.5, $fn = 16
);

union() {
    // Square base plinth.
    prismoid(size1 = [plinth, plinth], size2 = [plinth - 4, plinth - 4],
             h = 14, rounding = 3, anchor = BOTTOM);
    // Twisting fluted shaft, overlapping the plinth and cap so all fuse.
    up(12)
        linear_extrude(height = shaft_h, twist = twist, slices = 160, convexity = 12)
            polygon(shaft_profile);
    // Square cap plinth, overlapping the shaft top.
    up(12 + shaft_h - 2)
        prismoid(size1 = [plinth - 4, plinth - 4], size2 = [plinth, plinth],
                 h = 14, rounding = 3, anchor = BOTTOM);
}
`);

Open in editor →

Faceted prismoid vase

An angular tapered vase with a wide square base flaring to a smaller rotated top, hollowed for stems. Built from two BOSL2 prismoids (outer minus inner) with a solid floor. Tune base/top widths, twist, height and wall.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Faceted prismoid vase
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

base_w  = 60;   // base width (square)
top_w   = 46;   // top opening width (square)
vase_h  = 120;  // overall height
wall    = 2.6;  // wall thickness
floor_t = 3;    // floor thickness
edge_r  = 3;    // vertical edge rounding
$fn = 64;

difference() {
    // Outer faceted body.
    prismoid(size1 = [base_w, base_w], size2 = [top_w, top_w],
             h = vase_h, rounding = edge_r, anchor = BOTTOM);
    // Inner cavity, raised above the floor so the base stays solid.
    up(floor_t)
        prismoid(size1 = [base_w - 2 * wall, base_w - 2 * wall],
                 size2 = [top_w - 2 * wall, top_w - 2 * wall],
                 h = vase_h, rounding = max(edge_r - wall, 0.5), anchor = BOTTOM);
}
`);

Open in editor →

Rounded bud vase

A smooth single-shell bud vase with a swelling belly and a narrowed neck, hollowed for water. Built by revolving a rounded profile with BOSL2 rotate_sweep. Tune the base/belly/neck radii, height and wall thickness.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Rounded bud vase
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

base_r  = 22;   // radius at the base
belly_r = 38;   // widest radius (belly)
neck_r  = 18;   // radius at the neck/mouth
vase_h  = 110;  // overall height
wall    = 2.4;  // wall thickness
$fn = 96;

// Outer profile (right half, x>=0) revolved around the Z axis.
function vase_profile(rb, rbelly, rn, h) = [
    [0,        0],
    [rb,       0],
    [rb + 6,   h * 0.18],
    [rbelly,   h * 0.45],
    [rn + 7,   h * 0.78],
    [rn,       h],
    [0,        h],
];

difference() {
    rotate_sweep(vase_profile(base_r, belly_r, neck_r, vase_h), closed = true);
    // Inner cavity: same profile scaled inward by the wall, with a solid floor.
    up(wall)
        rotate_sweep(vase_profile(base_r - wall, belly_r - wall, neck_r - wall, vase_h), closed = true);
}
`);

Open in editor →

Cable management clip

A desk-edge cable management clip: a flat adhesive base with an open C-shaped jaw on top that snaps around a cable bundle and holds it along the desk edge. The C jaw is a ring extruded across the clip depth with a top wedge cut for the snap opening, unioned to the base, so it prints flat-down as one solid. Tune the cable channel diameter, jaw opening, base size, and wall.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Cable management clip
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

cable_d   = 12;   // inner channel diameter (cable bundle)
wall      = 2.8;  // clip wall thickness
gap_w     = 8;    // width of the snap opening at the top
base_w    = 26;   // adhesive base width
depth     = 18;   // clip depth (along the cable run)
base_t    = 3;    // base thickness
$fn = 72;

outer_d = cable_d + 2 * wall;

union() {
    // Adhesive base plate.
    cuboid([base_w, depth, base_t], rounding = 2, except = [TOP, BOTTOM], anchor = BOTTOM);

    // C-jaw: extrude a ring-with-gap profile across the clip depth.
    up(base_t)
        xrot(90)
            linear_extrude(height = depth, center = true)
                difference() {
                    circle(d = outer_d);
                    circle(d = cable_d);
                    // Top opening slot.
                    translate([0, outer_d / 2])
                        square([gap_w, outer_d], center = true);
                }
}
`);

Open in editor →

Business-card holder

An angled desktop business-card holder: a rounded block with a slanted slot that cradles a stack of cards at a readable angle, plus a front cut-away so you can thumb the top card out. Carved entirely by difference from one rounded body so it prints as a single watertight piece. Tune the card width, stack thickness, slot angle, and wall.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Business-card holder
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

card_w     = 92;   // card width (slot length) — standard card ~90mm
stack_t    = 16;   // thickness of card stack the slot holds
slot_angle = 18;   // backward lean of the slot, degrees
wall       = 4;    // surrounding wall thickness
base_h     = 26;   // overall body height
round_r    = 3;    // outer corner rounding
$fn = 48;

body_w = card_w + 2 * wall;
body_d = stack_t + 2 * wall + 14;   // depth: stack + walls + front lip room
body_h = base_h;

difference() {
    cuboid([body_w, body_d, body_h], rounding = round_r, except = [TOP]);

    // Angled slot that holds the card stack (tall thin pocket, leaned back).
    translate([0, 2, body_h - 2])
        rotate([slot_angle, 0, 0])
            cuboid([card_w + 1, stack_t, body_h * 2.2],
                   rounding = 1, except = [TOP, BOTTOM], anchor = TOP);

    // Front thumb cut-away so the top card is reachable.
    translate([0, -body_d / 2 + wall + 1, body_h])
        cuboid([card_w - 24, wall * 3, body_h * 1.4], rounding = 4, except = [TOP], anchor = TOP);
}
`);

Open in editor →

Headphone hook bracket

An under-desk headphone hook bracket: a flat vertical mounting plate (screw-mount) with a hook arm that sweeps out and curls up to cradle a headphone band without creasing it. The side profile (plate + arm + upturned tip) is drawn once and extruded across the width, then screw holes are bored, so it is guaranteed a single watertight solid. Tune the plate size, hook reach, tip height, and width.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Headphone hook bracket
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

plate_h   = 60;   // mount plate height
plate_t   = 6;    // plate / arm material thickness
arm_reach = 45;   // how far the hook sticks out
tip_h     = 24;   // height of the upturned cradle tip
width     = 26;   // width across (band rests here)
$fn = 48;

// Side profile in the YZ-ish plane, drawn in 2D (X = reach, Y = height),
// then extruded across the part width and laid upright.
xrot(90)
linear_extrude(height = width, center = true)
    offset(r = 1.5) offset(r = -1.5)   // round all profile corners (kept < half arm thickness)
        polygon([
            [0,             0],            // plate back-bottom
            [plate_t,       0],            // plate front-bottom
            [plate_t,       plate_h - plate_t],     // arm root
            [plate_t + arm_reach,          plate_h - plate_t],  // arm tip bottom
            [plate_t + arm_reach,          plate_h - plate_t + tip_h], // tip top outer
            [plate_t + arm_reach - plate_t, plate_h - plate_t + tip_h], // tip top inner
            [plate_t + arm_reach - plate_t, plate_h],            // arm tip inner
            [0,             plate_h],       // plate back-top
        ]);
`);

Open in editor →

Monitor-riser foot

A single load-bearing foot/leg for a DIY monitor riser or laptop stand: a hollow tapered pedestal (wide stable base, narrower top) with a thick top deck and a centering spigot on top so a wooden or acrylic shelf board or a stacked foot locates onto it. Carved from a rounded prismoid with an internal cavity, printed open-side-down as one watertight shell. Tune the footprint, height, wall, taper, and spigot.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Monitor-riser foot
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

base_w    = 78;   // bottom footprint width/depth (square, sits on desk)
foot_h    = 50;   // height of one riser foot
top_w     = 60;   // top deck width/depth (narrower for a taper)
wall      = 4;    // shell wall thickness
spigot_d  = 22;   // top centering spigot diameter
round_r   = 6;    // corner rounding
$fn = 64;

union() {
    difference() {
        // Tapered pedestal: wide base, narrower top, rounded.
        prismoid(size1 = [base_w, base_w], size2 = [top_w, top_w], h = foot_h,
                 rounding = round_r, anchor = BOTTOM);
        // Hollow cavity opening downward (prints open-side-down, no supports).
        prismoid(size1 = [base_w - 2 * wall, base_w - 2 * wall],
                 size2 = [top_w - 2 * wall, top_w - 2 * wall],
                 h = foot_h - wall, anchor = BOTTOM);
    }
    // Top centering spigot.
    up(foot_h)
        cyl(h = 8, d = spigot_d, chamfer2 = 1.5, anchor = BOTTOM);
}
`);

Open in editor →

Pen & pencil cup with base tray

A round desktop pen cup with a slightly flared rounded rim and a wide chamfered base disc that doubles as a stability foot and a tiny clip/eraser ledge. Built from a BOSL2 tube on a chamfered cylinder so it prints floor-down with no supports. Tune the outer diameter, height, wall, floor thickness, and base flare.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Pen & pencil cup with base tray
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

cup_d     = 70;   // outer diameter of the cup body
cup_h     = 100;  // overall height
wall      = 2.4;  // wall thickness
floor_t   = 3;    // floor thickness
base_flare = 12;  // extra diameter added at the base foot
$fn = 96;

union() {
    // Wide chamfered base foot for stability, with a solid floor on top.
    cyl(h = floor_t + 4, d = cup_d + base_flare, chamfer1 = 1.2, rounding2 = 2, anchor = BOTTOM);
    // Hollow body wall standing on the base, rounded top rim.
    up(floor_t)
        tube(h = cup_h - floor_t, od = cup_d, wall = wall,
             orounding2 = 1.6, irounding2 = 1.6, anchor = BOTTOM);
}
`);

Open in editor →

Phone stand

A single-piece angled phone stand: a back support leaned at an angle with a front lip ledge that catches the phone, joined to a flat base for stability. Built by unioning a leaned slab, a base plate, and a front lip so it prints as one solid with no supports. Tune the width, lean angle, support height, base depth, and slab thickness.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Phone stand
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

stand_w    = 80;   // width across (phone width + margin)
lean       = 20;   // backward lean of the support from vertical, degrees
support_h  = 95;   // length of the leaning support slab
base_d     = 75;   // base plate depth on the desk
thick      = 8;    // slab / base thickness
lip_h      = 12;   // front catching lip height
$fn = 48;

union() {
    // Flat base plate for stability.
    cuboid([stand_w, base_d, thick], rounding = 2, except = [TOP, BOTTOM], anchor = BOTTOM);

    // Front catching lip running across the width near the base front edge.
    translate([0, -base_d / 2 + thick + 2, 0])
        cuboid([stand_w, thick, thick + lip_h], rounding = 2, except = [BOTTOM], anchor = BOTTOM);

    // Leaning back support: a slab tilted backward, rooted at the base.
    translate([0, -base_d / 2 + thick + 2 + thick, thick / 2])
        xrot(lean)
            cuboid([stand_w, thick, support_h], rounding = 2, except = [], anchor = BOTTOM);
}
`);

Open in editor →

Sticky-note tray

A desktop sticky-note holder: a shallow rounded tray sized for a square sticky pad, with a scooped front thumb cut-out so you can peel the top note off easily, and a solid floor. Carved by difference from one rounded block so the whole tray is a single watertight piece. Tune the pad size, wall, tray height, and floor thickness.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Sticky-note tray
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

pad_size  = 78;   // sticky pad edge length (76mm pad + clearance)
wall      = 3;    // wall thickness
tray_h    = 18;   // overall tray height
floor_t   = 2.5;  // floor thickness
scoop_d   = 30;   // diameter of the front peel scoop
round_r   = 4;    // outer corner rounding
$fn = 64;

body = pad_size + 2 * wall;

difference() {
    cuboid([body, body, tray_h], rounding = round_r, except = [TOP], anchor = BOTTOM);

    // Pad pocket.
    up(floor_t)
        cuboid([pad_size, pad_size, tray_h], rounding = max(round_r - wall, 0.5),
               except = [TOP], anchor = BOTTOM);

    // Front peel scoop: a sphere carved into the front wall + floor lip.
    translate([0, -body / 2, floor_t + 3])
        sphere(d = scoop_d);
}
`);

Open in editor →

Tablet stand

A wider, sturdier cousin of the phone stand sized for tablets: a leaned back support slab with a deep front trough ledge that cradles a tablet, joined to a heavy base plate for stability. Unioned from base, trough lips, and a tilted slab so it prints as one solid, ledge facing up, no supports. Tune the width, lean, support height, base depth, and trough gap.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Tablet stand
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

stand_w    = 180;  // width across (tablet width + margin)
lean       = 22;   // backward lean of the support from vertical, degrees
support_h  = 130;  // length of the leaning support slab
base_d     = 120;  // base plate depth on the desk
thick      = 10;   // slab / base thickness
trough_gap = 16;   // gap between front lip and support = tablet thickness slot
$fn = 48;

union() {
    // Heavy base plate.
    cuboid([stand_w, base_d, thick], rounding = 3, except = [TOP, BOTTOM], anchor = BOTTOM);

    // Front lip forming the outer wall of the cradle trough.
    translate([0, -base_d / 2 + thick + 4, 0])
        cuboid([stand_w, thick, thick + 22], rounding = 2, except = [BOTTOM], anchor = BOTTOM);

    // Leaning back support, set behind the trough gap.
    translate([0, -base_d / 2 + thick + 4 + thick + trough_gap, thick / 2])
        xrot(lean)
            cuboid([stand_w, thick, support_h], rounding = 3, anchor = BOTTOM);
}
`);

Open in editor →

Divided tray (3 compartments)

A shallow desk tray split into three equal compartments by two internal dividers, with rounded outer corners and a solid floor. Carve out each compartment from a rounded block so the whole tray prints as one watertight piece. Tune the footprint, height, wall thickness, and floor thickness.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Divided tray (3 compartments)
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

tray_w     = 120;  // outer width (X) — the long axis split into 3
tray_d     = 50;   // outer depth (Y)
tray_h     = 22;   // outer height (Z)
wall       = 2.4;  // outer wall + divider thickness
floor_t    = 2;    // floor thickness
round_r    = 4;    // outer corner rounding radius
$fn = 48;

compartments = 3;
// Total interior length available after the two outer walls.
inner_len = tray_w - 2 * wall;
// Each pocket width once the (compartments-1) dividers are removed.
pocket_w = (inner_len - (compartments - 1) * wall) / compartments;
pocket_d = tray_d - 2 * wall;
pocket_h = tray_h - floor_t;

difference() {
    cuboid([tray_w, tray_d, tray_h], rounding = round_r, except = [TOP]);
    // One open pocket per compartment, marching along X.
    for (i = [0 : compartments - 1]) {
        // Left edge of interior, then offset by each pocket + divider.
        x0 = -tray_w / 2 + wall + i * (pocket_w + wall);
        translate([x0 + pocket_w / 2, 0, -tray_h / 2 + floor_t])
            cuboid([pocket_w, pocket_d, pocket_h + 1],
                   rounding = max(round_r - wall, 0.5), except = [TOP], anchor = BOTTOM);
    }
}
`);

Open in editor →

Dovetail female socket

A flat plate with a sliding dovetail groove (the female half) bored through it by the BOSL2 joiners library. The matching dovetail male connector slides in for a self-locking joint. Tune the plate size, groove width, height, and slide length.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Dovetail female socket
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/joiners.scad>

plate      = [40, 40, 12];  // base plate size [x, y, z]
tail_w     = 20;            // dovetail width (wide reference dimension)
tail_h     = 8;            // dovetail height (groove depth)
slide      = 30;           // length of the groove along the slide axis
slope      = 5;            // flank slope (match the male part)
entry_slot = 17;           // open entry slot so the male part can drop in
$fn = 32;

diff()
  cuboid(plate)
    attach(TOP, BOTTOM, align = BACK, inside = true, inset = 5)
      tag("remove")
        dovetail("female", slide = slide, width = tail_w,
                 height = tail_h, slope = slope,
                 entry_slot_length = entry_slot);
`);

Open in editor →

Dovetail male connector

A flat connector plate with a sliding dovetail tongue (the male half) generated by the BOSL2 joiners library. Slides into the matching dovetail female socket for a self-locking woodworking-style joint. Tune the plate size, dovetail width, height, and slide length.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Dovetail male connector
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/joiners.scad>

plate      = [40, 30, 8];  // base plate size [x, y, z]
tail_w     = 20;           // dovetail width (wide reference dimension)
tail_h     = 8;            // dovetail height (how far it sticks out)
slide      = 30;           // length of the dovetail along the slide axis
slope      = 5;            // flank slope (higher = shallower angle)
$fn = 32;

cuboid(plate)
  attach(RIGHT, BOTTOM, align = BACK, inset = 5)
    dovetail("male", slide = slide, width = tail_w,
             height = tail_h, slope = slope);
`);

Open in editor →

Drawer organizer insert

A drop-in drawer insert with a grid of pockets for screws, stationery, or small parts. The whole tray is carved from a rounded block so it prints as one watertight piece — set the rows and columns to repartition the grid. Tune the footprint, height, grid size, wall thickness, and floor thickness.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Drawer organizer insert
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

org_w    = 140;  // outer width (X)
org_d    = 90;   // outer depth (Y)
org_h    = 28;   // outer height (Z)
cols     = 4;    // number of pockets across X
rows     = 3;    // number of pockets across Y
wall     = 2;    // outer wall + divider thickness
floor_t  = 2;    // floor thickness
round_r  = 3;    // outer corner rounding radius
$fn = 48;

// Interior span after the outer walls.
inner_w = org_w - 2 * wall;
inner_d = org_d - 2 * wall;
// Each pocket size once the internal dividers are removed.
pocket_w = (inner_w - (cols - 1) * wall) / cols;
pocket_d = (inner_d - (rows - 1) * wall) / rows;
pocket_h = org_h - floor_t;

difference() {
    cuboid([org_w, org_d, org_h], rounding = round_r, except = [TOP]);
    for (cx = [0 : cols - 1], ry = [0 : rows - 1]) {
        x0 = -org_w / 2 + wall + cx * (pocket_w + wall) + pocket_w / 2;
        y0 = -org_d / 2 + wall + ry * (pocket_d + wall) + pocket_d / 2;
        translate([x0, y0, -org_h / 2 + floor_t])
            cuboid([pocket_w, pocket_d, pocket_h + 1],
                   rounding = max(round_r - wall, 0.4), except = [TOP], anchor = BOTTOM);
    }
}
`);

Open in editor →

Flanged bushing

A plain bushing with an integral shoulder flange at one end, so it both press-fits into a bore and seats against the face of the housing to take axial load. Printed as one watertight solid (flange + sleeve share the same bore). Tune the sleeve OD to your bore, the flange diameter for the bearing face, the bore for your shaft, and the lengths.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Flanged bushing
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

sleeve_od  = 12;   // sleeve outer diameter (press-fit)
flange_d   = 18;   // flange outer diameter (seating face)
bore_d     = 8;    // shaft bore diameter
sleeve_len = 14;   // sleeve length below the flange
flange_t   = 3;    // flange thickness
$fn = 96;

difference() {
    union() {
        // flange disc at the bottom
        cyl(h = flange_t, d = flange_d, chamfer2 = 0.8, anchor = BOTTOM);
        // sleeve rising from the top of the flange
        up(flange_t)
            cyl(h = sleeve_len, d = sleeve_od, chamfer2 = 0.8, anchor = BOTTOM);
    }
    // through bore
    down(0.5)
        cyl(h = flange_t + sleeve_len + 1, d = bore_d, anchor = BOTTOM);
}
`);

Open in editor →

Flat-belt pulley with bore

A crowned flat-belt pulley with a bored hub to run on a shaft. The slight barrel crown across the face keeps a flat belt tracked to the centre, and the bore lets it ride on a shaft or bushing. Printed as one watertight solid. Tune the rim diameter, crown, face width, and bore.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Flat-belt pulley with bore
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

rim_d    = 28;   // pulley diameter at the edges of the face
crown    = 1.2;  // extra radius at the centre of the crown
face_w   = 14;   // axial width of the belt face
bore_d   = 8;    // center bore diameter
$fn = 120;

mid_d = rim_d + 2 * crown;   // diameter at the crowned centre

difference() {
    // crowned body of revolution
    rotate_extrude($fn = 120)
        polygon([
            [bore_d/2,  0],
            [rim_d/2,   0],
            [mid_d/2,   face_w/2],
            [rim_d/2,   face_w],
            [bore_d/2,  face_w],
        ]);
    // through bore
    down(1)
        cylinder(h = face_w + 2, d = bore_d, $fn = 96);
}
`);

Open in editor →

Friction-fit box lid

A press-on lid with a downward inner lip that slides snugly inside a matching box opening, plus a finger-grip recess on top. Sized to pair with a rounded box base; adjust the clearance for a looser or tighter fit. Tune the opening size, lip depth, top thickness, and rounding.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Friction-fit box lid
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

open_w    = 80;   // box outer width the lid sits over (X)
open_d    = 55;   // box outer depth the lid sits over (Y)
top_t     = 2.4;  // lid top plate thickness
lip_h     = 8;    // depth of the inner lip
lip_wall  = 2;    // lip wall thickness
clearance = 0.3;  // gap per side for a friction fit
round_r   = 5;    // outer corner rounding radius
$fn = 64;

// Inner opening the lip must drop into (box inner cavity).
inner_w = open_w - 2 * 2.4 - 2 * clearance;
inner_d = open_d - 2 * 2.4 - 2 * clearance;

union() {
    // Top cap plate, rounded only on the vertical corners to match the box footprint.
    cuboid([open_w, open_d, top_t], rounding = round_r, edges = "Z", anchor = BOTTOM);
    // Hollow downward lip that grips the inside of the box.
    down(lip_h)
        difference() {
            cuboid([inner_w, inner_d, lip_h], rounding = max(round_r - 2.4, 0.5), edges = "Z", anchor = BOTTOM);
            up(0.01)
                cuboid([inner_w - 2 * lip_wall, inner_d - 2 * lip_wall, lip_h + 0.02],
                       rounding = max(round_r - 2.4 - lip_wall, 0.4), edges = "Z", anchor = BOTTOM);
        }
}
`);

Open in editor →

Hose guide stake

A ground stake topped with a smooth vertical roller post that steers a garden hose around bed corners without crushing plants. The post, collar, and pointed spike fuse into one printable solid. Tune the spike length, post height/diameter, and base collar.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Hose guide stake
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

spike_len   = 70;  // length of the pointed ground spike
spike_d     = 14;  // spike diameter at the top (tapers to a point)
post_h      = 90;  // height of the hose-guiding post above ground
post_d      = 16;  // post diameter
collar_d    = 34;  // diameter of the base collar / soil stop
collar_h    = 6;   // collar thickness
$fn = 64;

union() {
    // Pointed ground spike, point down.
    down(spike_len)
        cyl(h = spike_len, d1 = 0.5, d2 = spike_d, anchor = BOTTOM);
    // Base collar / soil stop sitting at ground level.
    cyl(h = collar_h, d = collar_d, rounding = 2, anchor = BOTTOM);
    // The guiding post with a rounded cap so the hose slides freely.
    up(collar_h - 0.01)
        cyl(h = post_h, d = post_d, rounding2 = post_d / 2 - 0.5,
            anchor = BOTTOM);
}
`);

Open in editor →

Engraved plant label stake

A flat plant label on a pointed push-in stake, with the plant name engraved into the face via difference so it prints as one connected solid. Tune the label size, stake length, plate thickness, engrave depth, and the text.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Engraved plant label stake
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

label_text   = "BASIL";  // the name to engrave
plate_w      = 60;       // label plate width (X)
plate_h      = 22;       // label plate height (Z of the face)
plate_t      = 3;        // plate thickness (Y)
stake_len    = 45;       // length of the pointed push-in stake below the plate
font_size    = 11;       // engraved text size
engrave_d    = 1.2;      // how deep the text is cut into the face
$fn = 48;

difference() {
    union() {
        // The flat label plate. Rounding must stay under half the thin Y
        // dimension, so keep it modest to avoid BOSL2's size assertion.
        cuboid([plate_w, plate_t, plate_h], rounding = plate_t / 2 - 0.2,
               edges = "Z", anchor = BOTTOM);
        // Pointed stake hanging below the plate (a downward wedge).
        down(stake_len)
            prismoid(size1 = [4, plate_t], size2 = [14, plate_t],
                     h = stake_len, anchor = BOTTOM);
    }
    // Engrave the text into the front face (+Y side).
    up(plate_h / 2)
        fwd(plate_t / 2 - engrave_d)
            xrot(90)
                linear_extrude(height = engrave_d + 0.5)
                    text(label_text, size = font_size, halign = "center",
                         valign = "center", font = "Liberation Sans:style=Bold");
}
`);

Open in editor →

Plant pot with drainage holes

A tapered round plant pot with a solid floor pierced by a ring of drainage holes. Carved from a tapered tube so it prints as one watertight shell. Tune the top/bottom diameters, height, wall, floor thickness, and drainage hole count/size.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Plant pot with drainage holes
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

pot_top_d   = 90;  // outer diameter at the rim (X/Y)
pot_bot_d   = 70;  // outer diameter at the base — smaller for a taper
pot_h       = 80;  // overall height (Z)
wall        = 3;   // side-wall thickness
floor_t     = 4;   // floor thickness
drain_n     = 6;   // number of drainage holes around the centre
drain_d     = 7;   // diameter of each drainage hole
$fn = 96;

// Drainage ring sits inside the base footprint, clear of the wall.
drain_ring_r = (pot_bot_d / 2 - wall) * 0.55;

difference() {
    // Solid tapered body (cone frustum).
    cyl(h = pot_h, d1 = pot_bot_d, d2 = pot_top_d, anchor = BOTTOM);
    // Hollow the inside, leaving the floor.
    up(floor_t)
        cyl(h = pot_h, d1 = pot_bot_d - 2 * wall, d2 = pot_top_d - 2 * wall,
            anchor = BOTTOM);
    // Drainage holes through the floor.
    for (i = [0 : drain_n - 1]) {
        zrot(i * 360 / drain_n)
            right(drain_ring_r)
                cyl(h = floor_t + 2, d = drain_d, anchor = BOTTOM, $fn = 32);
    }
}
`);

Open in editor →

Pot saucer / drip tray

A shallow round saucer that catches drainage water under a plant pot, with a slightly raised inner lip and rounded outer edge. Carved from a rounded disc so it prints as one watertight piece. Tune the outer diameter, height, wall, and floor thickness.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Pot saucer / drip tray
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

saucer_d   = 110;  // outer diameter (X/Y) — make ~20mm bigger than the pot base
saucer_h   = 18;   // overall height (Z)
wall       = 3;    // side-wall thickness
floor_t    = 3;    // floor thickness
edge_r     = 3;    // rounding radius on the outer rim
$fn = 120;

difference() {
    // Solid disc with rounded top + bottom outer edges.
    cyl(h = saucer_h, d = saucer_d, rounding = edge_r, anchor = BOTTOM);
    // Carve the water-catching basin, leaving floor + walls.
    up(floor_t)
        cyl(h = saucer_h, d = saucer_d - 2 * wall,
            rounding2 = max(edge_r - wall, 0.5), anchor = BOTTOM);
}
`);

Open in editor →

Row-marker sign on stake

A small angled signboard on a flat ground stake for labelling vegetable rows, with the crop name engraved into the tilted face via difference so it reads from above. The board, stake, and point fuse into one printable solid. Tune the board size, stake length, tilt, and the text.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Row-marker sign on stake
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

sign_text   = "CARROTS";  // crop name to engrave
board_w     = 70;         // signboard width (X)
board_h     = 26;         // signboard height (Y, before the tilt)
board_t     = 4;          // board thickness
stake_len   = 60;         // length of the flat ground stake
stake_w     = 16;         // stake width
font_size   = 11;         // engraved text size
engrave_d   = 1.2;        // how deep the text is cut
$fn = 48;

union() {
    // Flat ground stake with a pointed tip at the bottom.
    down(stake_len)
        prismoid(size1 = [4, board_t], size2 = [stake_w, board_t],
                 h = stake_len, anchor = BOTTOM);
    // Tilted signboard sitting on top of the stake, engraved on its face.
    // Sink it low enough that the board overlaps the stake top into one shell.
    up(board_h / 2 - 12)
        xrot(-20)
            difference() {
                cuboid([board_w, board_h, board_t],
                       rounding = board_t / 2 - 0.2, edges = "Y");
                // Engrave the crop name into the +Z face.
                up(board_t / 2 - engrave_d)
                    linear_extrude(height = engrave_d + 0.5)
                        text(sign_text, size = font_size, halign = "center",
                             valign = "center",
                             font = "Liberation Sans:style=Bold");
            }
}
`);

Open in editor →

Seed-starting tray (2x2 cells)

A compact seed-starting tray with a 2x2 grid of tapered cells, each with its own drainage hole, joined by a shared rim so the whole tray lifts as one piece. Carved from a solid block so it prints watertight. Tune the cell count per side, cell size/depth, wall, and drain hole size.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Seed-starting tray (2x2 cells)
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

cells       = 2;   // cells per side (2 -> a 2x2 tray)
cell_top    = 34;  // inner width of each cell at the top
cell_depth  = 40;  // cell depth (Z)
wall        = 2.4; // wall between/around cells
floor_t     = 2;   // floor thickness under each cell
drain_d     = 5;   // drainage hole diameter per cell
$fn = 48;

taper      = 6;             // how much narrower the cell base is per side
pitch      = cell_top + wall;
tray_w     = cells * cell_top + (cells + 1) * wall;
tray_h     = cell_depth + floor_t;

difference() {
    // Solid outer block with rounded vertical corners.
    cuboid([tray_w, tray_w, tray_h], rounding = 3, edges = "Z",
           anchor = BOTTOM);
    // Carve each tapered cell.
    for (ix = [0 : cells - 1], iy = [0 : cells - 1]) {
        cx = -tray_w / 2 + wall + cell_top / 2 + ix * pitch;
        cy = -tray_w / 2 + wall + cell_top / 2 + iy * pitch;
        translate([cx, cy, floor_t])
            prismoid(size1 = [cell_top - taper, cell_top - taper],
                     size2 = [cell_top, cell_top],
                     h = cell_depth + 1, rounding = 2, anchor = BOTTOM);
        // Drainage hole through the floor of that cell.
        translate([cx, cy, -1])
            cyl(h = floor_t + 2, d = drain_d, anchor = BOTTOM, $fn = 24);
    }
}
`);

Open in editor →

Trellis / vine clip

A C-shaped open clip that snaps onto a trellis wire or thin stake and gently holds a plant stem in a second loop, training climbers without ties. Built as one wedge-and-ring body so it prints connected. Tune the wire and stem diameters, the snap-gap, wall thickness, and clip depth.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Trellis / vine clip
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

wire_d    = 5;    // diameter of the trellis wire / stake the clip grips
stem_d    = 9;    // diameter of the plant stem the clip cradles
wall      = 2.4;  // wall thickness of both rings
gap_frac  = 0.55; // snap-opening as a fraction of the inner diameter
depth     = 12;   // extrusion depth (clip width along Z)
$fn = 64;

wire_or = wire_d / 2 + wall;
stem_or = stem_d / 2 + wall;
spacing = wire_or + stem_or - wall;  // overlap so the two rings merge

// A single open C-ring: a full ring minus a wedge slice for the snap mouth.
module c_ring(inner_d, w, open_frac) {
    half = asin(min(1, max(0, open_frac)) * inner_d / 2 / (inner_d / 2 + w));
    difference() {
        tube(h = depth, id = inner_d, wall = w, anchor = BOTTOM);
        // Cut the mouth opening facing +X.
        rotate_extrude(angle = 2 * half)
            zrot(-half)
            right(inner_d / 2 - 0.5)
                square([inner_d / 2 + w + 1, depth + 2]);
    }
}

union() {
    // Wire-gripping C-clip, mouth facing outward (+X).
    c_ring(wire_d, wall, gap_frac);
    // Stem-cradling C-clip, mouth facing the other way (-X), offset along X.
    right(spacing)
        zrot(180)
            c_ring(stem_d, wall, gap_frac);
}
`);

Open in editor →

Bottle watering spike

A slow-release watering spike that screws into a standard PET bottle neck and drips into the soil through a hollow pointed stake with side weep holes. Bored hollow with a through-channel so water flows; prints as one shell. Tune the bottle-neck diameter, spike length, bore, and weep holes.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Bottle watering spike
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

neck_d     = 25;  // outer diameter of the bottle-neck collar
neck_h     = 18;  // collar height that grips the inverted bottle neck
spike_len  = 75;  // length of the soil spike below the collar
spike_d    = 18;  // spike diameter at the collar (tapers to a tip)
bore_d     = 6;   // inner water channel diameter
weep_d     = 2.5; // diameter of the side weep holes
$fn = 64;

difference() {
    union() {
        // Collar that slips over / threads into the bottle neck.
        cyl(h = neck_h, d = neck_d, rounding = 2, anchor = BOTTOM);
        // Tapered soil spike pointing down. Overlap into the collar so the
        // two bodies fuse into one shell.
        down(spike_len)
            cyl(h = spike_len + 2, d1 = 2, d2 = spike_d, anchor = BOTTOM);
    }
    // Hollow water channel, open at the top. It stops part-way down where the
    // spike is still safely wider than the bore, so the tapered tip stays a
    // connected solid plug (no severed floating piece).
    bore_stop = 35;  // distance the bore reaches below the collar
    down(bore_stop)
        cyl(h = bore_stop + neck_h + 1, d = bore_d, anchor = BOTTOM);
    // Side weep holes that connect the bore to the soil, kept inside the
    // bored region and shorter than the spike so they don't sever a ring.
    for (i = [0 : 3]) {
        zrot(i * 90)
            down(bore_stop - 8)
                right(spike_d / 6)
                    xrot(90)
                        cyl(h = spike_d * 0.7, d = weep_d, anchor = CENTER,
                            $fn = 20);
    }
}
`);

Open in editor →

GT2 timing pulley

A GT2 timing-belt pulley with 2 mm pitch tooth grooves and a flange on each end to keep the belt tracking. The default 20-tooth size is the common 3D-printer X/Y pulley. Tune the tooth count, bore, belt width, and flange size. Add a flat or grub-screw later if you need to lock it to a shaft.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// GT2 timing pulley
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

teeth    = 20;    // number of belt teeth (20 = standard printer pulley)
bore_d   = 5;     // shaft bore diameter in mm
belt_w   = 6;     // belt width / toothed band height in mm
flange_h = 1;     // flange thickness at each end in mm
flange_o = 1.4;   // how far each flange sticks out past the tip radius in mm
$fn = 96;

pitch       = 2;                       // GT2 pitch = 2 mm
pitch_d     = teeth * pitch / PI;      // pitch diameter
groove_r    = 0.555;                   // GT2 groove radius (tooth valley)
groove_off  = 0.254;                   // groove center offset below pitch line
// outer (tip) radius of the toothed band
tip_r       = pitch_d / 2 + 0.15;
// radius the groove centers sit on
groove_ctr_r = pitch_d / 2 + groove_off + groove_r - 0.40;
flange_r    = tip_r + flange_o;

union() {
    difference() {
        union() {
            // toothed band
            cylinder(h = belt_w, r = tip_r, center = false);
            // bottom flange
            cylinder(h = flange_h, r = flange_r, center = false);
            // top flange
            translate([0, 0, belt_w - flange_h])
                cylinder(h = flange_h, r = flange_r, center = false);
        }
        // cut the GT2 tooth grooves into the band
        for (i = [0 : teeth - 1]) {
            ang = i * 360 / teeth;
            rotate([0, 0, ang])
                translate([groove_ctr_r, 0, -1])
                    cylinder(h = belt_w + 2, r = groove_r, center = false, $fn = 24);
        }
        // center bore
        translate([0, 0, -1])
            cylinder(h = belt_w + 2, d = bore_d, center = false);
    }
}
`);

Open in editor →

Right-angle gusset bracket

A heavy-duty 90 degree angle bracket: two square bolt-down plates meeting at a right angle, braced by a full-height central triangular gusset web so it resists bending under load. Each plate carries a bolt hole. Fuses into one watertight solid that prints with the inside corner on the bed. Tune the plate size, thickness, gusset thickness, and bolt-hole diameter.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Right-angle gusset bracket
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

plate    = 40;   // square plate side length
thick    = 5;    // plate thickness
gusset_t = 6;    // gusset web thickness
hole_d   = 5;    // bolt-hole diameter
$fn = 48;

difference() {
    union() {
        // Bottom plate on the bed.
        cuboid([plate, plate, thick], anchor = BOTTOM + LEFT);
        // Upright plate at the left edge.
        cuboid([thick, plate, plate], anchor = BOTTOM + LEFT);
        // Central triangular gusset web in the X-Z plane, spanning both plates.
        translate([0, -gusset_t / 2, 0])
            linear_extrude(height = gusset_t)
                polygon([[thick, thick], [plate, thick], [thick, plate]]);
    }
    // Hole in the bottom plate.
    translate([plate * 0.7, plate / 2, thick / 2])
        cyl(d = hole_d, h = thick + 2, anchor = CENTER);
    // Hole in the upright plate.
    translate([thick / 2, plate / 2, plate * 0.7]) yrot(90)
        cyl(d = hole_d, h = thick + 2, anchor = CENTER);
}
`);

Open in editor →

Heat-set insert boss

A mounting boss with a tapered pilot bore sized for a brass heat-set threaded insert, plus a chamfered lead-in so the insert seats square. Built from the BOSL2 shape library with rounded fillets for strength. A single printable solid. Tune the boss size and the insert pilot diameters.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Heat-set insert boss
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/shapes3d.scad>

boss_d      = 12;    // outside diameter of the boss (mm)
boss_h      = 10;    // boss height (mm)
insert_top  = 5.0;   // pilot diameter at the mouth (mm) — match your insert's body
insert_tip  = 4.6;   // pilot diameter at the bottom (mm) — slight taper grips the melt
insert_h    = 8;     // depth of the insert pilot bore (mm)
$fn = 64;

difference() {
    // Solid boss with a rounded base fillet for a strong joint.
    cyl(d = boss_d, h = boss_h, rounding1 = 1.5, chamfer2 = 0.8, anchor = BOTTOM);
    // Tapered pilot bore for the heat-set insert, open at the top.
    up(boss_h - insert_h)
        cyl(d1 = insert_tip, d2 = insert_top, h = insert_h + 0.02,
            chamfer2 = 0.6, anchor = BOTTOM);
}
`);

Open in editor →

Herringbone gear

A double-helical (herringbone) spur gear. The mirrored helical teeth cancel axial thrust while running smoother and quieter than straight-cut teeth, and the chevron pattern prints cleanly without supports. Tune the module, tooth count, thickness, helix angle, and bore.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Herringbone gear
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/gears.scad>

teeth      = 20;   // number of teeth
gear_mod   = 2;    // tooth module in mm
thickness  = 12;   // gear plate thickness in mm
helix_ang  = 30;   // helix angle in degrees
shaft_d    = 6;    // center shaft bore diameter in mm
$fn = 64;

spur_gear(mod = gear_mod, teeth = teeth, thickness = thickness,
          shaft_diam = shaft_d, helical = helix_ang, herringbone = true,
          pressure_angle = 20);
`);

Open in editor →

Bag / chip-bag sealing clip

A springy C-shaped clip that pinches a folded bag closed. Two parallel jaws join at a solid left spine; the narrow mouth gap at the tips lets the printed plastic flex to grip. Built as a union of the spine plus two jaws so it prints flat as one connected piece. Tune the jaw length, width, gap, and spine thickness.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Bag / chip-bag sealing clip
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

jaw_len   = 70;   // length of the gripping jaws (X)
clip_w    = 16;   // width across the clip (Y)
jaw_t     = 3;    // thickness of each jaw
gap       = 1.4;  // mouth gap between jaw tips (the grip)
spine_h   = 14;   // inner height between the jaws at the spine
$fn = 48;

spine_t = 4;  // thickness of the closed hinge spine on the left
outer_h = spine_h + 2 * jaw_t;
full_l  = jaw_len + spine_t;

// Profile in X (along jaws) / Z (height): a left spine column plus a top and a
// bottom jaw. The jaws angle inward at the tips by (spine_h-gap)/2 so the mouth
// pinches to the gap. Union keeps everything one connected ring.
tip_dy = (spine_h - gap) / 2;  // how far each jaw tip closes in toward center

rotate([90, 0, 0])
linear_extrude(height = clip_w, center = true)
    union() {
        // Left spine joining both jaws.
        left((full_l - spine_t) / 2)
            rect([spine_t, outer_h], rounding = 1);
        // Top jaw, tapering inward toward the tip.
        polygon([
            [-full_l / 2 + spine_t * 0.5, spine_h / 2],
            [ full_l / 2,                 gap / 2],
            [ full_l / 2,                 gap / 2 + jaw_t],
            [-full_l / 2 + spine_t * 0.5, spine_h / 2 + jaw_t],
        ]);
        // Bottom jaw, mirrored.
        polygon([
            [-full_l / 2 + spine_t * 0.5, -spine_h / 2 - jaw_t],
            [ full_l / 2,                 -gap / 2 - jaw_t],
            [ full_l / 2,                 -gap / 2],
            [-full_l / 2 + spine_t * 0.5, -spine_h / 2],
        ]);
    }
`);

Open in editor →

Beveled drink coaster

A solid round drink coaster with a beveled top edge and a shallow recessed well to catch condensation drips, plus a fine bottom chamfer for a clean first layer. Tune the diameter, thickness, bevel, and well depth.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Beveled drink coaster
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

coaster_d  = 95;   // outer diameter
coaster_h  = 8;    // overall thickness
top_bevel  = 3;    // chamfer on the top outer edge
well_depth = 1.6;  // depth of the central condensation well
well_inset = 8;    // ring of flat rim left around the well
$fn = 128;

difference() {
    // Solid disc, top edge beveled, base lightly chamfered for first-layer adhesion.
    cyl(h = coaster_h, d = coaster_d,
        chamfer2 = top_bevel, chamfer1 = 0.8, anchor = BOTTOM);
    // Shallow recessed well on top to hold drips, with a soft rounded lip.
    up(coaster_h - well_depth)
        cyl(h = well_depth + 1, d = coaster_d - 2 * (top_bevel + well_inset),
            rounding1 = 1.2, anchor = BOTTOM);
}
`);

Open in editor →

Fridge note clip with magnet pocket

A small spring clip for pinning notes to a fridge. Two tapering jaws join at a solid spine and pinch to a narrow mouth gap to grip paper; a round pocket is carved into the back of the spine to glue in a magnet. Built as a union minus the pocket so it prints as one connected piece. Tune the jaw size, gap, and magnet diameter/depth.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Fridge note clip with magnet pocket
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

body_w    = 28;   // width of the clip (Y)
jaw_len   = 30;   // length of the jaws (X)
jaw_t     = 2.8;  // thickness of each jaw
gap       = 1.0;  // mouth gap at the jaw tips
mouth_h   = 8;    // inner height between jaws at the spine
mag_d     = 12;   // magnet diameter
mag_depth = 2.5;  // magnet pocket depth
$fn = 64;

spine_t = 6;  // thickness of the closed spine (holds the magnet)
outer_h = mouth_h + 2 * jaw_t;
full_l  = jaw_len + spine_t;

difference() {
    // C-clip body: union of spine + two tapering jaws, extruded along Y.
    rotate([90, 0, 0])
    linear_extrude(height = body_w, center = true)
        union() {
            left((full_l - spine_t) / 2)
                rect([spine_t, outer_h], rounding = 1);
            polygon([
                [-full_l / 2 + spine_t * 0.5,  mouth_h / 2],
                [ full_l / 2,                  gap / 2],
                [ full_l / 2,                  gap / 2 + jaw_t],
                [-full_l / 2 + spine_t * 0.5,  mouth_h / 2 + jaw_t],
            ]);
            polygon([
                [-full_l / 2 + spine_t * 0.5, -mouth_h / 2 - jaw_t],
                [ full_l / 2,                 -gap / 2 - jaw_t],
                [ full_l / 2,                 -gap / 2],
                [-full_l / 2 + spine_t * 0.5, -mouth_h / 2],
            ]);
        }
    // Magnet pocket bored into the back (left) face of the spine, toward -X.
    translate([-full_l / 2 - 0.01, 0, 0])
        rotate([0, 90, 0])
            cyl(h = mag_depth + 0.02, d = mag_d, anchor = TOP);
}
`);

Open in editor →

Napkin ring

A simple round napkin ring — a short tube with softly rounded inner and outer rims so it slides over a rolled napkin without catching. Prints flat on its rim with no supports. Tune the inner diameter, wall thickness, and height.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Napkin ring
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

inner_d = 42;   // inner diameter (napkin bundle size)
wall    = 4;    // ring wall thickness
ring_h  = 30;   // ring height
rim_r   = 2;    // rounding on the top and bottom rims
$fn = 128;

tube(h = ring_h, id = inner_d, wall = wall,
     orounding1 = rim_r, orounding2 = rim_r,
     irounding1 = rim_r, irounding2 = rim_r,
     anchor = BOTTOM);
`);

Open in editor →

Soap dish with drain slots

A rounded-rectangle soap dish with a raised lip and a floor cut by parallel drain slots so water runs off and the bar dries. The slotted floor keeps everything one watertight print. Tune the footprint, height, wall, and slot count/width.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Soap dish with drain slots
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

dish_w   = 110;  // outer width (X)
dish_d   = 75;   // outer depth (Y)
dish_h   = 20;   // outer height (Z)
wall     = 2.6;  // outer wall thickness
floor_t  = 2.2;  // slotted floor thickness
round_r  = 6;    // outer corner rounding
slots    = 7;    // number of drain slots
slot_w   = 4;    // width of each drain slot
$fn = 64;

include <BOSL2/std.scad>

inner_w = dish_w - 2 * wall;
inner_d = dish_d - 2 * wall;
pitch   = inner_w / slots;

difference() {
    // Hollow rounded tray.
    difference() {
        cuboid([dish_w, dish_d, dish_h], rounding = round_r, except = [TOP]);
        up(floor_t)
            cuboid([inner_w, inner_d, dish_h], rounding = max(round_r - wall, 1),
                   except = [TOP], anchor = BOTTOM);
    }
    // Drain slots cut through the floor, running along Y.
    for (i = [0 : slots - 1]) {
        x = -inner_w / 2 + pitch / 2 + i * pitch;
        translate([x, 0, -dish_h / 2 - 1])
            cuboid([slot_w, inner_d - 8, floor_t + 2], rounding = slot_w / 2 - 0.2,
                   edges = [FRONT, BACK], anchor = BOTTOM);
    }
}
`);

Open in editor →

Sink sponge holder

A sink-side sponge tray with tall slotted side walls for airflow and a slotted floor for drainage, so a wet sponge dries from every side. Walls and floor are cut from a rounded open box so it stays one watertight print. Tune the footprint, height, wall, and slot spacing.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Sink sponge holder
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

tray_w   = 130;  // outer width (X)
tray_d   = 75;   // outer depth (Y)
tray_h   = 45;   // outer height (Z)
wall     = 2.6;  // wall thickness
floor_t  = 2.2;  // floor thickness
round_r  = 5;    // outer corner rounding
slot_w   = 6;    // width of the ventilation/drain slots
$fn = 48;

inner_w = tray_w - 2 * wall;
inner_d = tray_d - 2 * wall;

// Slots along the long walls (cut in X-direction openings through Y walls).
nx = floor(inner_w / (slot_w * 2));
pitch_x = inner_w / nx;
// Floor drain slots running along X.
nf = floor(inner_d / (slot_w * 2));
pitch_f = inner_d / nf;

difference() {
    // Hollow rounded tray.
    difference() {
        cuboid([tray_w, tray_d, tray_h], rounding = round_r, except = [TOP]);
        up(floor_t)
            cuboid([inner_w, inner_d, tray_h], rounding = max(round_r - wall, 1),
                   except = [TOP], anchor = BOTTOM);
    }
    // Vertical vent slots through both long (front/back) walls.
    for (i = [0 : nx - 1]) {
        x = -inner_w / 2 + pitch_x / 2 + i * pitch_x;
        translate([x, 0, floor_t + (tray_h - floor_t) / 2])
            cuboid([slot_w, tray_d + 2, tray_h - floor_t - 8],
                   rounding = slot_w / 2 - 0.2, edges = [TOP, BOTTOM]);
    }
    // Floor drain slots running along X.
    for (j = [0 : nf - 1]) {
        y = -inner_d / 2 + pitch_f / 2 + j * pitch_f;
        translate([0, y, -tray_h / 2 - 1])
            cuboid([inner_w - 10, slot_w, floor_t + 2],
                   rounding = min(slot_w / 2 - 0.2, (floor_t + 2) / 2 - 0.4),
                   edges = [LEFT, RIGHT], anchor = BOTTOM);
    }
}
`);

Open in editor →

Toothbrush holder

A round bathroom cup with a perforated top deck — drilled holes hold toothbrushes upright while the open base below lets water drain to the floor of the cup. One watertight print with a chamfered base. Tune the diameter, height, hole count, and hole size.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Toothbrush holder
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

cup_d    = 70;   // outer diameter
cup_h    = 100;  // overall height
wall     = 2.6;  // wall thickness
floor_t  = 3;    // base floor thickness
deck_t   = 4;    // thickness of the perforated top deck
holes    = 4;    // number of brush holes
hole_d   = 13;   // diameter of each brush hole
$fn = 96;

ring_r = cup_d / 4;  // radius of the hole circle

difference() {
    union() {
        // Outer wall.
        up(floor_t)
            tube(h = cup_h - floor_t, od = cup_d, wall = wall, anchor = BOTTOM);
        // Solid floor.
        cyl(h = floor_t, d = cup_d, chamfer1 = 0.8, anchor = BOTTOM);
        // Top perforated deck spanning the bore.
        up(cup_h - deck_t)
            cyl(h = deck_t, d = cup_d - 0.01, anchor = BOTTOM);
    }
    // Brush holes through the deck.
    for (i = [0 : holes - 1]) {
        a = i * 360 / holes;
        translate([ring_r * cos(a), ring_r * sin(a), cup_h - deck_t - 1])
            cyl(h = deck_t + 2, d = hole_d, anchor = BOTTOM);
    }
}
`);

Open in editor →

Cutlery caddy (4 bays)

A countertop cutlery caddy split into four open bays by internal dividers, with rounded corners and a slotted floor so rinse water drains away. Pockets and slots are carved from a rounded block so it prints as one watertight piece. Tune the footprint, height, walls, and bay count.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Cutlery caddy (4 bays)
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

caddy_w  = 150;  // outer width (X) — split into bays
caddy_d  = 65;   // outer depth (Y)
caddy_h  = 110;  // outer height (Z)
wall     = 2.6;  // outer wall + divider thickness
floor_t  = 2.4;  // floor thickness
round_r  = 5;    // outer corner rounding
bays     = 4;    // number of cutlery bays
$fn = 48;

inner_w  = caddy_w - 2 * wall;
pocket_w = (inner_w - (bays - 1) * wall) / bays;
pocket_d = caddy_d - 2 * wall;
pocket_h = caddy_h - floor_t;

difference() {
    cuboid([caddy_w, caddy_d, caddy_h], rounding = round_r, except = [TOP]);
    // Open bay per compartment.
    for (i = [0 : bays - 1]) {
        x0 = -caddy_w / 2 + wall + i * (pocket_w + wall);
        translate([x0 + pocket_w / 2, 0, -caddy_h / 2 + floor_t])
            cuboid([pocket_w, pocket_d, pocket_h + 1],
                   rounding = max(round_r - wall, 0.6), except = [TOP], anchor = BOTTOM);
        // Two drain slots through the floor of each bay.
        for (s = [-1, 1])
            translate([x0 + pocket_w / 2 + s * pocket_w / 4, 0, -caddy_h / 2 - 1])
                cuboid([3.5, pocket_d - 10, floor_t + 2], rounding = 1.5,
                       edges = [FRONT, BACK], anchor = BOTTOM);
    }
}
`);

Open in editor →

Idler pulley with bore

A grooved idler/guide pulley for round belt or cord, with a center bore to run on a shaft or bushing. The V-groove keeps the belt tracked; two flanges contain it. Printed as one watertight solid. Tune the outer diameter, groove depth, width, and bore to suit your belt and shaft.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Idler pulley with bore
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

outer_d    = 24;   // flange (rim) outer diameter
groove_d   = 18;   // diameter at the bottom of the V-groove
width      = 10;   // overall axial width
bore_d     = 6;    // center bore diameter
flange_t   = 2;    // thickness of each outer flange
$fn = 120;

groove_w = width - 2 * flange_t;   // axial width of the groove mouth

difference() {
    // solid body of revolution: two flanges + V-groove between them
    rotate_extrude($fn = 120)
        polygon([
            [bore_d/2,        0],
            [outer_d/2,       0],
            [outer_d/2,       flange_t],
            [groove_d/2,      width/2],
            [outer_d/2,       width - flange_t],
            [outer_d/2,       width],
            [bore_d/2,        width],
        ]);
    // clean through bore
    down(1)
        cylinder(h = width + 2, d = bore_d, $fn = 96);
}
`);

Open in editor →

Knuckle hinge leaf

One leaf of a classic knuckle (butt) hinge — a flat plate with rounded barrel knuckles and a through pin bore, built from BOSL2 attachable primitives as a single printable solid. Print two and join with a pin rod. Tune the leaf size, knuckle count, barrel diameter, and pin bore.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Knuckle hinge leaf
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

leaf_w     = 40;   // leaf width along the hinge axis
leaf_d     = 25;   // leaf depth (away from the barrel)
leaf_t     = 3;    // leaf plate thickness
barrel_d   = 9;    // outer diameter of the barrel knuckles
pin_d      = 3.2;  // pin bore diameter through the knuckles
knuckles   = 3;    // number of knuckles on this leaf
gap        = 0.4;  // gap between this leaf's knuckles (for the mating leaf)
$fn = 48;

barrel_r  = barrel_d / 2;
seg_pitch = leaf_w / (2 * knuckles - 1);   // knuckle + matching gap

difference() {
  union() {
    // Flat leaf plate; barrel axis runs along X, plate reaches back from it
    translate([0, barrel_r, 0])
      cuboid([leaf_w, leaf_d, leaf_t]);
    // Knuckle barrels along the X axis, overlapping the plate front edge
    for (i = [0 : knuckles - 1]) {
      xpos = -leaf_w/2 + seg_pitch/2 + i * 2 * seg_pitch;
      translate([xpos, 0, 0])
        xcyl(l = seg_pitch - gap, d = barrel_d);
    }
  }
  // Pin bore through every knuckle
  xcyl(l = leaf_w + 2, d = pin_d);
}
`);

Open in editor →

Knurled knob (threaded bore)

A grippy diamond-knurled control knob with an internally threaded blind bore so it screws onto a bolt or shaft, generated by the BOSL2 cylinder texture + threading libraries. A single printable solid. Tune the knob diameter, height, thread size and pitch.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Knurled knob (threaded bore)
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/threading.scad>

knob_d   = 30;    // outside diameter of the knob (mm)
knob_h   = 16;    // overall knob height (mm)
thread_d = 8;     // bore thread major diameter (mm)
pitch    = 1.25;  // bore thread pitch (mm)
bore_h   = 12;    // depth of the threaded bore (mm)
$fn = 96;

difference() {
    // Knurled grip body with a domed-ish flat top.
    cyl(d = knob_d, h = knob_h, rounding2 = 3, chamfer1 = 1,
        texture = "diamonds", tex_size = [3, 3], tex_depth = 0.9,
        anchor = BOTTOM);
    // Internal thread, cut from the bottom up.
    up(-0.01)
        threaded_nut_hole();
}

module threaded_nut_hole() {
    // Female thread carved into the body.
    threaded_rod(d = thread_d, l = bore_h + 0.02, pitch = pitch,
                 internal = true, bevel = false, blunt_start = false,
                 anchor = BOTTOM);
}
`);

Open in editor →

Rounded L-bracket

A right-angle mounting bracket with two filleted flanges and countersunk-free thru-holes on each face. The 90 degree inside corner is reinforced so it prints as one watertight solid. Tune the flange length, width, plate thickness, corner rounding, and bolt-hole diameter.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Rounded L-bracket
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

leg     = 40;   // length of each flange
width   = 30;   // bracket width (depth)
thick   = 4;    // plate thickness
round_r = 3;    // outer corner rounding radius
hole_d  = 4.5;  // bolt-hole diameter
$fn = 48;

difference() {
    union() {
        // Horizontal flange lying on the bed.
        cuboid([leg, width, thick], rounding = round_r,
               edges = [FRONT + LEFT, FRONT + RIGHT, BACK + LEFT, BACK + RIGHT],
               anchor = BOTTOM + LEFT);
        // Vertical flange standing up at the left edge.
        left(0)
            cuboid([thick, width, leg], rounding = round_r,
                   edges = [FRONT + TOP, FRONT + BOTTOM, BACK + TOP, BACK + BOTTOM],
                   anchor = BOTTOM + LEFT);
    }
    // Bolt hole through the horizontal flange.
    up(-1) translate([leg * 0.6, 0, 0])
        cyl(d = hole_d, h = thick + 2, anchor = BOTTOM);
    // Bolt hole through the vertical flange.
    translate([thick / 2, 0, leg * 0.6])
        xrot(0) yrot(90)
            cyl(d = hole_d, h = thick + 2, anchor = CENTER);
}
`);

Open in editor →

M8 hex bolt

A real ISO-metric M8 hex-head bolt with a properly cut helical thread, generated by the BOSL2 screws library. A single printable solid (head + threaded shaft). Tune the metric size, shank length, threaded length, and fit tolerance.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// M8 hex bolt
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/screws.scad>

bolt_size  = "M8";   // metric thread designation (e.g. M6, M8, M10)
bolt_len   = 30;     // overall shaft length below the head (mm)
thread_len = 22;     // length of the threaded section (mm), rest is plain shank
tolerance  = "6g";   // ISO external-thread fit class
$fn = 48;

screw(bolt_size, head = "hex", length = bolt_len, thread_len = thread_len,
      tolerance = tolerance, anchor = BOTTOM);
`);

Open in editor →

M8 hex nut

A real ISO-metric M8 hex nut with an internally cut helical thread, generated by the BOSL2 screws library. A single printable solid that mates with an M8 bolt. Tune the metric size, nut thickness, and internal-thread fit tolerance.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// M8 hex nut
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/screws.scad>

nut_size  = "M8";   // metric thread designation (e.g. M6, M8, M10)
thickness = 6.5;    // nut height (mm)
tolerance = "6H";   // ISO internal-thread fit class
$fn = 64;

nut(nut_size, thickness = thickness, thread = "coarse",
    tolerance = tolerance, anchor = BOTTOM);
`);

Open in editor →

NEMA17 motor mount plate

An L-shaped NEMA17 stepper mount: a vertical face plate with the standard 22 mm pilot bore and four 31 mm-spaced M3 bolt holes, joined to a horizontal base flange (with its own slots) by a stiffening rib. Dimensions follow the NEMA17 standard. Prints as one solid. Tune the plate size, thickness, bore, bolt-hole diameter, and base depth.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// NEMA17 motor mount plate
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

plate    = 50;    // square face-plate side length
thick    = 5;     // plate thickness
bore_d   = 23;    // center pilot bore (NEMA17 boss is 22 mm)
hole_sp  = 31;    // NEMA17 bolt-hole spacing (centre to centre)
bolt_d   = 3.4;   // M3 clearance hole
base_d   = 35;    // depth of the horizontal base flange
$fn = 56;

difference() {
    union() {
        // Vertical face plate, standing in the X=0 plane.
        cuboid([thick, plate, plate], rounding = 3,
               edges = [FRONT + TOP, FRONT + BOTTOM, BACK + TOP, BACK + BOTTOM],
               anchor = BOTTOM + LEFT);
        // Horizontal base flange.
        cuboid([base_d, plate, thick], rounding = 3,
               edges = [RIGHT + FRONT, RIGHT + BACK],
               anchor = BOTTOM + LEFT);
        // Triangular stiffening ribs on each side.
        for (y = [-plate / 2, plate / 2 - thick])
            translate([0, y, 0])
                linear_extrude(height = thick)
                    polygon([[0, 0], [base_d * 0.7, 0], [0, plate * 0.55]]);
    }
    // Center pilot bore through the face plate.
    translate([thick / 2, plate / 2, plate / 2]) yrot(90)
        cyl(d = bore_d, h = thick + 2, anchor = CENTER);
    // Four NEMA17 bolt holes.
    for (dy = [-hole_sp / 2, hole_sp / 2], dz = [-hole_sp / 2, hole_sp / 2])
        translate([thick / 2, plate / 2 + dy, plate / 2 + dz]) yrot(90)
            cyl(d = bolt_d, h = thick + 2, anchor = CENTER);
    // Two base mounting holes.
    for (dy = [-plate / 3, plate / 3])
        translate([base_d * 0.7, plate / 2 + dy, thick / 2])
            cyl(d = bolt_d + 1, h = thick + 2, anchor = CENTER);
}
`);

Open in editor →

PCO-1810 bottle cap

A standards-compliant PCO-1810 screw cap that fits the common 28mm PET soda/water bottle neck finish, generated by the BOSL2 bottlecaps library. Tune the cap height, wall thickness, and knurl texture for grip.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// PCO-1810 bottle cap
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/bottlecaps.scad>

cap_h    = 14.5;     // overall cap height (mm) — must clear the tamper ring (>=14.1)
cap_wall = 1.6;      // side + top wall thickness (mm)
$fn = 96;

pco1810_cap(h = cap_h, wall = cap_wall, texture = "knurled");
`);

Open in editor →

Pencil & tool cup

A round desktop cup for pens, pencils, and small tools, with a rounded top rim and a solid floor. Built from a BOSL2 tube with a chamfered base disc so it prints cleanly without supports. Tune the outer diameter, height, wall thickness, and floor thickness.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Pencil & tool cup
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

cup_d   = 75;   // outer diameter
cup_h   = 95;   // overall height
wall    = 2.4;  // wall thickness
floor_t = 3;    // floor thickness
rim_r   = 1.5;  // rounding radius on the top rim
$fn = 96;

union() {
    // Hollow wall: a tube standing on the floor, top rim rounded.
    up(floor_t)
        tube(h = cup_h - floor_t, od = cup_d, wall = wall,
             orounding2 = rim_r, irounding2 = rim_r, anchor = BOTTOM);
    // Solid floor disc, slightly chamfered at the base for a clean first layer.
    cyl(h = floor_t, d = cup_d, chamfer1 = 0.8, anchor = BOTTOM);
}
`);

Open in editor →

Round pill container body

A pocket-sized round pill bottle body with an external screw thread at the mouth, rounded shoulders, and a closed bottom, built with the BOSL2 threading helix. Pairs with a matching screw lid. Tune the body diameter, height, wall thickness, and thread pitch.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Round pill container body
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/threading.scad>

body_d   = 32;    // outer body diameter (mm)
body_h   = 45;    // total height including the threaded neck (mm)
wall     = 1.8;   // wall + bottom thickness (mm)
neck_d   = 24;    // threaded neck outer diameter (mm)
neck_h   = 10;    // threaded neck height (mm)
pitch    = 3;     // thread pitch (mm)
$fn = 96;

thread_depth = pitch * 0.5;
inner_d      = body_d - 2*wall;
neck_id      = neck_d - 2*wall;
shoulder_h   = 6;                       // tapered shoulder height (mm)
barrel_h     = body_h - neck_h - shoulder_h;

union() {
    // closed-bottom barrel
    difference() {
        cyl(d = body_d, h = barrel_h, anchor = BOTTOM, rounding1 = 3);
        up(wall) cyl(d = inner_d, h = barrel_h, anchor = BOTTOM);
    }
    // tapered shoulder from barrel down-to neck (hollow)
    up(barrel_h)
        difference() {
            cyl(d1 = body_d, d2 = neck_d, h = shoulder_h, anchor = BOTTOM);
            cyl(d1 = inner_d, d2 = neck_id, h = shoulder_h + 0.02, anchor = BOTTOM);
        }
    // threaded neck tube
    up(barrel_h + shoulder_h)
        tube(od = neck_d, id = neck_id, h = neck_h, anchor = BOTTOM);
    // external thread fused into the neck wall
    up(barrel_h + shoulder_h)
        thread_helix(
            d            = neck_d - thread_depth,
            pitch        = pitch,
            thread_depth = thread_depth,
            flank_angle  = 30,
            turns        = (neck_h - pitch) / pitch,
            lead_in      = pitch,
            anchor       = BOTTOM
        );
}
`);

Open in editor →

2:1 reduction pinion

A 12-tooth pinion that meshes with the 24-tooth spur gear in this set to give an exact 2:1 gear ratio. Print this and the spur gear, set them one pitch-distance apart, and the small gear turns twice for every turn of the large one. Tune the module, tooth count, thickness, and bore.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// 2:1 reduction pinion
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/gears.scad>

teeth     = 12;   // teeth on this pinion (24/12 = 2:1 vs the spur gear)
gear_mod  = 2;    // tooth module in mm (must match the mating gear)
thickness = 8;    // gear plate thickness in mm
shaft_d   = 5;    // center shaft bore diameter in mm
$fn = 64;

spur_gear(mod = gear_mod, teeth = teeth, thickness = thickness,
          shaft_diam = shaft_d, pressure_angle = 20);
`);

Open in editor →

Pipe / rod mounting clamp

A one-piece pipe stand-off: a closed cylindrical collar that a pipe or rod passes through, fused to a flat mounting foot with two bolt holes that screws to a wall or panel. The bore is sized for a slip fit. Prints flat as a single watertight solid, no supports. Tune the pipe diameter, wall thickness, collar length, foot width, and bolt-hole size.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Pipe / rod mounting clamp
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

pipe_d   = 20;   // diameter of the pipe / rod it holds
wall     = 4;    // collar wall thickness
length   = 22;   // collar length along the pipe axis
foot_w   = 18;   // width of each mounting foot
hole_d   = 4.5;  // bolt-hole diameter
$fn = 64;

collar_od = pipe_d + 2 * wall;
foot_th   = wall;                 // foot thickness
span      = collar_od + 2 * foot_w; // overall foot span

difference() {
    union() {
        // Collar tube lying along the X axis, resting on the bed.
        up(collar_od / 2)
            xrot(90)
                tube(id = pipe_d, wall = wall, h = length, anchor = CENTER);
        // Flat mounting foot under the collar.
        cuboid([length, span, foot_th], rounding = 3, except = [TOP],
               anchor = BOTTOM);
    }
    // Two bolt holes through the feet, clear of the collar.
    for (y = [collar_od / 2 + foot_w / 2, -(collar_od / 2 + foot_w / 2)])
        translate([0, y, foot_th / 2])
            cyl(d = hole_d, h = foot_th + 2, anchor = CENTER);
}
`);

Open in editor →

Rack (linear gear)

A straight gear rack: the flat, linear counterpart of a spur gear. A meshing pinion of the same module converts rotation into linear travel. Tune the module, number of teeth (rack length), thickness, width, and the solid backing below the teeth.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Rack (linear gear)
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/gears.scad>

gear_mod   = 2;    // tooth module in mm (match the pinion)
teeth      = 12;   // number of teeth (sets rack length)
thickness  = 8;    // overall height in mm
width      = 10;   // depth of the rack along the tooth in mm
backing    = 4;    // solid material below the tooth roots in mm
$fn = 32;

rack(mod = gear_mod, teeth = teeth, thickness = thickness,
     width = width, backing = backing, pressure_angle = 20);
`);

Open in editor →

Internal ring gear

An internal ring (annular) gear with teeth cut on the inside, the outer ring of a planetary gearset. A meshing spur gear of the same module rolls around the inside. Tune the module, tooth count, thickness, and the solid backing wall thickness behind the teeth.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Internal ring gear
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/gears.scad>

teeth      = 48;   // number of internal teeth
gear_mod   = 2;    // tooth module in mm (match the meshing spur gear)
thickness  = 8;    // ring thickness in mm
backing    = 4;    // solid wall thickness behind the teeth in mm
$fn = 64;

ring_gear(mod = gear_mod, teeth = teeth, thickness = thickness,
          backing = backing, pressure_angle = 20);
`);

Open in editor →

Bore roller / conveyor wheel

A barrel-shaped roller (conveyor / guide wheel) with a center bore to spin on a shaft or bushing. The crowned (slightly barrelled) profile self-centers a belt or load and the rounded ends resist edge wear. Printed as one watertight solid. Tune the body diameter, crown, length, and bore.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Bore roller / conveyor wheel
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

body_d   = 20;   // diameter at the ends of the roller
crown    = 1.5;  // extra radius bulge at the middle (barrel crown)
length   = 24;   // axial length of the roller
bore_d   = 8;    // center bore diameter
end_rnd  = 1.0;  // rounding on the end edges
$fn = 120;

mid_d = body_d + 2 * crown;   // diameter at the crowned middle

difference() {
    // barrelled body of revolution
    rotate_extrude($fn = 120)
        polygon([
            [bore_d/2,   0],
            [body_d/2,   0],
            [mid_d/2,    length/2],
            [body_d/2,   length],
            [bore_d/2,   length],
        ]);
    // through bore
    down(1)
        cylinder(h = length + 2, d = bore_d, $fn = 96);
}
`);

Open in editor →

Rounded storage box base

A hollow box base with softly rounded outer corners and an open top, sized for small parts and hardware. Built from a rounded BOSL2 cuboid with an inner cavity subtracted. Tune the footprint, height, wall thickness, corner rounding, and floor thickness.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Rounded storage box base
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

box_w   = 80;   // outer width (X)
box_d   = 55;   // outer depth (Y)
box_h   = 35;   // outer height (Z)
wall    = 2.4;  // side wall thickness
floor_t = 2.4;  // floor thickness
round_r = 5;    // outer corner rounding radius
$fn = 64;

difference() {
    // Outer rounded shell, sharp top edge for a clean rim.
    cuboid([box_w, box_d, box_h], rounding = round_r, except = [TOP]);
    // Inner cavity: floor left solid, open + slightly over-cut at the top.
    up(-box_h / 2 + floor_t)
        cuboid(
            [box_w - 2 * wall, box_d - 2 * wall, box_h],
            rounding = max(round_r - wall, 0.5),
            except = [TOP],
            anchor = BOTTOM
        );
}
`);

Open in editor →

Rounded box with lid

A clean filleted enclosure with rounded edges and a friction-fit lid, using BOSL2 rounding + attachments. Tune the outer size, wall thickness, corner rounding, and lid height.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Rounded box with lid
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

box_w   = 60;   // outer width
box_d   = 40;   // outer depth
box_h   = 30;   // outer height (base part)
wall    = 2;    // wall thickness
round_r = 4;    // corner rounding radius
$fn = 48;

// Hollow base: outer rounded cuboid minus an inner rounded cavity.
difference() {
    cuboid([box_w, box_d, box_h], rounding = round_r, except = [TOP]);
    up(wall)
        cuboid([box_w - 2 * wall, box_d - 2 * wall, box_h], rounding = round_r - wall > 0 ? round_r - wall : 0.5, except = [TOP]);
}
`);

Open in editor →

Capsule (stadium solid)

A cylinder capped by hemispheres on both ends — the 3D stadium / pill shape, built by revolving a stadium profile into one watertight solid. Tune the radius and the straight mid-section length.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Capsule (stadium solid)
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

cap_r    = 12;   // radius of the tube and the end caps
mid_len  = 40;   // length of the straight middle section
segs     = 64;   // surface resolution

half = mid_len / 2;

// Half-profile (X = radius, Y = height): bottom cap arc, straight side, top cap arc.
prof = concat(
    [ for (a = [-90 : 180 / segs : -0.0001])
        [cap_r * cos(a), -half + cap_r * sin(a)] ],          // bottom hemisphere
    [ for (a = [0 : 180 / segs : 90])
        [cap_r * cos(a),  half + cap_r * sin(a)] ],          // top hemisphere
    [[0, half + cap_r], [0, -half - cap_r]]                  // close along the axis
);

rotate_extrude($fn = segs)
    polygon(prof);
`);

Open in editor →

Chamfered box

A solid box with flat 45-degree chamfers cut on every edge for a crisp faceted look. Tune the side lengths and the chamfer depth.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Chamfered box
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

box_w    = 50;   // width  (X)
box_d    = 50;   // depth  (Y)
box_h    = 30;   // height (Z)
chamf    = 5;    // chamfer depth on every edge
$fn = 32;

cuboid([box_w, box_d, box_h], chamfer = chamf);
`);

Open in editor →

Filleted wedge ramp

A right-triangular wedge / ramp solid with its long top edge rounded into a smooth fillet. Tune the footprint, the rise, and the fillet radius.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Filleted wedge ramp
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

base_len = 60;   // ramp run (X)
width    = 30;   // ramp width (Y)
rise     = 28;   // ramp height (Z)
fillet_r = 6;    // radius of the rounded top edge
$fn = 48;

// A wedge minus a rounded prism subtracted from its sharp apex edge,
// realised by intersecting the wedge with an over-sized rounded block.
intersection() {
    wedge([base_len, width, rise]);
    translate([0, 0, -1])
        cuboid([base_len + 2, width, rise + 2], rounding = fillet_r,
               edges = [TOP + FRONT], anchor = CENTER);
}
`);

Open in editor →

Cone frustum

A truncated cone (frustum) with a wider base and narrower top, edges softly rounded. Tune the two radii, the height, and the rounding.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Cone frustum
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

r_base   = 25;   // bottom radius
r_top    = 14;   // top radius
frust_h  = 35;   // height
round_r  = 2;    // rim rounding radius
$fn = 64;

cyl(h = frust_h, r1 = r_base, r2 = r_top, rounding = round_r);
`);

Open in editor →

Hexagonal prism

A regular six-sided prism with softly rounded vertical edges. Tune the across-flats radius, the height, and the side count to make other regular prisms.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Hexagonal prism
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

sides    = 6;    // number of sides (6 = hex, 8 = oct, ...)
radius   = 20;   // circumscribed radius (center to vertex)
prism_h  = 30;   // height
round_r  = 1.5;  // vertical edge rounding
$fn = 48;

regular_prism(n = sides, h = prism_h, r = radius, rounding = round_r);
`);

Open in editor →

Octagonal prism

A regular eight-sided prism with a chamfered top and bottom rim for a faceted token look. Tune the radius, height, side count, and chamfer.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Octagonal prism
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

sides    = 8;    // number of sides (8 = oct)
radius   = 18;   // circumscribed radius (center to vertex)
prism_h  = 22;   // height
chamf    = 2;    // top/bottom rim chamfer
$fn = 48;

regular_prism(n = sides, h = prism_h, r = radius, chamfer = chamf);
`);

Open in editor →

Onion dome finial

A bulbous onion-dome solid that swells out then tapers to a point, sitting on a short cylindrical drum — a classic finial / cupola cap. Tune the bulge, height, and base.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Onion dome finial
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

base_r   = 16;   // drum (base) radius
bulge_r  = 22;   // widest radius of the bulb
dome_h   = 50;   // total height of the bulb above the drum
drum_h   = 8;    // height of the cylindrical base drum
segs     = 96;   // surface resolution

// Profile in the X(radius)-Y(height) plane, revolved into a solid.
// Drum then an onion curve: out to the bulge, in to a point at the top.
prof = concat(
    [[0, 0], [base_r, 0], [base_r, drum_h]],
    [ for (i = [0 : segs])
        let (
            t  = i / segs,                          // 0..1 up the bulb
            // radius: swell to bulge near the bottom, taper to 0 at the top
            rr = (bulge_r) * sin(180 * pow(t, 0.7)) * (1 - t) + base_r * (1 - t),
            zz = drum_h + dome_h * t
        )
        [max(rr, 0.01), zz]
    ],
    [[0, drum_h + dome_h]]
);

rotate_extrude($fn = segs)
    polygon(prof);
`);

Open in editor →

Rounded cuboid

A solid box with all twelve edges rounded into smooth fillets. Tune the three side lengths and the corner radius.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Rounded cuboid
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

box_w   = 60;   // width  (X)
box_d   = 40;   // depth  (Y)
box_h   = 25;   // height (Z)
round_r = 6;    // edge rounding radius
$fn = 48;

cuboid([box_w, box_d, box_h], rounding = round_r);
`);

Open in editor →

Spindle / lens solid

A symmetric spindle (lens) made by revolving a circular arc — a fat lens that tapers to points at both poles. Tune the equatorial radius and the bulge height.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Spindle / lens solid
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

eq_radius = 22;   // equatorial radius (widest point)
half_h    = 26;   // half-height (pole to equator)
segs      = 96;   // surface resolution

// Circular arc through the bottom pole (0,-half_h), the equator (eq_radius,0)
// and the top pole (0,half_h). Center sits on the X axis at cx.
arc_r = (eq_radius * eq_radius + half_h * half_h) / (2 * eq_radius);
cx    = eq_radius - arc_r;                       // arc center X (may be negative)
ang   = atan2(half_h, -cx);                      // half-sweep of the arc

// Right-side profile from bottom pole up to top pole (all X >= 0), then
// close straight down the revolution axis.
prof = concat(
    [ for (a = [-ang : 2 * ang / segs : ang])
        [max(cx + arc_r * cos(a), 0), arc_r * sin(a)] ],
    [[0, half_h], [0, -half_h]]
);

rotate_extrude($fn = segs)
    polygon(prof);
`);

Open in editor →

Super-egg (superellipsoid)

A Piet Hein style super-egg — a superellipsoid that stands on its own end. Tune the radii and the superellipse exponent for a rounder or boxier profile.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Super-egg (superellipsoid)
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

rad_xy = 22;    // equatorial radius (X and Y)
rad_z  = 32;    // polar half-height (Z)
expo   = 2.5;   // superellipse exponent (>2 = squarer, <2 = pointier)
segs   = 96;    // surface resolution

// Build a superellipse cross-section and revolve it into a solid of revolution.
prof = [
    for (a = [0 : 360 / segs : 360 - 0.001])
        let (
            ca = cos(a), sa = sin(a),
            x = rad_xy * sign(ca) * pow(abs(ca), 2 / expo),
            y = rad_z  * sign(sa) * pow(abs(sa), 2 / expo)
        )
        if (x >= 0) [x, y]
];

rotate_extrude($fn = segs)
    polygon(prof);
`);

Open in editor →

Torus ring

A solid donut/ring shape defined by the major (centerline) radius and the minor (tube) radius. Tune both radii and the facet counts.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Torus ring
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

r_major = 30;   // distance from center to tube center
r_minor = 9;    // tube radius
seg_maj = 64;   // segments around the ring
seg_min = 32;   // segments around the tube

torus(r_maj = r_major, r_min = r_minor, $fn = seg_maj);
`);

Open in editor →

Shelf bracket with gusset

A load-bearing shelf bracket: a vertical wall plate, a horizontal shelf flange, and a triangular diagonal gusset web tying the two together for stiffness. Wall and shelf carry mounting holes. The whole part fuses into one watertight solid. Tune the wall height, shelf reach, width, thickness, and hole diameter.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Shelf bracket with gusset
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

wall_h  = 50;   // height of the wall-mount plate
reach   = 45;   // how far the shelf flange sticks out
width   = 24;   // bracket width
thick   = 5;    // plate / gusset thickness
hole_d  = 5;    // mounting-hole diameter
$fn = 48;

difference() {
    union() {
        // Vertical wall plate (mounts to the wall, sits in the X=0 plane).
        cuboid([thick, width, wall_h], anchor = BOTTOM + LEFT);
        // Horizontal shelf flange.
        cuboid([reach, width, thick], anchor = BOTTOM + LEFT);
        // Diagonal triangular gusset in the X-Z plane, extruded across the width.
        translate([0, -width / 2, 0])
            linear_extrude(height = width)
                polygon([[0, 0], [reach, 0], [0, wall_h]]);
    }
    // Two holes in the wall plate.
    for (z = [wall_h * 0.55, wall_h * 0.85])
        translate([thick / 2, 0, z]) yrot(90)
            cyl(d = hole_d, h = thick + 2, anchor = CENTER);
    // Two holes in the shelf flange.
    for (x = [reach * 0.55, reach * 0.85])
        translate([x, 0, thick / 2])
            cyl(d = hole_d, h = thick + 2, anchor = CENTER);
}
`);

Open in editor →

Stepped shoulder bushing

A two-diameter shoulder bushing: a smaller pilot diameter that drops into a bore and a larger shoulder that registers depth and takes face load. Printed as one watertight solid with a clean through bore. Tune the pilot and shoulder diameters and lengths, plus the bore for your shaft.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Stepped shoulder bushing
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

pilot_d    = 10;   // pilot (smaller) outer diameter — fits the bore
shoulder_d = 16;   // shoulder (larger) outer diameter — registers depth
bore_d     = 6;    // shaft through bore
pilot_len  = 10;   // length of the pilot section
shoulder_t = 4;    // thickness of the shoulder section
$fn = 96;

difference() {
    union() {
        // shoulder at the bottom
        cyl(h = shoulder_t, d = shoulder_d, chamfer1 = 0.8, anchor = BOTTOM);
        // pilot rising from the shoulder
        up(shoulder_t)
            cyl(h = pilot_len, d = pilot_d, chamfer2 = 0.8, anchor = BOTTOM);
    }
    // through bore
    down(0.5)
        cyl(h = shoulder_t + pilot_len + 1, d = bore_d, anchor = BOTTOM);
}
`);

Open in editor →

Plain sleeve bushing

A simple cylindrical plain (journal) bushing — a printable sleeve that press-fits into a housing bore and gives a shaft a low-friction running surface. The inner and outer edges are chamfered for easy insertion. Tune the outer diameter to your housing, the bore to your shaft (leave running clearance), and the length to suit.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Plain sleeve bushing
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

outer_d  = 12;   // outer diameter (press-fit into housing)
bore_d   = 8;    // shaft bore diameter (add running clearance)
length   = 14;   // axial length of the sleeve
lead_cf  = 1.0;  // lead-in chamfer on both ends
$fn = 96;

tube(h = length, od = outer_d, id = bore_d, chamfer = lead_cf, anchor = BOTTOM);
`);

Open in editor →

Snap-pin socket block

A solid mounting block with a sprung snap-pin socket bored into it — the receiver for the BOSL2 snap pin. The socket geometry comes from the BOSL2 joiners library so the locking-nub catch matches the pin exactly. Tune the block size, socket radius, length, and snap depth.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Snap-pin socket block
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/joiners.scad>

block       = [16, 16, 18];  // outer block size [x, y, z]
socket_r    = 3.5;           // socket radius (match the pin radius)
socket_l    = 16;            // socket depth / length
nub_depth   = 9;             // distance to the locking-nub catch
snap        = 0.6;           // depth of the nub catch
$fn = 48;

diff()
  cuboid(block)
    attach(TOP, TOP, inside = true)
      tag("remove")
        snap_pin_socket(r = socket_r, l = socket_l,
                        nub_depth = nub_depth, snap = snap);
`);

Open in editor →

Snap pin (sprung)

A two-pronged snap pin that clicks into a matching socket and locks with a sprung nub. Generated by the BOSL2 joiners library so the spring slot, nub depth, and clearance are correct. Tune the radius, length, snap depth, prong thickness, and fit clearance.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Snap pin (sprung)
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/joiners.scad>

pin_r      = 3.5;   // outer radius of the pin shaft
pin_l      = 16;    // overall length of the pin
nub_depth  = 9;     // distance from tip to the locking nub
snap       = 0.6;   // depth the locking nub springs out
thickness  = 1.2;   // wall thickness of each prong
clearance  = 0.2;   // fit clearance against the socket
$fn = 48;

snap_pin(r = pin_r, l = pin_l, nub_depth = nub_depth, snap = snap,
         thickness = thickness, clearance = clearance,
         anchor = CENTER, orient = UP);
`);

Open in editor →

Spur gear (involute)

A real meshing spur gear with a correct involute tooth profile and a center bore, generated by the BOSL2 gears library. Tune the module (tooth size), tooth count, thickness, and shaft diameter.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Spur gear (involute)
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/gears.scad>

teeth     = 24;   // number of teeth
gear_mod  = 2;    // module (mm of pitch diameter per tooth)
thickness = 8;    // gear thickness
shaft_d   = 6;    // center bore diameter
$fn = 48;

spur_gear(mod = gear_mod, teeth = teeth, thickness = thickness, shaft_diam = shaft_d);
`);

Open in editor →

Stacking parts bin

An open-front-friendly parts bin whose rounded base nests a matching lip on the bin below, so several stack stably on a shelf. The shell is carved hollow from a rounded block with a recessed underside rim. Tune the footprint, height, wall thickness, floor thickness, and the nesting lip depth.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Stacking parts bin
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

bin_w    = 70;   // outer width (X)
bin_d    = 100;  // outer depth (Y)
bin_h    = 45;   // outer height (Z)
wall     = 2.4;  // wall thickness
floor_t  = 3.6;  // floor thickness (> lip_h so the floor stays solid)
lip_h    = 2;    // depth of the nesting recess under the base
round_r  = 4;    // outer corner rounding radius
$fn = 48;

difference() {
    cuboid([bin_w, bin_d, bin_h], rounding = round_r, except = [TOP]);
    // Interior pocket, open top.
    up(-bin_h / 2 + floor_t)
        cuboid([bin_w - 2 * wall, bin_d - 2 * wall, bin_h],
               rounding = max(round_r - wall, 0.5), except = [TOP], anchor = BOTTOM);
    // Nesting recess in the underside: a shallow pocket matching the rim of the
    // bin below. Kept shallower than the floor so the base stays watertight.
    down(bin_h / 2 + 0.01)
        cuboid([bin_w - 2 * wall + 0.6, bin_d - 2 * wall + 0.6, lip_h],
               rounding = max(round_r - wall, 0.5), except = [TOP], anchor = BOTTOM);
}
`);

Open in editor →

Rubber-foot bumper socket

A screw-down socket that grips a push-in rubber bumper foot: a rounded cylindrical body with a counterbored cavity for the rubber foot's stem and a central screw hole through the bottom. Tune body diameter/height, socket cavity diameter/depth, and screw hole diameter.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Rubber-foot bumper socket
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

body_d    = 24;   // outer body diameter (mm)
body_h    = 12;   // overall body height (mm)
socket_d  = 14;   // rubber-foot cavity diameter (mm)
socket_h  = 7;    // cavity depth from the top (mm)
hole_d    = 4.2;  // central mounting screw hole diameter (mm)
$fn = 64;

difference() {
    // rounded body
    cyl(h = body_h, d = body_d, rounding1 = 2, rounding2 = 4, anchor = BOTTOM);
    // socket cavity for the rubber foot, opening at the top
    up(body_h - socket_h)
        cyl(h = socket_h + 0.1, d = socket_d, rounding1 = 1, anchor = BOTTOM);
    // central mounting screw hole through the floor
    cyl(h = body_h * 3, d = hole_d);
    // counterbore so a flat screw head sits flush on the underside
    down(0.01)
        cyl(h = 3, d = hole_d * 2, anchor = BOTTOM);
}
`);

Open in editor →

Corner brace with triangular gusset

A 90-degree corner brace: two flat mounting tabs joined by a tall triangular gusset web for stiffness, with one screw hole per tab. Tune tab length, plate thickness, gusset height/web thickness, and hole diameter.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Corner brace with triangular gusset
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

tab     = 35;   // length of each mounting tab (mm)
wide    = 22;   // brace width (mm)
thick   = 4;    // tab/plate thickness (mm)
gusset  = 28;   // gusset height up each leg (mm)
web     = 3;    // gusset web thickness (mm)
hole_d  = 5;    // screw hole diameter (mm)
$fn = 48;

difference() {
    union() {
        // horizontal tab on the build plate
        cuboid([tab, wide, thick], rounding = 2, edges = "Z",
               anchor = BOTTOM + LEFT + FRONT);
        // vertical tab standing at the corner
        cuboid([thick, wide, tab], rounding = 2, edges = "Z",
               anchor = BOTTOM + LEFT + FRONT);
        // central triangular gusset web bridging the two tabs.
        // polygon lies in X-Z (corner cross-section); extruded across Y.
        // origin sunk to (0,0) so the triangle legs overlap both plates.
        translate([0, wide / 2 + web / 2, 0])
            rotate([90, 0, 0])
            linear_extrude(height = web)
                polygon([[0, 0], [gusset, 0], [0, gusset]]);
    }
    // horizontal tab hole
    translate([tab * 0.75, wide / 2, thick / 2])
        cyl(h = thick * 3, d = hole_d);
    // vertical tab hole
    translate([thick / 2, wide / 2, tab * 0.75])
        yrot(90)
        cyl(h = thick * 3, d = hole_d);
}
`);

Open in editor →

Rounded L-bracket

A right-angle mounting L-bracket with rounded outer corners, an inner fillet weld at the corner for strength, and four screw holes (two per leg). Tune leg length, width, thickness, hole diameter, and fillet radius.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Rounded L-bracket
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

leg     = 40;   // length of each leg measured from the corner (mm)
wide    = 30;   // bracket width (mm)
thick   = 4;    // plate thickness (mm)
hole_d  = 4.5;  // screw hole diameter (mm)
fillet  = 6;    // inner corner gusset size (mm)
$fn = 48;

// A solid right-triangle (legs along +X and +Y) with the hypotenuse
// rounded concavely toward the corner — the cross-section of a weld bead.
module fillet_profile(s) {
    difference() {
        square([s, s]);
        translate([s, s]) circle(r = s);
    }
}

difference() {
    union() {
        // horizontal leg: thickness in Z, lies on the build plate
        cuboid([leg, wide, thick], rounding = 2, edges = "Z",
               anchor = BOTTOM + LEFT + FRONT);
        // vertical leg: thickness in X, stands up at the corner
        cuboid([thick, wide, leg], rounding = 2, edges = "Z",
               anchor = BOTTOM + LEFT + FRONT);
        // inner fillet weld bead bridging the two legs along the width:
        // a rounded right-triangle extruded across the full width.
        translate([thick, wide, thick])
            xrot(90)
            linear_extrude(height = wide)
                fillet_profile(fillet);
    }
    // horizontal-leg screw holes
    for (x = [leg * 0.55, leg * 0.85])
        translate([x, wide / 2, thick / 2])
            cyl(h = thick * 3, d = hole_d);
    // vertical-leg screw holes
    for (z = [leg * 0.55, leg * 0.85])
        translate([thick / 2, wide / 2, z])
            xrot(0) yrot(90)
                cyl(h = thick * 3, d = hole_d);
}
`);

Open in editor →

Threaded leveling foot

An adjustable leveling foot: a wide rounded base disk topped by a real metric-style threaded stud that screws into a furniture insert. Tune base diameter/height, stud thread diameter, pitch, and stud length. Pairs with a matching threaded insert/nut.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Threaded leveling foot
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/threading.scad>

base_d   = 40;   // base disk diameter (mm)
base_h   = 8;    // base disk height (mm)
stud_d   = 8;    // stud thread outer diameter (mm)
pitch    = 1.25; // thread pitch (mm)
stud_l   = 20;   // threaded stud length (mm)
$fn = 64;

union() {
    // rounded foot base that contacts the floor
    cyl(h = base_h, d = base_d, rounding1 = 1.5, rounding2 = 3, anchor = BOTTOM);
    // short solid neck to blend the threads onto the base
    up(base_h - 0.01)
        cyl(h = 4, d = stud_d + 2, chamfer2 = 1, anchor = BOTTOM);
    // real threaded stud, sunk into the neck so the volumes overlap
    up(base_h + 1)
        threaded_rod(d = stud_d, l = stud_l, pitch = pitch,
                     bevel2 = true, blunt_start = true, anchor = BOTTOM);
}
`);

Open in editor →

Panel snap clip

A cantilever snap-fit clip for retaining a panel or wire: a screw-down base with an upright flexible arm ending in a hooked barb that snaps over a panel edge. Two base bolt holes. Tune base size, arm height/thickness, barb depth, and bolt hole diameter.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Panel snap clip
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

base_l   = 30;   // base length (mm)
base_w   = 16;   // base width (mm)
base_t   = 4;    // base thickness (mm)
arm_h    = 18;   // cantilever arm height (mm)
arm_t    = 3;    // arm thickness (mm)
barb     = 4;    // hook barb overhang depth (mm)
hole_d   = 4;    // base bolt hole diameter (mm)
$fn = 48;

difference() {
    union() {
        // mounting base
        translate([0, 0, base_t / 2])
            cuboid([base_l, base_w, base_t], rounding = 2, edges = "Z");
        // flexible cantilever arm rising from one end of the base
        translate([-base_l / 2 + arm_t / 2, 0, base_t])
            cuboid([arm_t, base_w * 0.7, arm_h],
                   rounding = 1, edges = [FRONT + TOP, BACK + TOP],
                   anchor = BOTTOM);
        // hooked barb at the top of the arm (extends inward over the panel).
        // built as an extruded right-triangle so it prints with a sloped
        // self-supporting underside.
        translate([-base_l / 2, base_w * 0.7 / 2, base_t + arm_h - 2])
            rotate([90, 0, 0])
            linear_extrude(height = base_w * 0.7)
                polygon([
                    [0, 2],
                    [arm_t + barb, 2],
                    [0, -barb * 1.4]
                ]);
    }
    // base bolt holes
    for (x = [base_l * 0.18, base_l * 0.42])
        translate([x, 0, base_t / 2])
            cyl(h = base_t * 4, d = hole_d);
}
`);

Open in editor →

Right-angle gusset plate

A flat triangular gusset plate for reinforcing 90-degree frame joints: a right-triangle web with a thickened ribbed hypotenuse and three bolt holes (one near each corner). Lies flat for printing. Tune leg length, thickness, rib width, and bolt hole diameter.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Right-angle gusset plate
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

leg     = 50;   // length of each right-angle leg (mm)
thick   = 4;    // plate thickness (mm)
rib     = 6;    // raised rib width along the hypotenuse (mm)
rib_h   = 3;    // extra rib height above the plate (mm)
hole_d  = 5;    // bolt hole diameter (mm)
$fn = 48;

inset = leg * 0.18;   // bolt-hole inset from corners

difference() {
    union() {
        // flat triangular web (corner at origin, legs along +X and +Y)
        linear_extrude(height = thick)
            offset(r = 3) offset(r = -3)   // round the sharp tip a touch
                polygon([[0, 0], [leg, 0], [0, leg]]);
        // raised stiffening rib along the hypotenuse
        translate([0, 0, thick])
            linear_extrude(height = rib_h)
                polygon([
                    [leg - rib, 0], [leg, 0],
                    [0, leg], [0, leg - rib]
                ]);
    }
    // three bolt holes near the corners
    for (p = [[inset, inset], [leg - inset * 2, inset], [inset, leg - inset * 2]])
        translate([p[0], p[1], 0])
            cyl(h = (thick + rib_h) * 4, d = hole_d);
}
`);

Open in editor →

Shelf bracket with diagonal strut

A wall-mount shelf bracket: a vertical wall plate, a horizontal shelf plate, and a diagonal strut between them for load support. Wall plate has two keyhole-free round screw holes; shelf plate has one. Tune arm lengths, thickness, width, strut width, and hole diameter.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Shelf bracket with diagonal strut
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

arm     = 60;   // horizontal shelf arm length (mm)
rise    = 60;   // vertical wall plate height (mm)
wide    = 25;   // bracket width (mm)
thick   = 5;    // plate thickness (mm)
strut_w = 6;    // diagonal strut thickness (mm)
hole_d  = 5;    // screw hole diameter (mm)
$fn = 48;

difference() {
    union() {
        // vertical wall plate (thickness in X)
        cuboid([thick, wide, rise], rounding = 2, edges = "Z",
               anchor = BOTTOM + LEFT + FRONT);
        // horizontal shelf plate (thickness in Z)
        cuboid([arm, wide, thick], rounding = 2, edges = "Z",
               anchor = BOTTOM + LEFT + FRONT);
        // diagonal strut: a thick band from wall up-point to shelf out-point.
        // built as an extruded quadrilateral in the X-Z corner plane.
        translate([0, wide / 2 + strut_w / 2, 0])
            rotate([90, 0, 0])
            linear_extrude(height = strut_w)
                polygon([
                    [0, 0],
                    [arm * 0.85, thick],
                    [thick, rise * 0.85]
                ]);
    }
    // wall plate screw holes
    for (z = [rise * 0.30, rise * 0.65])
        translate([thick / 2, wide / 2, z])
            yrot(90)
            cyl(h = thick * 3, d = hole_d);
    // shelf plate screw hole
    translate([arm * 0.78, wide / 2, thick / 2])
        cyl(h = thick * 3, d = hole_d);
}
`);

Open in editor →

Tube / rod clamp with mounting feet

A saddle clamp that holds a tube or rod against a surface: a rounded cradle block with a semicircular channel and two flat mounting feet, each with a bolt hole. Tune tube diameter, wall thickness, foot length, base thickness, width, and bolt hole diameter.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Tube / rod clamp with mounting feet
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

tube_d   = 20;   // tube/rod outer diameter to clamp (mm)
wall     = 4;    // cradle wall above the tube (mm)
foot     = 14;   // length of each mounting foot (mm)
base_t   = 4;    // base plate thickness under the feet (mm)
wide     = 18;   // clamp width along the tube axis (mm)
bolt_d   = 4.5;  // mounting bolt hole diameter (mm)
$fn = 64;

tube_r    = tube_d / 2;
axis_z    = base_t + tube_r;           // tube channel centre height
block_h   = axis_z + wall;             // top of the cradle block
block_w   = tube_d + 2 * wall;         // cradle block width
span      = block_w + 2 * foot;        // total footprint width
foot_ctr  = block_w / 2 + foot / 2;    // bolt-hole x offset

difference() {
    union() {
        // base plate spanning the full footprint with the two feet
        translate([0, 0, base_t / 2])
            cuboid([span, wide, base_t], rounding = 2, edges = "Z");
        // solid cradle block sitting on the base
        translate([0, 0, block_h / 2])
            cuboid([block_w, wide, block_h], rounding = 3,
                   edges = "Z");
    }
    // semicircular tube channel through the block (axis along Y)
    up(axis_z)
        yrot(90)
        cyl(h = wide + 1, d = tube_d, anchor = CENTER);
    // bolt holes through each foot
    for (x = [-foot_ctr, foot_ctr])
        translate([x, 0, base_t / 2])
            cyl(h = base_t * 4, d = bolt_d);
}
`);

Open in editor →

Threaded jar body

A round storage jar with an external screw thread at the mouth and a flat closed bottom, built with the BOSL2 threading helix. Pairs with the matching threaded lid recipe. Tune the body diameter, height, wall thickness, and thread pitch.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Threaded jar body
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/threading.scad>

body_d   = 50;    // outer body diameter (mm)
body_h   = 60;    // total jar height including the threaded neck (mm)
wall     = 2.4;   // wall + bottom thickness (mm)
pitch    = 4;     // thread pitch (mm)
neck_h   = 12;    // height of the threaded neck section (mm)
$fn = 96;

thread_depth = pitch * 0.5;   // derived thread depth (mm)
inner_d      = body_d - 2*wall;

union() {
    // hollow body shell with a closed welded floor
    tube(od = body_d, id = inner_d, h = body_h, anchor = BOTTOM);
    cyl(d = inner_d + 0.02, h = wall, anchor = BOTTOM);   // welded floor
    // external thread fused into the neck wall (root overlaps the wall)
    up(body_h - neck_h)
        thread_helix(
            d            = body_d - thread_depth,
            pitch        = pitch,
            thread_depth = thread_depth,
            flank_angle  = 30,
            turns        = (neck_h - pitch) / pitch,
            lead_in      = pitch,
            anchor       = BOTTOM
        );
}
`);

Open in editor →

Threaded jar lid

A round screw-on lid with an internal thread and a knurled grip skirt, built with the BOSL2 threading helix. Mates with the matching threaded jar body recipe — keep the jar diameter and pitch in sync. Tune the lid diameter, height, wall thickness, and pitch.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Threaded jar lid
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/threading.scad>

jar_d     = 50;    // jar neck outer diameter to fit over (mm)
lid_h     = 14;    // total lid height (mm)
top_t     = 2.4;   // top wall thickness (mm)
skirt_t   = 3;     // skirt wall thickness (mm)
pitch     = 4;     // thread pitch (mm) — match the jar
tol       = 0.4;   // clearance for a free-running fit (mm)
$fn = 96;

thread_depth = pitch * 0.5;
outer_d      = jar_d + 2*skirt_t;
bore_d       = jar_d + tol;            // inner skirt diameter

difference() {
    union() {
        // outer lid shell (closed top, open bottom)
        cyl(d = outer_d, h = lid_h, anchor = BOTTOM, rounding2 = 2);
        // internal thread fused to the bore wall
        internal_thread();
    }
    // hollow out the skirt bore from the underside, leaving the top closed
    up(top_t)
        cyl(d = bore_d, h = lid_h, anchor = BOTTOM);
}

module internal_thread() {
    up(top_t)
        thread_helix(
            d            = bore_d + thread_depth,
            pitch        = pitch,
            thread_depth = thread_depth,
            flank_angle  = 30,
            turns        = (lid_h - top_t - pitch) / pitch,
            lead_in      = pitch,
            internal     = true,
            anchor       = BOTTOM
        );
}
`);

Open in editor →

Threaded rod (metric)

A real metric threaded rod (all-thread / studding) with a true helical ISO thread profile and blunt printable ends, generated by the BOSL2 threading library. A single printable solid. Tune the major diameter, pitch, and overall length.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Threaded rod (metric)
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/threading.scad>

rod_d  = 8;     // major (outer) diameter (mm)
pitch  = 1.25;  // thread pitch (mm) — 1.25 is standard M8 coarse
length = 40;    // overall rod length (mm)
$fn = 64;

threaded_rod(d = rod_d, l = length, pitch = pitch,
             blunt_start = true, bevel = true, anchor = BOTTOM);
`);

Open in editor →

Thrust washer

A flat annular thrust washer that sits between a rotating part and a fixed face to carry axial load and reduce wear. Both faces are flat for full bearing contact, with chamfered edges so it does not snag. Tune the outer and inner diameters to your shaft and seat, and the thickness for the load.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Thrust washer
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

outer_d   = 20;   // outer diameter
bore_d    = 10;   // inner bore diameter (shaft)
thickness = 2;    // washer thickness
edge_cf   = 0.5;  // edge chamfer
$fn = 120;

tube(h = thickness, od = outer_d, id = bore_d, chamfer = edge_cf, anchor = BOTTOM);
`);

Open in editor →

Thumb screw

A real thumb screw: a wide knurled finger grip head fused to a properly threaded metric shaft for tool-free tightening, built from the BOSL2 cylinder texture + threading libraries. A single printable solid. Tune the head diameter, shaft size, pitch and length.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Thumb screw
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/threading.scad>

head_d   = 22;    // knurled grip head diameter (mm)
head_h   = 8;     // head height (mm)
thread_d = 6;     // shaft thread major diameter (mm)
pitch    = 1.0;   // thread pitch (mm) — 1.0 is M6 coarse
shaft_l  = 20;    // threaded shaft length below the head (mm)
$fn = 72;

// Knurled grip head sitting on the build plate.
cyl(d = head_d, h = head_h, rounding1 = 2, chamfer2 = 1,
    texture = "diamonds", tex_size = [3, 3], tex_depth = 0.9,
    anchor = BOTTOM);

// Threaded shaft growing upward out of the head's top face.
up(head_h - 0.5)
    threaded_rod(d = thread_d, l = shaft_l + 0.5, pitch = pitch,
                 blunt_start = true, bevel2 = true, bevel1 = false,
                 anchor = BOTTOM);
`);

Open in editor →

Tool caddy with handle

A two-pocket carry caddy with a central spine and a rounded grab handle, for ferrying tools, brushes, or craft supplies. The pockets, handle hole, and rounded body are all carved from one rounded block so it prints as a single watertight piece. Tune the footprint, height, wall thickness, and handle dimensions.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Tool caddy with handle
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

cad_w     = 130;  // outer width (X)
cad_d     = 70;   // outer depth (Y)
body_h    = 55;   // height of the body up to the handle bridge
wall      = 2.6;  // wall + spine thickness
floor_t   = 2.6;  // floor thickness
handle_h  = 28;   // height of the handle arch above the body
$fn = 40;

// Two pockets either side of a central spine.
pocket_w = (cad_w - 2 * wall - wall) / 2;
pocket_d = cad_d - 2 * wall;
pocket_h = body_h - floor_t;
total_h  = body_h + handle_h;

difference() {
    // Body block plus a handle slab on top, rounded vertical corners.
    union() {
        cuboid([cad_w, cad_d, body_h], rounding = 5, edges = "Z", anchor = BOTTOM);
        // Central handle slab (spans the width), overlapping the body so they fuse.
        // Round only the TOP edges so the slab/body interface stays a clean plane.
        translate([0, 0, body_h - 2])
            cuboid([cad_w, wall * 3, handle_h + 2], rounding = 3,
                   edges = TOP, anchor = BOTTOM);
    }
    // Left and right pockets.
    for (s = [-1, 1])
        translate([s * (wall / 2 + pocket_w / 2), 0, floor_t])
            cuboid([pocket_w, pocket_d, pocket_h + 1],
                   rounding = 3, edges = "Z", anchor = BOTTOM);
    // Hand hole through the slab (plain slot, no end rounding to stay manifold).
    up(body_h + handle_h * 0.45)
        ycyl(h = cad_d + 1, d = handle_h * 0.7);
}
`);

Open in editor →

T-slot joiner clip

A T-slot snap joiner clip from the BOSL2 joiners library — the printable connector that plugs two panels together edge-to-edge with a self-retaining barbed tongue. Tune the length, width, base thickness, and flank angle.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// T-slot joiner clip
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/joiners.scad>

joiner_l   = 40;   // length of the joiner along the join axis
joiner_w   = 10;   // width of the tongue
base_t     = 10;   // base / wall thickness it mounts to
flank_ang  = 30;   // barb flank angle in degrees
$fn = 32;

joiner(l = joiner_l, w = joiner_w, base = base_t, ang = flank_ang);
`);

Open in editor →

Broom / tool clip

A spring-grip wall clip for broom, mop, or rake handles: a screw-mount backplate with a C-shaped jaw whose mouth is narrower than the handle so it snaps on and holds. Tune the handle diameter, mouth opening, jaw thickness, and backplate.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Broom / tool clip
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

handle_d  = 24;   // diameter of the handle to grip
gap       = 14;   // mouth opening (under handle_d so it grips)
jaw_t     = 4;    // jaw wall thickness
plate_w   = 40;   // backplate width
plate_t   = 5;    // backplate thickness
plate_h   = 30;   // backplate height (along the handle axis)
screw_d   = 4.5;  // screw clearance bore
$fn = 72;

bore_r  = handle_d / 2;
outer_r = bore_r + jaw_t;
overlap = jaw_t * 0.8;
// Jaw centre lifted off the plate so the outer ring fuses with the backplate.
jaw_y   = plate_t + outer_r - overlap;

union() {
    // Backplate flush to wall (back at y=0, extends to y=plate_t).
    difference() {
        cuboid([plate_w, plate_t, plate_h], rounding = 3, edges = "Y", anchor = BOTTOM + FRONT);
        translate([0, 0, plate_h * 0.5]) {
            ycyl(h = plate_t * 3, d = screw_d, anchor = CENTER);
            translate([0, plate_t, 0]) ycyl(h = screw_d, d1 = screw_d * 2.2, d2 = screw_d, anchor = FRONT);
        }
    }

    // C-shaped jaw: axis runs vertically (Z), opening faces away from the wall (+Y).
    translate([0, jaw_y, plate_h * 0.5])
        difference() {
            zcyl(h = plate_h, r = outer_r, rounding = 1);
            zcyl(h = plate_h + 0.4, r = bore_r);
            // Mouth slot opening toward +Y (away from the wall).
            fwd(0) back(outer_r / 2)
                cube([gap, outer_r + 0.4, plate_h + 0.4], center = true);
        }
}
`);

Open in editor →

Screw-mount cable clip

A screw-mount cable clip with a flat slotted backing tab and a rounded saddle that holds one or more cables against a wall or desk edge. The screw slot lets you snug it down over the cables. Tune the cable diameter, saddle width, tab length, and screw bore.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Screw-mount cable clip
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

cable_d   = 7;    // diameter of cable(s) to hold
saddle_w  = 14;   // width of the holding saddle (along cable axis)
wall      = 2.5;  // saddle wall thickness
tab_len   = 14;   // length of the screw tab beside the saddle
tab_t     = 3;    // backing / tab thickness
screw_d   = 4;    // screw clearance bore
$fn = 64;

bore_r  = cable_d / 2;
outer_r = bore_r + wall;
overlap = wall * 0.7;
saddle_z = tab_t + outer_r - overlap;

union() {
    // Backing strip the whole assembly sits on (back on z=0, against wall when
    // laid flat; printable as a single flat-bottomed solid).
    base_w = saddle_w;
    base_l = outer_r * 2 + tab_len;
    cuboid([base_w, base_l, tab_t], rounding = 1.5, edges = "Z", anchor = BOTTOM);

    // Screw tab: extends out one side with a countersunk hole.
    difference() {
        translate([0, base_l/2 - tab_len/2, 0])
            cuboid([base_w * 0.8, tab_len, tab_t], rounding = 3, edges = "Z", anchor = BOTTOM);
        translate([0, base_l/2 - tab_len/2 + 2, 0]) {
            cyl(h = tab_t * 3, d = screw_d, anchor = CENTER);
            up(tab_t) cyl(h = screw_d, d1 = screw_d * 2.2, d2 = screw_d, anchor = TOP);
        }
    }

    // Cable saddle: a tube section (axis along the cable / Y) with the top
    // opened so cables press in, sitting over the base near the other side.
    translate([0, -base_l/2 + outer_r, saddle_z])
        difference() {
            xcyl(h = saddle_w, r = outer_r, rounding = 1);
            xcyl(h = saddle_w + 0.4, r = bore_r);
            up(outer_r/2) cube([saddle_w + 0.4, gap_open(), outer_r + 0.4], center = true);
        }
}

// Mouth opening a touch narrower than the cable so cables snap and stay.
function gap_open() = cable_d * 0.55;
`);

Open in editor →

Double coat hook

A double coat hook with two outward-curving prongs on a single screw-mount backplate, ideal for hanging two coats or a coat and a scarf. Tune the backplate size, prong reach, prong thickness, and screw bore.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Double coat hook
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

plate_w   = 34;   // backplate width
plate_h   = 60;   // backplate height
plate_t   = 6;    // backplate thickness
prong_len = 22;   // horizontal reach of each prong
prong_r   = 5;    // prong radius
screw_d   = 4.5;  // screw clearance bore
$fn = 56;

module prong(z) {
    // A prong sweeps straight out from the wall then tips up into a small hook.
    pts = concat(
        [ for (x = [0:2:prong_len]) [x, 0, 0] ],
        [ for (a = [0:8:120]) [prong_len + sin(a) * prong_r * 1.4,
                               0,
                               (1 - cos(a)) * prong_r * 1.4] ]
    );
    translate([0, plate_t * 0.5, z])
        path_sweep(circle(r = prong_r), path3d(deduplicate(pts)), closed = false);
}

union() {
    difference() {
        cuboid([plate_w, plate_t, plate_h], rounding = 5, edges = "Y", anchor = BOTTOM + BACK);
        // Two screw holes (top and bottom) with countersinks.
        for (z = [plate_h - 10, 10]) {
            up(z) ycyl(h = plate_t * 3, d = screw_d, anchor = CENTER);
            up(z) back(0.1) ycyl(h = screw_d, d1 = screw_d * 2.2, d2 = screw_d, anchor = BACK);
        }
    }
    prong(plate_h * 0.62);
    prong(plate_h * 0.30);
}
`);

Open in editor →

French-cleat hook

A French-cleat hanger: the back face is bevelled at 45 degrees to drop over a matching wall-mounted cleat rail, and the front carries an upward hook arm. Self-locking and tool-free to mount. Tune the body size, cleat angle, hook reach, and arm thickness.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// French-cleat hook
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

body_w    = 40;   // width of the cleat block
body_h    = 50;   // height of the cleat block
body_t    = 18;   // depth (thickness) of the block, front-to-back
cleat_ang = 45;   // bevel angle of the cleat slot
arm_reach = 28;   // how far the front hook reaches out
arm_r     = 5;    // hook arm radius
$fn = 56;

// Body sits with its back face on the y=0 plane and extends forward to y=body_t.
union() {
    // Cleat body with a 45-degree wedge groove cut into the back face so it
    // hooks downward onto a matching wall rail. The groove is kept shallow
    // (depth < body_t) so the block stays one connected piece.
    difference() {
        cuboid([body_w, body_t, body_h], rounding = 2, edges = "Y", anchor = BOTTOM + FRONT);
        // Wedge slot: removes a 45deg triangular notch from the BACK face in
        // the upper region. The back face is at y=0; the cutter is centred just
        // behind it and rotated so its lower face slopes up-and-forward,
        // forming the cleat's bearing surface. Kept short in depth so the front
        // half of the block stays solid and connected.
        translate([0, 0, body_h * 0.72])
            xrot(cleat_ang)
            cuboid([body_w + 2, body_t * 0.9, body_h], anchor = BACK);
    }

    // Front hook arm: sweeps out from the FRONT face (+Y) and curls up (+Z).
    // Path is built directly in (y=out, z=up); start slightly inside the body
    // so the swept tube fuses with the block.
    pts = concat(
        [ for (y = [-arm_r:2:arm_reach]) [0, y, 0] ],
        [ for (a = [0:8:120]) [0,
                               arm_reach + sin(a) * arm_r * 1.6,
                               (1 - cos(a)) * arm_r * 1.6] ]
    );
    translate([0, body_t, body_h * 0.20])
        path_sweep(circle(r = arm_r), deduplicate(pts), closed = false);
}
`);

Open in editor →

J-hook wall hanger

A deep J-shaped hook on a screw-mount backplate for hanging tools, mugs, utensils, or cables. The long curved tail makes items easy to lift on and off. Tune the backplate, hook drop, hook radius, and bar thickness.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// J-hook wall hanger
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

plate_w  = 26;   // backplate width
plate_h  = 30;   // backplate height
plate_t  = 5;    // backplate thickness
reach    = 24;   // how far the hook reaches out from the wall
drop     = 28;   // how far the J curls back down
bar_r    = 4;    // thickness (radius) of the hook bar
screw_d  = 4.5;  // screw clearance bore
$fn = 56;

union() {
    difference() {
        cuboid([plate_w, plate_t, plate_h], rounding = 4, edges = "Y", anchor = BOTTOM + BACK);
        up(plate_h - 8) ycyl(h = plate_t * 3, d = screw_d, anchor = CENTER);
        up(plate_h - 8) back(0.1) ycyl(h = screw_d, d1 = screw_d * 2.2, d2 = screw_d, anchor = BACK);
    }

    // The J: out from the wall, then a half-circle curl down and back.
    out_pts  = [ for (x = [0:2:reach]) [x, 0, 0] ];
    curl_pts = [ for (a = [0:8:180]) [reach + sin(a) * (drop/2),
                                      0,
                                      -(1 - cos(a)) * (drop/2)] ];
    pts = deduplicate(concat(out_pts, curl_pts));
    translate([0, plate_t * 0.5, plate_h * 0.5])
        path_sweep(circle(r = bar_r), path3d(pts), closed = false);
}
`);

Open in editor →

Key rail with hooks

A horizontal screw-mount key rail: a rounded backing bar with a row of small upward hooks for keys, lanyards, or jewellery, plus screw holes at each end. Tune the rail length, number of hooks, hook size, and bar thickness.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Key rail with hooks
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

rail_len  = 120;  // overall length of the rail
rail_h    = 22;   // height of the backing bar
rail_t    = 6;    // thickness of the backing bar
n_hooks   = 4;    // number of key hooks
hook_r    = 2.5;  // hook bar radius
screw_d   = 4.5;  // screw clearance bore
$fn = 40;

module key_hook() {
    // Small hook: out from the bar then curling up.
    pts = concat(
        [ for (y = [-hook_r:1:6]) [0, y, 0] ],
        [ for (a = [0:12:150]) [0, 6 + sin(a) * hook_r * 2, (1 - cos(a)) * hook_r * 2] ]
    );
    path_sweep(circle(r = hook_r), deduplicate(pts), closed = false);
}

union() {
    // Backing bar: back face on y=0, extends forward to y=rail_t.
    difference() {
        cuboid([rail_len, rail_t, rail_h], rounding = 3, edges = "Y", anchor = BOTTOM + FRONT);
        // Screw holes near each end with countersinks (drilled along +Y).
        for (sx = [-1, 1]) {
            translate([sx * (rail_len/2 - 9), 0, rail_h * 0.5])
                ycyl(h = rail_t * 3, d = screw_d, anchor = CENTER);
            translate([sx * (rail_len/2 - 9), rail_t, rail_h * 0.5])
                ycyl(h = screw_d, d1 = screw_d * 2.2, d2 = screw_d, anchor = FRONT);
        }
    }
    // Row of evenly spaced hooks along the lower front edge.
    for (i = [0 : n_hooks - 1]) {
        x = -rail_len/2 + rail_len * (i + 0.5) / n_hooks;
        translate([x, rail_t, rail_h * 0.25]) key_hook();
    }
}
`);

Open in editor →

Pegboard hook

A pegboard hook that plugs into standard 1-inch-pitch pegboard: two rear pegs drop into adjacent holes and a forward arm holds tools. Tune the peg diameter, pegboard pitch, board thickness, arm reach, and bar thickness. Default pitch 25.4 mm and peg 5.5 mm suit common 6 mm pegboard.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Pegboard hook
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

peg_d     = 5.5;   // pegboard peg diameter (fits ~6mm holes)
pitch     = 25.4;  // pegboard hole pitch (1 inch)
board_t   = 6;     // pegboard panel thickness
arm_reach = 35;    // how far the front arm sticks out
bar_r     = 4;     // arm / spine thickness (radius)
$fn = 48;

// Geometry: a vertical spine sits against the front of the board (y=0 plane is
// the board's front face). Two pegs poke back (-Y) into holes one pitch apart;
// the lower peg hooks down behind the board to lock. A front arm sweeps out.
spine_h = pitch + bar_r * 2;

union() {
    // Vertical spine against the board face (swept for a rounded body).
    spine_pts = [ for (z = [0:2:spine_h]) [0, bar_r, z] ];
    path_sweep(circle(r = bar_r), deduplicate(spine_pts), closed = false);

    // Top peg: straight back into the upper hole.
    top_pts = [ for (y = [bar_r : -2 : -(board_t + 3)]) [0, y, spine_h] ];
    path_sweep(circle(r = peg_d/2), deduplicate(top_pts), closed = false);

    // Bottom peg: back into the lower hole then curl DOWN behind the board so
    // the hook cannot pull straight out (the classic pegboard lock).
    bot_back = [ for (y = [bar_r : -2 : -(board_t + 2)]) [0, y, 0] ];
    bot_curl = [ for (a = [0:12:90]) [0,
                                      -(board_t + 2) - sin(a) * 4,
                                      -(1 - cos(a)) * 6] ];
    path_sweep(circle(r = peg_d/2), deduplicate(concat(bot_back, bot_curl)), closed = false);

    // Front holding arm sweeps out (+Y) from the lower spine and tips up.
    arm = concat(
        [ for (y = [bar_r : 2 : arm_reach]) [0, y, bar_r] ],
        [ for (a = [0:10:120]) [0, arm_reach + sin(a) * bar_r * 1.5, bar_r + (1 - cos(a)) * bar_r * 1.5] ]
    );
    path_sweep(circle(r = bar_r), deduplicate(arm), closed = false);
}
`);

Open in editor →

Screw-mount wall hook

A simple screw-mount wall hook: a flat rounded backplate with a countersunk screw hole and an upward-curving arm to hang coats, bags, or towels. Tune the backplate size, arm reach, hook depth, and screw bore.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Screw-mount wall hook
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>

plate_w   = 30;   // backplate width (against wall)
plate_h   = 44;   // backplate height
plate_t   = 5;    // backplate thickness
arm_reach = 26;   // how far the hook sticks out from the wall
arm_r     = 5;    // radius of the round hook arm
screw_d   = 4.5;  // screw clearance bore diameter
$fn = 64;

union() {
    // Flat backplate flush against the wall (wall face = back, at y=0 plane).
    difference() {
        cuboid([plate_w, plate_t, plate_h], rounding = 4, edges = "Y", anchor = BOTTOM + BACK);
        // Countersunk screw hole near the top, drilled through the plate (along +Y).
        up(plate_h - 9)
            ycyl(h = plate_t * 3, d = screw_d, anchor = CENTER);
        // Countersink cone on the front face.
        up(plate_h - 9) back(0.1)
            ycyl(h = screw_d, d1 = screw_d * 2.2, d2 = screw_d, anchor = BACK);
        // Lower screw hole for stability.
        up(9)
            ycyl(h = plate_t * 3, d = screw_d, anchor = CENTER);
        up(9) back(0.1)
            ycyl(h = screw_d, d1 = screw_d * 2.2, d2 = screw_d, anchor = BACK);
    }

    // The hook arm: a curved tube sweeping out from the lower-middle of the plate
    // and curling upward to catch the hung item.
    arm_z = plate_h * 0.35;
    pts = [
        for (a = [0:6:90])
            [ sin(a) * arm_reach, plate_t * 0.5 + (1 - cos(a)) * (arm_reach * 0.6) ]
    ];
    // Build the arm as a swept circle along an L-then-up path in the XZ-ish plane.
    translate([0, plate_t * 0.5, arm_z])
    yrot(0)
    path_sweep(circle(r = arm_r),
        path3d([ for (p = pts) [p[0], 0, p[1]] ]),
        closed = false);
}
`);

Open in editor →

Wing nut

A real wing nut: an internally threaded barrel with two flat finger wings for hand-tightening, built from the BOSL2 threading and shape libraries. A single printable solid. Tune the thread size and pitch, body height, and wing span.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Wing nut
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/threading.scad>

thread_d  = 8;     // thread major diameter (mm)
pitch     = 1.25;  // thread pitch (mm)
body_h    = 10;    // height of the threaded barrel (mm)
wing_span = 38;    // total tip-to-tip span across the wings (mm)
wing_h    = 7;     // wing height (mm)
$fn = 72;

difference() {
    union() {
        // Threaded barrel.
        cyl(d = thread_d + 6, h = body_h, rounding = 1, anchor = BOTTOM);
        // Two finger wings.
        up(wing_h / 2)
            prismoid(size1 = [wing_span, 5], size2 = [wing_span * 0.55, 3.5],
                     h = wing_h, rounding = 1.0, anchor = CENTER);
    }
    // Internal thread through the barrel.
    down(0.01)
        threaded_rod(d = thread_d, l = body_h + 0.02, pitch = pitch,
                     internal = true, bevel = false, blunt_start = false,
                     anchor = BOTTOM);
}
`);

Open in editor →

Worm gear

The wheel half of a worm drive: a throated spur gear whose teeth are curved to wrap around a mating worm screw. Pairing a worm with this wheel gives a high reduction, self-locking right-angle drive. Tune the module, tooth count, worm diameter, worm starts, and bore.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Worm gear
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/gears.scad>

teeth       = 30;  // teeth on the worm wheel
gear_mod    = 2;   // tooth module in mm (match the worm)
worm_d      = 15;  // pitch diameter of the mating worm in mm
worm_starts = 1;   // number of thread starts on the worm
shaft_d     = 6;   // center shaft bore diameter in mm
$fn = 48;

worm_gear(mod = gear_mod, teeth = teeth, worm_diam = worm_d,
          worm_starts = worm_starts, shaft_diam = shaft_d,
          pressure_angle = 20);
`);

Open in editor →

Worm screw (drive)

The screw half of a worm drive: a helical thread that turns the mating worm wheel. One full turn of the worm advances the wheel by one tooth (per start), giving a large, self-locking reduction. Print this plus the worm gear wheel. Tune the module, length, diameter, and thread starts.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Worm screw (drive)
//
// Source: BOSL2 (BelfrySCAD) — BSD-2-Clause
// https://github.com/BelfrySCAD/BOSL2
// Generated from the library above, used under its license.

include <BOSL2/std.scad>
include <BOSL2/gears.scad>

gear_mod    = 2;   // tooth module in mm (match the worm wheel)
worm_d      = 15;  // pitch diameter in mm (match the wheel's worm_diam)
worm_len    = 40;  // worm length in mm
worm_starts = 1;   // number of thread starts
$fn = 48;

worm(mod = gear_mod, d = worm_d, l = worm_len, starts = worm_starts,
     pressure_angle = 20);
`);

Open in editor →

2020 corner bracket (3-way)

A 3-way corner bracket that joins three 2020 aluminium extrusions at a right-angle corner, with M5 bolt holes. From the adgaudio OpenSCAD_connectors library.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// 2020 corner bracket (3-way)
//
// Source: OpenSCAD_connectors (adgaudio) — MIT
// Generated from the library above, used under its license.

include <oscad-connectors/_defaults.scad>
use <oscad-connectors/connector.scad>
use <oscad-connectors/corner_bracket.scad>
use <oscad-connectors/grid.scad>
use <oscad-connectors/repeat_grid.scad>

corner_bracket(2, 2, 2);
`);

Open in editor →

2020 corner bracket (flat L)

A flat L-shaped bracket that joins two 2020 aluminium extrusions in-plane, with M5 bolt holes. From the adgaudio OpenSCAD_connectors library.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// 2020 corner bracket (flat L)
//
// Source: OpenSCAD_connectors (adgaudio) — MIT
// Generated from the library above, used under its license.

include <oscad-connectors/_defaults.scad>
use <oscad-connectors/connector.scad>
use <oscad-connectors/corner_bracket.scad>
use <oscad-connectors/grid.scad>
use <oscad-connectors/repeat_grid.scad>

corner_bracket(2, 2, 0);
`);

Open in editor →

2020 extrusion end cap

A press-fit end cap that closes the open end of a 20x20 aluminium extrusion, with an M5 bolt clearance hole. From the adgaudio OpenSCAD_connectors library.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// 2020 extrusion end cap
//
// Source: OpenSCAD_connectors (adgaudio) — MIT
// Generated from the library above, used under its license.

include <oscad-connectors/_defaults.scad>
use <oscad-connectors/endcap.scad>
use <oscad-connectors/grid.scad>
use <oscad-connectors/repeat_grid.scad>

endcap(20, 20, 8, 2, m5_hole_tight);
`);

Open in editor →

2020 T-slot extrusion bar

A length of standard 2020 aluminium-style T-slot extrusion (20 by 20 mm cross section) with four T-channels, ready to print as a jig rail, frame member, or mock-up of real metal extrusion. Change the length to suit your build.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// 2020 T-slot extrusion bar
//
// Source: OpenSCAD_AluminumExtrusionProfile_Library — Apache-2.0
// Generated from the library above, used under its license.

include <extrusion-profiles/AluminumExtrusionProfile.scad>

$fn = 80;

length = 120;  // bar length in mm

linear_extrude(height = length)
  2020_extrusion_profile(slot = "t");
`);

Open in editor →

2040 V-slot extrusion rail

A length of 2040 aluminium-style extrusion (40 by 20 mm cross section) cut with V-shaped channels, the kind used for CNC and 3D-printer gantries that ride on V-wheels. Print it as a linear-motion rail mock-up or a sturdy frame member.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// 2040 V-slot extrusion rail
//
// Source: OpenSCAD_AluminumExtrusionProfile_Library — Apache-2.0
// Generated from the library above, used under its license.

include <extrusion-profiles/AluminumExtrusionProfile.scad>

$fn = 80;

length = 160;  // rail length in mm

linear_extrude(height = length)
  2040_extrusion_profile(slot = "v");
`);

Open in editor →

2060 extrusion base bar

A length of wide 2060 aluminium-style extrusion (60 by 20 mm cross section) with six T-channels across its face, perfect as a base bar or work-surface rail that needs lots of mounting slots. Resize the length for benches, fixtures, or camera sliders.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// 2060 extrusion base bar
//
// Source: OpenSCAD_AluminumExtrusionProfile_Library — Apache-2.0
// Generated from the library above, used under its license.

include <extrusion-profiles/AluminumExtrusionProfile.scad>

$fn = 80;

length = 140;  // bar length in mm

linear_extrude(height = length)
  2060_extrusion_profile(slot = "t");
`);

Open in editor →

3030 T-slot extrusion beam

A length of 3030 aluminium-style extrusion (30 by 30 mm cross section) with four T-channels, a popular mid-weight size for printer frames, camera rigs, and shelving. Print it as a structural beam and adjust the length to fit your build.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// 3030 T-slot extrusion beam
//
// Source: OpenSCAD_AluminumExtrusionProfile_Library — Apache-2.0
// Generated from the library above, used under its license.

include <extrusion-profiles/AluminumExtrusionProfile.scad>

$fn = 80;

length = 130;  // beam length in mm

linear_extrude(height = length)
  3030_extrusion_profile(slot = "t");
`);

Open in editor →

4040 heavy-duty extrusion post

A short length of beefy 4040 aluminium-style extrusion (40 by 40 mm cross section) with eight T-channels, ideal as a corner post or load-bearing upright in a printed frame. Lengthen it for a full column or keep it short as a connector block.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// 4040 heavy-duty extrusion post
//
// Source: OpenSCAD_AluminumExtrusionProfile_Library — Apache-2.0
// Generated from the library above, used under its license.

include <extrusion-profiles/AluminumExtrusionProfile.scad>

$fn = 80;

length = 80;  // post length in mm

linear_extrude(height = length)
  4040_extrusion_profile(slot = "t");
`);

Open in editor →

Gridfinity storage bin 2x1x3

A printable Gridfinity storage bin two grid cells wide, one deep, and three units tall, with magnet and screw pockets in the base and a finger-slide scoop for easy parts removal.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Gridfinity storage bin 2x1x3
//
// Source: vector76-gridfinity — MIT
// https://github.com/kennetek/gridfinity-rebuilt-openscad
// Generated from the library above, used under its license.

include <gridfinity-vector76/gridfinity_modules.scad>
use <gridfinity-vector76/gridfinity_cup_modules.scad>

$fn = 32;

basic_cup(
  num_x = 2,
  num_y = 1,
  num_z = 3,
  chambers = 1,
  withLabel = "disabled",
  labelWidth = 0,
  fingerslide = true,
  magnet_diameter = 6.5,
  screw_depth = 6,
  floor_thickness = 1.2,
  wall_thickness = 0.95,
  hole_overhang_remedy = false,
  efficient_floor = false,
  half_pitch = false,
  lip_style = "normal",
  box_corner_attachments_only = false
);
`);

Open in editor →

Gridfinity divided bin with label shelf

A printable Gridfinity bin three cells wide and two deep, split into three chambers by internal dividers, with a sloped label shelf across the front for marking each compartment.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Gridfinity divided bin with label shelf
//
// Source: vector76-gridfinity — MIT
// https://github.com/kennetek/gridfinity-rebuilt-openscad
// Generated from the library above, used under its license.

include <gridfinity-vector76/gridfinity_modules.scad>
use <gridfinity-vector76/gridfinity_cup_modules.scad>

$fn = 32;

basic_cup(
  num_x = 3,
  num_y = 2,
  num_z = 4,
  chambers = 3,
  withLabel = "left",
  labelWidth = 0,
  fingerslide = true,
  magnet_diameter = 0,
  screw_depth = 0,
  floor_thickness = 1.0,
  wall_thickness = 0.95,
  hole_overhang_remedy = false,
  efficient_floor = false,
  half_pitch = false,
  lip_style = "normal",
  box_corner_attachments_only = false
);
`);

Open in editor →

Gridfinity glue stick holder

A printable Gridfinity cup sized to cradle a standard glue stick upright, with a snug bored pocket and a slightly flared mouth so the stick drops in and lifts out cleanly.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Gridfinity glue stick holder
//
// Source: vector76-gridfinity — MIT
// https://github.com/kennetek/gridfinity-rebuilt-openscad
// Generated from the library above, used under its license.

cup_height = 5;
stick_diameter = 30;

include <gridfinity-vector76/gridfinity_glue_stick.scad>
`);

Open in editor →

Gridfinity socket wrench holder

A printable Gridfinity tray that holds a row of socket-wrench sockets at a 45-degree tilt for easy grabbing, with an engraved size label along the front edge.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Gridfinity socket wrench holder
//
// Source: vector76-gridfinity — MIT
// https://github.com/kennetek/gridfinity-rebuilt-openscad
// Generated from the library above, used under its license.

include <gridfinity-vector76/gridfinity_modules.scad>
use <gridfinity-vector76/gridfinity_socket_holder.scad>

$fn = 32;

socket_holder(4, [12, 12, 12, 13, 14, 16, 16, 17, 21, 22], "METRIC", num_z = 5);
`);

Open in editor →

Gridfinity weighted baseplate 3x2

A printable Gridfinity baseplate three cells wide and two deep with hollow pockets in the underside for steel weights or screws, giving the grid a heavy, stable footing on the desk.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Gridfinity weighted baseplate 3x2
//
// Source: vector76-gridfinity — MIT
// https://github.com/kennetek/gridfinity-rebuilt-openscad
// Generated from the library above, used under its license.

include <gridfinity-vector76/gridfinity_modules.scad>
use <gridfinity-vector76/gridfinity_baseplate.scad>

$fn = 32;

weighted_baseplate(3, 2);
`);

Open in editor →

608 bearing pillow block

A printable pillow-block housing sized from the official ISO bearing table for the popular 608 skate bearing, with a press-fit pocket, a shoulder lip so the bearing seats square, and two mounting-bolt holes. Drop a real 608 bearing in and bolt it to a frame.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// 608 bearing pillow block
//
// Source: OpenSCAD-hardware-database — BSD-2-Clause
// Generated from the library above, used under its license.

include <hardware-db/lib/_hardware.scad>
include <hardware-db/lib/_3d_print.scad>
include <hardware-db/lib/_functions.scad>

$fn = 96;

// --- look up the real 608 bearing dimensions from the ISO table ---
bb       = GetDataTable("608", BB);
bore     = bb[BBDia];        //  8 mm
od       = bb[BBOuterDia];   // 22 mm
bwidth   = bb[BBHeight];     //  7 mm

// --- look up an M4 mounting bolt clearance from the bolt table ---
m4       = GetDataTable("M4", Bolt);
bolt_clr = m4[BoltDia];      // ~4.1 mm clearance

wall     = 4;                // wall around the bearing pocket
lip      = 1.2;             // shoulder that stops the bearing
base_h   = 3;               // baseplate thickness
press    = 0.05;            // press-fit interference

block_d  = od + 2 * wall;
block_w  = block_d + 2 * (bolt_clr + wall);  // room for bolt ears

module pillow_block() {
    difference() {
        union() {
            // round bearing boss
            cylinder(d = block_d, h = bwidth + base_h);
            // mounting base slab
            translate([-block_w / 2, -block_d / 2, 0])
                cube([block_w, block_d, base_h]);
        }
        // bearing press-fit pocket (down from the top)
        translate([0, 0, base_h])
            cylinder(d = od - press, h = bwidth + 1);
        // shoulder bore the bearing rests on
        translate([0, 0, -0.1])
            cylinder(d = od - 2 * lip, h = base_h + bwidth + 1);
        // two mounting holes through the ears
        for (sx = [-1, 1])
            translate([sx * (block_w / 2 - wall / 2 - bolt_clr / 2), 0, -0.1])
                cylinder(d = bolt_clr, h = base_h + 1);
    }
}

pillow_block();
`);

Open in editor →

GT2 belt idler pulley blank

A smooth flanged idler-pulley blank sized to a GT2 timing belt from the official belt table, with a bore reamed for a 623 ball bearing pressed in from each side. The belt-running surface width matches the GT2 pitch so the belt tracks without rubbing. Press in two 623 bearings and run it on an M3 shaft.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// GT2 belt idler pulley blank
//
// Source: OpenSCAD-hardware-database — BSD-2-Clause
// Generated from the library above, used under its license.

include <hardware-db/lib/_hardware.scad>
include <hardware-db/lib/_3d_print.scad>
include <hardware-db/lib/_functions.scad>

$fn = 120;

// --- GT2 belt facts from the belt table ---
belt      = GetDataTable("GT2", Belt);
pitch     = belt[BeltPitch];   // 2.0 mm
thick     = belt[BeltThick];   // 0.63 mm

// --- 623 bearing to seat in the bore ---
bb        = GetDataTable("623", BB);
bb_od     = bb[BBOuterDia];    // 10 mm
bb_w      = bb[BBHeight];      //  4 mm

belt_w    = 6;                 // belt-tracking surface width
flange_h  = 1.5;               // each flange height
flange_d_extra = 4;            // flange overhang past the belt surface
run_d     = 16;                // diameter of the belt running surface
press     = 0.05;

total_h   = belt_w + 2 * flange_h;
flange_d  = run_d + 2 * flange_d_extra + thick * 2;

module pulley() {
    difference() {
        union() {
            // bottom flange
            cylinder(d = flange_d, h = flange_h);
            // belt running surface
            translate([0, 0, flange_h])
                cylinder(d = run_d, h = belt_w);
            // top flange
            translate([0, 0, flange_h + belt_w])
                cylinder(d = flange_d, h = flange_h);
        }
        // bearing pocket pressed in from the bottom
        translate([0, 0, -0.1])
            cylinder(d = bb_od - press, h = bb_w + 0.1);
        // bearing pocket pressed in from the top
        translate([0, 0, total_h - bb_w])
            cylinder(d = bb_od - press, h = bb_w + 0.2);
        // through shaft bore (clearance between the two bearings)
        translate([0, 0, -0.1])
            cylinder(d = bb[BBDia] + 0.6, h = total_h + 0.2);
    }
}

pulley();
`);

Open in editor →

LM8UU linear bearing clamp

A saddle clamp that holds an LM8UU linear ball bearing, sized straight from the official linear-bearing table, with a cradle bore for the bearing, two M3 bolt ears to pinch it closed, and a flat mounting base. Snap an LM8UU in and bolt the carriage to your 3D-printer gantry.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// LM8UU linear bearing clamp
//
// Source: OpenSCAD-hardware-database — BSD-2-Clause
// Generated from the library above, used under its license.

include <hardware-db/lib/_hardware.scad>
include <hardware-db/lib/_3d_print.scad>
include <hardware-db/lib/_functions.scad>

$fn = 96;

// --- LM8UU linear bearing from the linear-bearing table ---
lb       = GetDataTable("LM8", LB);
lb_od    = lb[LBOuterDia];   // 15 mm
lb_len   = lb[LBLength];     // 24 mm

// --- M3 clamp bolt clearance ---
m3       = GetDataTable("M3", Bolt);
bolt_clr = m3[BoltDia];      // ~3.1 mm

wall     = 3;                // wall around the bearing
base_h   = 4;               // mounting base thickness
gap      = 1.5;             // clamp slit so it can pinch closed
ear_w    = bolt_clr + 4;    // bolt ear width

body_w   = lb_od + 2 * wall;
body_h   = lb_od / 2 + wall;
total_w  = body_w + 2 * ear_w;

module clamp() {
    difference() {
        union() {
            // mounting base
            translate([-total_w / 2, -lb_len / 2, 0])
                cube([total_w, lb_len, base_h]);
            // half-round saddle body
            translate([0, 0, base_h])
                difference() {
                    translate([-body_w / 2, -lb_len / 2, 0])
                        cube([body_w, lb_len, body_h]);
                    translate([0, lb_len / 2 + 0.1, lb_od / 2 + wall - 0.0])
                        rotate([90, 0, 0])
                            cylinder(d = lb_od, h = lb_len + 0.2);
                }
        }
        // bearing cradle bore through the body
        translate([0, lb_len / 2 + 0.1, base_h + lb_od / 2 + wall])
            rotate([90, 0, 0])
                cylinder(d = lb_od, h = lb_len + 0.2);
        // clamp slit
        translate([-gap / 2, -lb_len / 2 - 0.1, base_h + lb_od / 2 + wall])
            cube([gap, lb_len + 0.2, body_h]);
        // two clamp bolt holes through the ears
        for (sx = [-1, 1])
            translate([sx * (body_w / 2 + ear_w / 2), 0, base_h + lb_od / 2])
                rotate([90, 0, 0])
                    translate([0, 0, -lb_len / 2 - 0.1])
                        cylinder(d = bolt_clr, h = lb_len + 0.2);
    }
}

clamp();
`);

Open in editor →

M8 captive-nut knob

A knurled hand knob with a captive hex pocket sized from the official DIN934 nut table for an M8 nut, plus a clearance bore for the M8 bolt shank. Drop a real M8 nut in the trapped pocket and you have a tool-free clamping knob for jigs and fixtures.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// M8 captive-nut knob
//
// Source: OpenSCAD-hardware-database — BSD-2-Clause
// Generated from the library above, used under its license.

include <hardware-db/lib/_hardware.scad>
include <hardware-db/lib/_3d_print.scad>
include <hardware-db/lib/_functions.scad>

$fn = 120;

// --- M8 nut from the DIN934 nut table ---
nut       = GetDataTable("M8", Nut);
nut_af    = nut[NutOuterDia];   // ~14.5 mm across flats (acts as nut socket dia)
nut_h     = nut[NutHeight];     // ~6.3 mm
bolt_dia  = nut[NutDia];        //  8.1 mm shank clearance

knob_d    = 36;                 // grip diameter
knob_h    = 16;                 // grip height
grips     = 14;                 // number of finger scallops
scallop_d = 5;                  // scallop cutter diameter
floor_t   = 3;                  // floor under the nut pocket

module knob() {
    difference() {
        // main grip body
        cylinder(d = knob_d, h = knob_h);

        // finger scallops around the rim
        for (i = [0 : grips - 1])
            rotate([0, 0, i * 360 / grips])
                translate([knob_d / 2, 0, -0.1])
                    cylinder(d = scallop_d, h = knob_h + 0.2);

        // hex nut pocket (trapped from the bottom) — point-up hexagon
        translate([0, 0, floor_t])
            rotate([0, 0, 30])
                cylinder(d = nut_af / cos(30), h = nut_h + 0.5, $fn = 6);

        // bolt shank clearance all the way through
        translate([0, 0, -0.1])
            cylinder(d = bolt_dia + 0.4, h = knob_h + 0.2);
    }
}

knob();
`);

Open in editor →

NEMA17 stepper motor bracket

An L-shaped face-mount bracket generated from the official NEMA17 motor-mount table, with the correct 31 mm bolt circle, a center pilot bore for the boss, four M3 screw holes, and a slotted base so you can square the motor before tightening. Bolt a real NEMA17 stepper straight on.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// NEMA17 stepper motor bracket
//
// Source: OpenSCAD-hardware-database — BSD-2-Clause
// Generated from the library above, used under its license.

include <hardware-db/lib/_hardware.scad>
include <hardware-db/lib/_3d_print.scad>
include <hardware-db/lib/_functions.scad>

$fn = 64;

// --- official NEMA17 mount geometry ---
mm        = GetDataTable("NEMA17", MotorMount);
size      = mm[MMSize];      // 42.3 mm flange
boss_d    = mm[MMCutDia];    // 22.1 mm pilot boss
bolt_span = mm[MMBolts];     // 31.0 mm bolt spacing (square)

// --- M3 screw clearance from the bolt table ---
m3        = GetDataTable("M3", Bolt);
screw_clr = m3[BoltDia];     // ~3.1 mm

plate     = 5;               // face plate thickness
margin    = 4;               // material around bolt circle
foot_len  = 22;              // base flange length
foot_h    = 4;               // base flange thickness

face = size + 2 * margin;
plate_h = face;              // how tall the vertical plate stands
web_h   = min(face * 0.6, foot_len);  // gusset web reach

// Coordinate model (all parts share the back-bottom edge so they fuse):
//   X = left/right (width)            : centered on 0
//   Y = depth out from the plate      : plate at front [0..plate], foot runs to +foot_len
//   Z = up                            : foot at [0..foot_h], plate rises to plate_h

module bracket() {
    difference() {
        union() {
            // vertical face plate: thin slab in Y, tall in Z
            translate([-face / 2, 0, 0])
                cube([face, plate, plate_h]);
            // horizontal foot: flat slab on the bed
            translate([-face / 2, 0, 0])
                cube([face, foot_len, foot_h]);
            // two triangular gusset webs joining plate to foot
            for (sx = [-1, 1])
                translate([sx * (face / 2) - (sx == 1 ? 4 : 0), plate, 0])
                    rotate([90, 0, 90])
                        linear_extrude(height = 4)
                            polygon([[0, 0], [web_h, 0], [0, web_h]]);
        }
        // ---- holes in the vertical plate (motor face) ----
        // center pilot bore for the motor boss
        translate([0, plate + 0.1, plate_h / 2])
            rotate([90, 0, 0])
                cylinder(d = boss_d + 0.4, h = plate + 0.2);
        // four mounting screw holes on the 31 mm bolt square
        for (sx = [-1, 1], sz = [-1, 1])
            translate([sx * bolt_span / 2, plate + 0.1, plate_h / 2 + sz * bolt_span / 2])
                rotate([90, 0, 0])
                    cylinder(d = screw_clr, h = plate + 0.2);
        // ---- adjustment slots in the foot ----
        for (sx = [-1, 1])
            translate([sx * face / 4, foot_len - 7, -0.1])
                hull()
                    for (dy = [-4, 4])
                        translate([0, dy, 0])
                            cylinder(d = screw_clr, h = foot_h + 0.2);
    }
}

bracket();
`);

Open in editor →

OpenBeam 1515 corner frame

An L-shaped corner made from two lengths of OpenBeam 15x15 t-slot extrusion meeting at a right angle, the kind of joint used to build the edges of a printer or enclosure frame. Set the length of each leg independently.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// OpenBeam 1515 corner frame
//
// Source: openscad-extrusions — MIT
// Generated from the library above, used under its license.

use <openscad-extrusions/OpenBeam/1515.scad>

leg_a = 90;   // horizontal leg length in mm
leg_b = 70;   // vertical leg length in mm
$fn = 48;

// Horizontal rail lying along +X.
rotate([0, 90, 0])
    OpenBeam_1515(leg_a);

// Vertical rail rising in +Z, butted to the end of the horizontal rail.
translate([leg_a, 0, 0])
    OpenBeam_1515(leg_b);
`);

Open in editor →

OpenBeam 1515 cube frame

A full open box frame built from twelve lengths of OpenBeam 15x15 t-slot extrusion, the skeleton of an enclosure, light box, or display cube. Set the inner edge size and all twelve rails are placed automatically.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// OpenBeam 1515 cube frame
//
// Source: openscad-extrusions — MIT
// Generated from the library above, used under its license.

use <openscad-extrusions/OpenBeam/1515.scad>

edge = 100;   // outer cube edge length in mm
$fn = 32;

bar = 15;             // 1515 profile width in mm
span = edge - 2 * bar; // clear rail length between corner posts
ov = 0.6;             // overlap so rails fuse into the posts

// Four vertical posts at the corners.
for (x = [0, span + bar], y = [0, span + bar])
    translate([x, y, 0])
        OpenBeam_1515(edge);

// Bottom and top horizontal rails along X (overlapped into both posts).
for (z = [0, span + bar], y = [0, span + bar])
    translate([bar - ov, y, z + bar / 2])
        rotate([0, 90, 0])
            OpenBeam_1515(span + 2 * ov);

// Bottom and top horizontal rails along Y (overlapped into both posts).
for (z = [0, span + bar], x = [0, span + bar])
    translate([x, bar - ov, z + bar / 2])
        rotate([-90, 0, 0])
            OpenBeam_1515(span + 2 * ov);
`);

Open in editor →

OpenBeam 1515 extrusion post

A single length of OpenBeam 15x15 aluminium-style t-slot extrusion with four open channels and a center bore, ready to use as a frame rail or leg. Adjust the length to suit your build.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// OpenBeam 1515 extrusion post
//
// Source: openscad-extrusions — MIT
// Generated from the library above, used under its license.

use <openscad-extrusions/OpenBeam/1515.scad>

length = 80;   // post length in mm
$fn = 48;

OpenBeam_1515(length);
`);

Open in editor →

OpenBeam 1515 parallel rail bed

A row of evenly spaced parallel OpenBeam 15x15 t-slot rails, like the gantry or bed support of a 3D printer or CNC. Choose how many rails, how far apart they sit, and how long each one runs.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// OpenBeam 1515 parallel rail bed
//
// Source: openscad-extrusions — MIT
// Generated from the library above, used under its license.

use <openscad-extrusions/OpenBeam/1515.scad>

rail_count = 4;    // number of parallel rails
spacing    = 40;   // center-to-center spacing in mm
length     = 120;  // rail length in mm
$fn = 40;

for (i = [0 : rail_count - 1])
    translate([0, i * spacing, 0])
        rotate([0, 90, 0])
            OpenBeam_1515(length);
`);

Open in editor →

Helical spur gear

An involute gear whose teeth twist along the thickness for quieter, smoother running than a straight-cut gear. Increase the twist for a steeper helix angle.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Helical spur gear
//
// Source: pd-gears — Unlicense
// Generated from the library above, used under its license.

use <pd-gears/pd-gears.scad>

mm_per_tooth  = 3;   // circular pitch in mm
teeth         = 19;  // number of teeth
thickness     = 10;  // gear thickness in mm (helix spans this)
hole_diameter = 5;   // shaft bore diameter in mm
twist_deg     = 30;  // total tooth twist top-to-bottom (helix amount)

gear(mm_per_tooth = mm_per_tooth,
     number_of_teeth = teeth,
     thickness = thickness,
     hole_diameter = hole_diameter,
     twist = twist_deg,
     pressure_angle = 20,
     center = true,
     $fn = 48);
`);

Open in editor →

Gear with reinforced hub

An involute spur gear with a raised cylindrical hub around the bore that adds grip length for a set screw or press-fit shaft. Tune the hub height and diameter for your shaft.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Gear with reinforced hub
//
// Source: pd-gears — Unlicense
// Generated from the library above, used under its license.

use <pd-gears/pd-gears.scad>

mm_per_tooth  = 3;   // circular pitch in mm
teeth         = 21;  // number of teeth
thickness     = 5;   // gear disc thickness in mm
hole_diameter = 5;   // shaft bore diameter in mm
hub_diameter  = 14;  // outer diameter of the reinforcing hub in mm
hub_height    = 7;   // hub length above the gear face in mm

difference() {
    union() {
        // Gear disc sitting on the build plate.
        gear(mm_per_tooth, teeth, thickness, hole_diameter,
             pressure_angle = 20, $fn = 48);
        // Reinforcing hub rising from the top face.
        translate([0, 0, thickness])
            cylinder(h = hub_height, d = hub_diameter, $fn = 48);
    }
    // Bore drilled all the way through gear + hub.
    translate([0, 0, -0.1])
        cylinder(h = thickness + hub_height + 0.2, d = hole_diameter, $fn = 48);
}
`);

Open in editor →

Meshing gear pair

Two involute spur gears spaced so their pitch circles touch and the teeth mesh, ready to print as a working reduction stage. Adjust the pinion and wheel tooth counts to set the gear ratio.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Meshing gear pair
//
// Source: pd-gears — Unlicense
// Generated from the library above, used under its license.

use <pd-gears/pd-gears.scad>

mm_per_tooth = 4;   // shared circular pitch (must match for meshing)
pinion_teeth = 11;  // small driving gear
wheel_teeth  = 23;  // large driven gear
thickness    = 6;   // gear thickness in mm
bore         = 5;   // shaft bore diameter in mm

// Center-to-center distance = sum of the two pitch radii so teeth mesh.
spacing = pitch_radius(mm_per_tooth, pinion_teeth)
        + pitch_radius(mm_per_tooth, wheel_teeth);

gear(mm_per_tooth, pinion_teeth, thickness, bore, pressure_angle = 20, $fn = 48);

translate([spacing, 0, 0])
    gear(mm_per_tooth, wheel_teeth, thickness, bore, pressure_angle = 20, $fn = 48);
`);

Open in editor →

Rack and pinion set

A toothed rack bar paired with a round pinion gear that rolls along it, converting rotation into straight-line travel. Print both to build a linear actuator or sliding mechanism.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Rack and pinion set
//
// Source: pd-gears — Unlicense
// Generated from the library above, used under its license.

use <pd-gears/pd-gears.scad>

mm_per_tooth = 5;   // shared circular pitch (must match for meshing)
rack_teeth   = 10;  // teeth along the rack bar
pinion_teeth = 12;  // teeth on the round pinion
thickness    = 6;   // part thickness in mm
rack_height  = 14;  // rack body height (tooth tip to far edge) in mm
bore         = 5;   // pinion shaft bore in mm

// Rack pitch line runs along X; place the pinion so its pitch circle sits on it.
rack(mm_per_tooth, rack_teeth, thickness, rack_height, pressure_angle = 20);

translate([rack_teeth * mm_per_tooth / 2,
           pitch_radius(mm_per_tooth, pinion_teeth), 0])
    gear(mm_per_tooth, pinion_teeth, thickness, bore, pressure_angle = 20, $fn = 48);
`);

Open in editor →

Involute spur gear

A single printable involute spur gear with a centered shaft bore. Tune the tooth count, tooth pitch, thickness, and hole diameter to fit your drivetrain.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Involute spur gear
//
// Source: pd-gears — Unlicense
// Generated from the library above, used under its license.

use <pd-gears/pd-gears.scad>

mm_per_tooth  = 3;   // circular pitch (arc length per tooth, mm)
teeth         = 17;  // number of teeth around the gear
thickness     = 6;   // gear thickness in mm
hole_diameter = 5;   // center shaft bore diameter in mm

gear(mm_per_tooth = mm_per_tooth,
     number_of_teeth = teeth,
     thickness = thickness,
     hole_diameter = hole_diameter,
     pressure_angle = 20,
     center = true,
     $fn = 48);
`);

Open in editor →

Arduino UNO Case

A custom-fit Arduino UNO R3 enclosure base with matched mounting standoffs and USB and barrel-jack cutouts on the wall.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Arduino UNO Case
//
// Source: project-boxy — MIT
// Generated from the library above, used under its license.

include <project-boxy/project_box.scad>

// Box base only, sized to host an Arduino UNO R3.
BOX = true;
LID = false;

EXTERIOR_WIDTH = 80;
EXTERIOR_HEIGHT = 70;
EXTERIOR_DEPTH = 30;
THICKNESS = 2;

// Use the built-in Arduino footprint: drops the four board standoffs and
// cuts the USB + barrel-jack openings in the wall it faces.
ARDUINO_UNO = true;
ARDUINO_UNO_ROTATION = 90;

// Footprint provides the standoffs, so disable the generic grid.
BOARD_STANDOFFS = false;
ROUND_HOLES = [];
`);

Open in editor →

Electronics Enclosure Box

A parametric 3D-printable electronics project box base with PCB standoffs and lid mounting posts.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Electronics Enclosure Box
//
// Source: project-boxy — MIT
// Generated from the library above, used under its license.

include <project-boxy/project_box.scad>

// Render only the box base (the lid is a separate part).
BOX = true;
LID = false;

// Compact enclosure footprint.
EXTERIOR_WIDTH = 70;
EXTERIOR_HEIGHT = 50;
EXTERIOR_DEPTH = 28;
THICKNESS = 2;

// PCB mounting standoffs inside the floor.
BOARD_STANDOFFS = true;
BOARD_STANDOFF_WIDTH = 30;
BOARD_STANDOFF_HEIGHT = 20;

// No side panel cutouts on this base.
ROUND_HOLES = [];
ARDUINO_UNO = false;
`);

Open in editor →

Snap-On Enclosure Lid

A parametric 3D-printable enclosure lid with an alignment lip and countersunk screw holes that mates to the matching box.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Snap-On Enclosure Lid
//
// Source: project-boxy — MIT
// Generated from the library above, used under its license.

include <project-boxy/project_box.scad>

// Render only the lid (matches the 70x50 enclosure box).
BOX = false;
LID = true;

EXTERIOR_WIDTH = 70;
EXTERIOR_HEIGHT = 50;
EXTERIOR_DEPTH = 28;
THICKNESS = 2;

// Lid features.
LID_THICKNESS = 3;
LID_LIP = true;
LID_LIP_WIDTH = 3;
LID_COUNTERSINK_DIA = 7;

ROUND_HOLES = [];
ARDUINO_UNO = false;
`);

Open in editor →

Panel-Mount Project Box

A tall electronics project box with a row of round panel-mount holes on the front face for connectors and switches.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Panel-Mount Project Box
//
// Source: project-boxy — MIT
// Generated from the library above, used under its license.

include <project-boxy/project_box.scad>

// Box base only.
BOX = true;
LID = false;

EXTERIOR_WIDTH = 90;
EXTERIOR_HEIGHT = 60;
EXTERIOR_DEPTH = 40;
THICKNESS = 2.5;

// PCB standoffs.
BOARD_STANDOFFS = true;
BOARD_STANDOFF_WIDTH = 40;
BOARD_STANDOFF_HEIGHT = 30;

// Three round panel-mount holes on the front (+y) face, 12mm diameter, spaced horizontally.
// Format: [Face, Diameter, Position_h, Position_v]  (Face 3 = front).
ROUND_HOLES = [[3, 12, -22, 5], [3, 12, 0, 5], [3, 12, 22, 5]];

ARDUINO_UNO = false;
`);

Open in editor →

Raspberry Pi B+ snap-on bumper
A low-profile protective bumper that clips around the edge of a Raspberry Pi 2/3/B+ board, with two external ear tabs drilled for wood screws so the whole board can be fastened flat to a panel or wall.
Methods usedModelEditor.execOpenScad
Example
```
await execOpenScad(`
// Raspberry Pi B+ snap-on bumper
//
// Source: OpenSCAD-RaspberryPi-Mounting-Library — MIT
// Generated from the library above, used under its license.

include <rpi-mounts/raspberry.scad>

$fn = 48;

bumper(
  boardType     = BPLUS,
  mountingHoles = true
);
`);
```
Open in editor →

Raspberry Pi B+ enclosure box

A walled case base for a Raspberry Pi 2/3/B+ with integrated tapped standoffs, side cut-outs for the USB, ethernet and power ports, and clip slots along the top edge that accept the matching snap-on lid.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Raspberry Pi B+ enclosure box
//
// Source: OpenSCAD-RaspberryPi-Mounting-Library — MIT
// Generated from the library above, used under its license.

include <rpi-mounts/raspberry.scad>

$fn = 32;

enclosure(
  boardType       = BPLUS,
  wall            = 2.5,
  offset          = 2,
  heightExtension = 6,
  cornerRadius    = 3,
  mountType       = TAPHOLE
);
`);

Open in editor →

Raspberry Pi B+ tapped standoffs

A set of four tapered standoffs positioned at the exact mounting-hole spacing of a Raspberry Pi 2/3/B+ board, each with a self-tapping screw hole so the board can be raised off a baseplate or screwed into a case floor.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Raspberry Pi B+ tapped standoffs
//
// Source: OpenSCAD-RaspberryPi-Mounting-Library — MIT
// Generated from the library above, used under its license.

include <rpi-mounts/raspberry.scad>

$fn = 48;

standoffs(
  boardType   = BPLUS,
  height      = 8,
  bottomRadius = 3.5,
  topRadius   = 2.6,
  mountType   = TAPHOLE
);
`);

Open in editor →

Raspberry Pi B+ enclosure lid

The snap-fit top cover for the Raspberry Pi 2/3/B+ case base, with a recessed inner lip and four flexible clips that lock it onto the enclosure clip slots.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Raspberry Pi B+ enclosure lid
//
// Source: OpenSCAD-RaspberryPi-Mounting-Library — MIT
// Generated from the library above, used under its license.

include <rpi-mounts/raspberry.scad>

$fn = 32;

enclosureLid(
  boardType    = BPLUS,
  wall         = 2.5,
  offset       = 2,
  cornerRadius = 3,
  ventHoles    = true
);
`);

Open in editor →

Raspberry Pi Zero tapped standoffs

Four short tapered standoffs spaced for the compact Raspberry Pi Zero mounting holes, each tapped for a self-threading screw so a Zero can be lifted off a baseplate or anchored inside a slim project box.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Raspberry Pi Zero tapped standoffs
//
// Source: OpenSCAD-RaspberryPi-Mounting-Library — MIT
// Generated from the library above, used under its license.

include <rpi-mounts/raspberry.scad>

$fn = 48;

standoffs(
  boardType    = ZERO,
  height       = 5,
  bottomRadius = 3.2,
  topRadius    = 2.4,
  mountType    = TAPHOLE
);
`);

Open in editor →

Snap-fit cable grommet

A round cable pass-through grommet with a cantilever snap-fit post on top, so it clips into a panel hole and stays put without screws. Tune the disc size, the cable bore, and the snap post to match your panel thickness and wire bundle.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Snap-fit cable grommet
//
// Source: snapfit-scad — MIT
// Generated from the library above, used under its license.

use <snapfit-scad/snapfit.scad>

disc_d   = 18;   // outer flange diameter
disc_h   = 3;    // flange thickness
bore_d   = 6;    // cable pass-through hole diameter
snap_dia = 5;    // snap-fit post diameter
snap_lip = 1;    // snap-fit lip (adds to diameter)
snap_col = 4;    // snap-fit column height
$fn = 96;

difference() {
  union() {
    translate([0, 0, disc_h / 2])
      cylinder(r1 = disc_d / 2, r2 = disc_d / 2.4, h = disc_h, center = true);
    translate([0, 0, disc_h])
      snapfit(dia = snap_dia, lip = snap_lip, col_h = snap_col,
              slot_ratio = 0.7, under_chamfer_angle = 45);
  }
  // central cable bore through everything
  translate([0, 0, -1])
    cylinder(r = bore_d / 2, h = disc_h + snap_col + snap_dia + snap_lip + 6);
}
`);

Open in editor →

Snap-together box clip coupler

A two-plate coupler that snaps shut on itself: the bottom plate carries a positive snap-fit post and the matching top plate has the negative socket bored into it, so the two halves click together and stay closed. Print both, set the same diameter, and press them home. Great for closing enclosures or joining panels without fasteners.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Snap-together box clip coupler
//
// Source: snapfit-scad — MIT
// Generated from the library above, used under its license.

use <snapfit-scad/snapfit.scad>

plate_d   = 14;   // plate diameter
plate_h   = 4;    // plate thickness
gap       = 8;    // spacing between the two printed halves
snap_dia  = 4;    // snap diameter
snap_lip  = 1;    // snap lip
snap_col  = 6;    // snap column height
neg_tol   = 0.5;  // clearance for the negative socket
$fn = 96;

// Bottom half: plate + positive snap post
union() {
  cylinder(r = plate_d / 2, h = plate_h, center = true);
  translate([0, 0, plate_h / 2])
    snapfit(dia = snap_dia, lip = snap_lip, col_h = snap_col,
            slot_ratio = 0.7, thickness = plate_h / 2);
}

// Top half: plate with negative socket, printed alongside
translate([plate_d + gap, 0, 0])
  difference() {
    cylinder(r = plate_d / 2, h = plate_h, center = true);
    translate([0, 0, -plate_h / 2 - 0.1])
      snapfit_neg(dia = snap_dia, lip = snap_lip, col_h = snap_col,
                  neg_tol = neg_tol, slot_ratio = 0.7, thickness = plate_h / 2);
  }
`);

Open in editor →

Snap-in PCB standoff foot

A tapered standoff foot with a chamfered snap-fit pin that pushes into a mounting hole on a circuit board or chassis and locks underneath. Print four to stand a board off its case. Tune the foot size and the pin diameter to match your board holes.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Snap-in PCB standoff foot
//
// Source: snapfit-scad — MIT
// Generated from the library above, used under its license.

use <snapfit-scad/snapfit.scad>

foot_d   = 10;   // base foot diameter
foot_h   = 4;    // standoff height
pin_dia  = 5;    // snap pin diameter (sized to the board hole)
pin_lip  = 1;    // snap lip
pin_col  = 2;    // pin column height
$fn = 96;

union() {
  // tapered standoff body
  translate([0, 0, foot_h / 2])
    cylinder(r1 = foot_d / 2, r2 = foot_d / 3, h = foot_h, center = true);
  // chamfered snap pin on top
  translate([0, 0, foot_h])
    snapfit(dia = pin_dia, lip = pin_lip, col_h = pin_col,
            col_tol = 0.1, slot_ratio = 0.8, under_chamfer_angle = 45);
}
`);

Open in editor →

Push-in snap rivet

A double-ended plastic push rivet: a snap-fit head on each end of a short waist, so it pushes through two aligned panel holes and locks both sheets together like a trim clip. Tune the head diameter, lip, and waist length for your combined panel thickness.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Push-in snap rivet
//
// Source: snapfit-scad — MIT
// Generated from the library above, used under its license.

use <snapfit-scad/snapfit.scad>

head_dia = 6;    // snap head diameter
head_lip = 1.2;  // snap lip
waist_h  = 5;    // central waist (panel grip) length
$fn = 96;

overlap = 0.6;   // weld overlap so the two halves fuse into one solid

union() {
  // bottom snap head pointing up (column slightly longer to overlap the join)
  snapfit(dia = head_dia, lip = head_lip, col_h = waist_h / 2 + overlap,
          col_tol = 0.1, slot_ratio = 0.7);

  // mirror a second snap head on top, sharing/overlapping the waist
  translate([0, 0, waist_h])
    mirror([0, 0, 1])
      snapfit(dia = head_dia, lip = head_lip, col_h = waist_h / 2 + overlap,
              col_tol = 0.1, slot_ratio = 0.7);
}
`);

Open in editor →

Auger drill bit

A printable auger-style bit with a deep helical flute that comes to a point, the shape used for hand drills, soil augers, and material feeders. Print it as a demo, a feeder screw, or a soft-material auger. Tune the diameters, height, and pitch to change how aggressive the flute is.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Auger drill bit
//
// Source: threads-scad — CC0
// Generated from the library above, used under its license.

use <threads-scad/threads.scad>

outer_d   = 20;  // outer flute diameter
inner_d   = 8;   // solid core diameter
auger_h   = 50;  // overall height of the fluted section
auger_p   = 14;  // pitch (vertical rise per turn) — larger = steeper flute
$fn = 64;

union() {
  AugerThread(outer_d, inner_d, auger_h, auger_p, tooth_angle = 30, tolerance = 0.4);
  // short solid shank below the flutes for chucking
  translate([0, 0, -10]) cylinder(d = inner_d, h = 10.01);
}
`);

Open in editor →

Threaded storage jar neck

A small open-top storage jar whose neck carries external threads, so a matching threaded lid screws on tight. Print it for screws, beads, spices, or small parts. Resize the body and the neck thread to make any jar you need.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Threaded storage jar neck
//
// Source: threads-scad — CC0
// Generated from the library above, used under its license.

use <threads-scad/threads.scad>

jar_diam     = 40;  // outer jar body diameter
jar_height   = 45;  // jar body height (below the neck)
wall         = 2.4; // wall thickness
neck_diam    = 30;  // external thread (neck) diameter
neck_height  = 12;  // threaded neck height
neck_pitch   = 3;   // coarse thread pitch for an easy screw lid
$fn = 96;

difference() {
  // Solid outer shape: jar body + threaded neck, fused into one piece.
  union() {
    cylinder(d = jar_diam, h = jar_height);
    // Neck overlaps 1 mm into the body so the two weld into a single shell.
    translate([0, 0, jar_height - 1])
      ScrewThread(neck_diam, neck_height + 1, pitch = neck_pitch, tolerance = 0.4);
  }
  // One continuous internal cavity opening through the neck.
  translate([0, 0, wall])
    cylinder(d = jar_diam - 2 * wall, h = jar_height + neck_height);
}
`);

Open in editor →

M10 hex nut

A printable M10 hex nut with metric-standard internal threads, sized to thread onto a matching M10 bolt. Great as a captive nut, a knob, or a spare fastener. Adjust the diameter for any metric size and the thickness for a thinner jam nut.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// M10 hex nut
//
// Source: threads-scad — CC0
// Generated from the library above, used under its license.

use <threads-scad/threads.scad>

nut_diam  = 10;  // nominal metric thread diameter (M10)
nut_thick = 0;   // 0 = use the metric-standard thickness for this size
fit_tol   = 0.4; // print clearance tolerance
$fn = 48;

MetricNut(nut_diam, thickness = nut_thick, tolerance = fit_tol);
`);

Open in editor →

M8 hex-head bolt

A real, fully printable M8 hex-head machine bolt with metric-standard threads, a hex head, and a built-in hex-key recess on top. Print it for fixtures, jigs, or anywhere a plastic fastener works. Change the diameter and length numbers to make any metric size.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// M8 hex-head bolt
//
// Source: threads-scad — CC0
// Generated from the library above, used under its license.

use <threads-scad/threads.scad>

bolt_diam   = 8;   // nominal metric thread diameter (M8)
bolt_length = 25;  // threaded shaft length in mm
fit_tol     = 0.4; // print clearance tolerance
$fn = 48;

MetricBolt(bolt_diam, bolt_length, tolerance = fit_tol);
`);

Open in editor →

Threaded grip knob

A round, knurled-free grip knob with a threaded blind hole in the base so it screws straight onto an M6 stud or bolt. Use it as a tightening handle for jigs, clamps, or machine adjustments. Tune the knob size or the thread diameter to fit your hardware.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Threaded grip knob
//
// Source: threads-scad — CC0
// Generated from the library above, used under its license.

use <threads-scad/threads.scad>

knob_diam   = 30;  // outer knob diameter in mm
knob_height = 16;  // knob height in mm
thread_diam = 6;   // metric thread the knob screws onto (M6)
thread_len  = 12;  // depth of the threaded hole
fit_tol     = 0.4; // print clearance tolerance
$fn = 64;

difference() {
  // domed grip body
  union() {
    cylinder(d = knob_diam, h = knob_height);
    translate([0, 0, knob_height])
      scale([1, 1, 0.45]) sphere(d = knob_diam);
  }
  // threaded mounting hole entering from the base
  ScrewHole(thread_diam, thread_len, position = [0, 0, -0.01], tolerance = fit_tol);
}
`);

Open in editor →

Basic project box enclosure

A clean two-part snap-together project box sized for a small circuit board, with a base tray and matching overlapping lid. Adjust the board length, width, and wall height to fit your own electronics.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Basic project box enclosure
//
// Source: YAPP_Box — MIT
// Generated from the library above, used under its license.

include <yappbox/YAPPgenerator_v3.scad>

// ---- Board footprint the box is built around ----
pcbLength      = 70;   // front-to-back (X)
pcbWidth       = 45;   // side-to-side (Y)
pcbThickness   = 1.6;

// ---- Padding between the board and the inside walls ----
paddingFront   = 3;
paddingBack    = 3;
paddingRight   = 3;
paddingLeft    = 3;

// ---- Shell thicknesses + heights ----
wallThickness      = 2.0;
basePlaneThickness = 1.5;
lidPlaneThickness  = 1.5;
baseWallHeight     = 14;
lidWallHeight      = 8;

// ---- Overlapping ridge that mates base + lid ----
ridgeHeight = 4.0;
roundRadius = 2.0;

printBaseShell = true;
printLidShell  = true;

YAPPgenerate();
`);

Open in editor →

PCB tray with standoffs

A base tray and lid with four printed standoffs that lift and fixate a circuit board off the floor, leaving room underneath for solder joints, plus a side cutout for a power jack. Tune the standoff height and diameter for your board's mounting holes.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// PCB tray with standoffs
//
// Source: YAPP_Box — MIT
// Generated from the library above, used under its license.

include <yappbox/YAPPgenerator_v3.scad>

pcbLength      = 75;
pcbWidth       = 50;
pcbThickness   = 1.6;
standoffHeight = 6.0;
standoffDiameter = 7;

paddingFront   = 4;
paddingBack    = 4;
paddingRight   = 4;
paddingLeft    = 4;

wallThickness      = 2.0;
basePlaneThickness = 1.5;
lidPlaneThickness  = 1.5;
baseWallHeight     = 18;
lidWallHeight      = 9;

ridgeHeight = 4.0;
roundRadius = 2.0;

printBaseShell = true;
printLidShell  = true;

// ---- Standoffs that raise + pin the board above the base floor ----
// [posx, posy] relative to the PCB corners
pcbStands =
[
  [6,  6],
  [pcbLength - 6, 6],
  [6,  pcbWidth - 6],
  [pcbLength - 6, pcbWidth - 6],
];

// ---- Power-jack hole in the left wall ----
cutoutsLeft =
[
  [30, 6, 0, 0, 5.5, yappCircle],
];

YAPPgenerate();
`);

Open in editor →

Tool-free snap-fit box

A compact enclosure that clicks shut with integrated snap-fit clips on all four walls, so it needs no screws to close. Great for battery holders or quick-access gadgets. Adjust the clip width and box height to control how firmly the lid grips.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Tool-free snap-fit box
//
// Source: YAPP_Box — MIT
// Generated from the library above, used under its license.

include <yappbox/YAPPgenerator_v3.scad>

pcbLength      = 60;
pcbWidth       = 40;
pcbThickness   = 1.6;

paddingFront   = 3;
paddingBack    = 3;
paddingRight   = 3;
paddingLeft    = 3;

wallThickness      = 2.0;
basePlaneThickness = 1.5;
lidPlaneThickness  = 1.5;
baseWallHeight     = 12;
lidWallHeight      = 9;

ridgeHeight = 4.0;
roundRadius = 2.0;

printBaseShell = true;
printLidShell  = true;

// ---- Snap-fit clips so the lid clicks shut without screws ----
// [position-along-wall, clip-width, which-wall, ...]
snapJoins =
[
  [20, 8, yappLeft,  yappRight, yappCenter, yappSymmetric],
  [16, 8, yappFront, yappBack,  yappCenter, yappSymmetric],
];

YAPPgenerate();
`);

Open in editor →

Vented enclosure with USB port

A project box whose lid carries a row of ventilation slots for airflow and whose front wall has a rectangular cutout for a USB connector. Ideal for boards that run warm. Tune the slot count, slot size, and port opening to match your hardware.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Vented enclosure with USB port
//
// Source: YAPP_Box — MIT
// Generated from the library above, used under its license.

include <yappbox/YAPPgenerator_v3.scad>

pcbLength      = 80;
pcbWidth       = 55;
pcbThickness   = 1.6;

paddingFront   = 4;
paddingBack    = 4;
paddingRight   = 4;
paddingLeft    = 4;

wallThickness      = 2.0;
basePlaneThickness = 1.5;
lidPlaneThickness  = 1.5;
baseWallHeight     = 16;
lidWallHeight      = 10;

ridgeHeight = 4.0;
roundRadius = 2.5;

printBaseShell = true;
printLidShell  = true;

// ---- Ventilation slots across the lid ----
cutoutsLid =
[
  [20, 12, 4, 35, 0, yappRectangle],
  [30, 12, 4, 35, 0, yappRectangle],
  [40, 12, 4, 35, 0, yappRectangle],
  [50, 12, 4, 35, 0, yappRectangle],
];

// ---- USB connector opening in the front wall ----
cutoutsFront =
[
  [25, 4, 14, 8, 1.5, yappRoundedRect],
];

YAPPgenerate();
`);

Open in editor →

Wall-mountable screwed case

An enclosure with external mounting flanges on two sides so it can be screwed to a wall or panel, plus internal screw posts that bolt the lid down onto the base for a secure, serviceable closure. Tune the flange screw size and post diameter to your fasteners.

Methods usedModelEditor.execOpenScad

Example

await execOpenScad(`
// Wall-mountable screwed case
//
// Source: YAPP_Box — MIT
// Generated from the library above, used under its license.

include <yappbox/YAPPgenerator_v3.scad>

pcbLength      = 90;
pcbWidth       = 60;
pcbThickness   = 1.6;

paddingFront   = 5;
paddingBack    = 5;
paddingRight   = 5;
paddingLeft    = 5;

wallThickness      = 2.4;
basePlaneThickness = 2.0;
lidPlaneThickness  = 2.0;
baseWallHeight     = 18;
lidWallHeight      = 11;

ridgeHeight = 5.0;
roundRadius = 3.0;

printBaseShell = true;
printLidShell  = true;

// ---- External flanges for screwing the case to a wall ----
// [pos, screwDiameter, slotWidth, height, which-wall(s)]
boxMounts =
[
  [15, 3, 3, 3, yappLeft],
  [15, 3, 3, 3, yappRight],
];

// ---- Internal screw posts that bolt the lid to the base ----
// [posx, posy, standHeight, screwD, headD, insertD, outsideD, ...]
connectors =
[
  [8,  8,  5, 2.5, 5, 3.5, 7, yappAllCorners, yappCoordBoxInside],
];

YAPPgenerate();
`);

Open in editor →

Materials & Textures

Make a red metallic material

Create a PBR material and assign it to the selected mesh. Properties are live setters; changes update the renderer immediately.

Methods usedModelEditor.create.material material.assignTo

Example

// Pick the first selected mesh and give it a red metallic look.
const sel = ls({selected: true})[0];
if (!sel) { console.log('Select a mesh first.'); return; }
const red = create.material({
  name: 'red',
  baseColor: [1, 0.1, 0.1, 1],
  metallic: 0.85,
  roughness: 0.25,
});
await red.assignTo(sel);
console.log('Assigned', red.name, 'to', sel.name);

What you'll seeconsole line: "Assigned red to <mesh name>"; viewport: mesh shows the new red metallic material.

Open in editor →

Bind a material by name (no UUIDs)

Name-first material workflow: create by name, resolve by name with getMaterial, set it on a mesh, then broadcast it to several meshes by name. Never capture a materialId UUID.

Methods usedModelEditor.create.material ModelEditor.getMaterial mesh.material.set ModelEditor.material.applyToAll

Example

// Name-first material binding — work entirely by NAME, never by UUID.
const cube = await create.cube({ name: 'Cube' });
const sphere = await create.sphere({ name: 'Sphere' });
await create.material({ name: 'Steel', baseColor: [0.6, 0.6, 0.65, 1], metallic: 1, roughness: 0.3 });
// Resolve by name and set on one mesh by handle.
ls('Cube')[0].material.set(getMaterial('Steel'));
// Broadcast the same material to several meshes by NAME in one undoable step.
await material.applyToAll('Steel', ['Cube', 'Sphere']);
console.log('bound', getMaterial('Steel').name, 'to Cube + Sphere');

What you'll seeconsole line confirming the bound material; viewport: the named meshes all show the Steel material.

Open in editor →

Make every mesh emissive blue
Walk every mesh in the scene and assign a flat unlit blue material. Quick way to silhouette a whole asset.
Methods usedModelEditor.create.unlitMaterial ModelEditor.scene.ls mesh.material.set
Example
```
// One unlit blue material applied to every mesh in the scene.
const blue = create.unlitMaterial({ name: 'flat-blue', baseColor: [0, 0.4, 1, 1] });
let count = 0;
for (const m of ls({ type: 'mesh' })) {
  m.material.set(blue);
  count++;
}
console.log('painted', count, 'meshes blue');
```
What you'll seeconsole line with painted mesh count; viewport: every mesh renders flat blue.
Open in editor →

Duplicate a material with a tweak

Take the selected mesh material, duplicate it under a new name, dial the roughness up, and assign the variant.

Methods usedmesh.material.get material.duplicate mesh.material.set

Example

// Variant of an existing material: same albedo, rougher finish.
const sel = ls({selected: true})[0];
if (!sel) { console.log('Select a mesh first.'); return; }
const base = sel.material.get();
if (!base) { console.log('Mesh has no resolvable material.'); return; }
const rough = base.duplicate({ name: base.name + '-rough' });
rough.roughness = Math.min(1, base.roughness + 0.4);
sel.material.set(rough);
console.log('switched', sel.name, 'to', rough.name);

What you'll seeconsole line: "switched <mesh name> to <new material name>"; viewport: mesh material is the rougher variant.

Open in editor →

Delete unused materials

List every material in the asset and remove any that no mesh references.

Methods usedModelEditor.listMaterials ModelEditor.getMaterial mesh.material.get material.delete

Example

// Drop materials nothing references.
const referenced = new Set();
for (const m of ls({ type: 'mesh' })) {
  const mat = m.material.get();
  if (mat) referenced.add(mat.id);
}
let removed = 0;
// listMaterials() → { id, name } descriptors; getMaterial(id) → the deletable handle.
for (const { id } of listMaterials()) {
  if (!referenced.has(id)) {
    getMaterial(id).delete();
    removed++;
  }
}
console.log('removed', removed, 'unused materials');

What you'll seeconsole line with removed-materials count.

Open in editor →

Assign a hash-of-name material color to every mesh

Build a few named meshes, then give each one a unique material whose base color comes from a hash of its name. Handy for telling parts apart in a screenshot.

Methods usedModelEditor.create.cube ModelEditor.create.material material.assignTo

Example

// Self-contained from an EMPTY scene: build a few named meshes, then recolor
// each one with a per-name hashed hue so they're easy to tell apart.

// Helpers: stable hue from a string, then HSL -> linear RGBA.
function hashHue(str) {
  let h = 0;
  for (let i = 0; i < str.length; i++) h = (h * 31 + str.charCodeAt(i)) | 0;
  return ((h % 360) + 360) % 360;   // 0..359 degrees
}
function hslToRgb(h, s, l) {
  const c = (1 - Math.abs(2 * l - 1)) * s;
  const hh = h / 60, x = c * (1 - Math.abs((hh % 2) - 1));
  let r = 0, g = 0, b = 0;
  if (hh < 1)      { r = c; g = x; }
  else if (hh < 2) { r = x; g = c; }
  else if (hh < 3) { g = c; b = x; }
  else if (hh < 4) { g = x; b = c; }
  else if (hh < 5) { r = x; b = c; }
  else             { r = c; b = x; }
  const m = l - c / 2;
  return [r + m, g + m, b + m, 1];   // [r, g, b, a], each 0..1
}

// 1. Build three named cubes in a row.
const names = ['Torso', 'ArmLeft', 'ArmRight'];
const meshes = [];
for (let i = 0; i < names.length; i++) {
  const c = await create.cube({ width: 0.8, name: names[i] });
  c.translate.set([i * 1.5, 0, 0]);
  meshes.push(c);
  select(null, { mode: 'clear' });
}

// 2. Per mesh: build a material (ASYNC -> await) and assign it. create.material
//    options: name, baseColor [r,g,b,a], metallic 0..1 (0 = dielectric),
//    roughness 0..1 (0 = mirror, 1 = matte), emissive [r,g,b], emissiveIntensity.
for (const me of meshes) {
  const rgba = hslToRgb(hashHue(me.name), 0.65, 0.55);
  const mat = await create.material({
    name: 'auto_' + me.name,
    baseColor: rgba,
    metallic: 0.1,            // mostly dielectric
    roughness: 0.6,           // semi-matte
    emissive: [0, 0, 0],      // no self-glow
    emissiveIntensity: 0,
  });
  await mat.assignTo(me);     // bind the material to this mesh
  console.log(me.name, '->', mat.name, 'rgb=' + rgba.slice(0, 3).map((v) => v.toFixed(2)).join(','));
}
console.log('recolored', meshes.length, 'meshes');

What you'll seeconsole: per-mesh name + assigned material name; viewport: every mesh shows a distinct color.

Open in editor →

Find meshes with no material assigned

Walk every mesh in the scene and report the ones with no resolvable material. Pairs with the inventory recipe to flag shading gaps before export.

Methods usedModelEditor.scene.ls ModelEditor.scene.select mesh.material.get

Example

// Surface every mesh that has no material assigned.
const all = ls({ type: 'mesh' });
const orphans = [];
for (const m of all) {
  if (!m.material.get()) orphans.push(m);
}

select(null, {mode: 'clear'});
for (const o of orphans) select(o, { add: true });

if (orphans.length === 0) {
  console.log('every mesh has a material; nothing to fix');
} else {
  console.log('meshes without materials:', orphans.length, '/', all.length);
  for (const o of orphans) console.log('  ' + o.name);
}

What you'll seeconsole: list of mesh names missing materials; outliner: those meshes are selected so the user can fix them in one pass.

Open in editor →

Author a PBR material and roundtrip every channel

Create a red metallic material, assign it to a cube, log every PBR field, then mutate via live setters to flip it to a blue rough double-sided variant.

Methods usedModelEditor.create.cube Utils.wait.frame ModelEditor.create.material node.translate ModelEditor.getMaterial material.assignTo material.name material.id material.materialId material.toString material.baseColor material.metallic material.roughness material.emissive material.emissiveIntensity material.alphaMode material.alphaCutoff material.doubleSided material.equals

Example

// Author a PBR material, assign it, read every channel back, then flip it
// to a different look via the live async setters. Self-contained from empty.

const cube = await create.cube({ width: 1, height: 1, depth: 1, name: 'PbrCube' });
cube.xform({ t: [2.5, 1.3, -0.7] });
await select(null, { mode: 'clear' });

// create.material is async. The constructor opts seed every PBR channel.
const m = await create.material({
  name: 'red-metal',
  baseColor: [0.9, 0.1, 0.1, 1], // [r,g,b,a] each 0..1
  metallic: 0.85,                // 0 (dielectric) .. 1 (metal)
  roughness: 0.25,               // 0 (mirror) .. 1 (matte)
  emissive: [0.4, 0.0, 0.0],     // [r,g,b] glow color
  emissiveIntensity: 0.5,        // emissive multiplier (>= 0)
  alphaMode: 'opaque',           // 'opaque' | 'mask' | 'blend'
  alphaCutoff: 0.5,              // only used when alphaMode === 'mask'
  doubleSided: false,            // render back faces?
});
await m.assignTo(cube); // bind the material to the cube

// IDENTITY — toString + name + id/materialId (id === materialId).
console.log('toString:', m.toString());
console.log('name:', m.name, 'id:', m.id, 'materialId:', m.materialId);
console.log('id matches materialId?', m.id === m.materialId);

// READ — PBR channels live under material.pbr.<channel>.get() (synchronous).
console.log('baseColor:', JSON.stringify(m.pbr.baseColor.get()));
console.log('metallic:', m.pbr.metallic.get(), 'roughness:', m.pbr.roughness.get());
console.log('emissive:', JSON.stringify(m.pbr.emissive.get()), 'intensity:', m.pbr.emissiveIntensity.get());
console.log('alphaMode:', m.pbr.alphaMode.get(), 'alphaCutoff:', m.pbr.alphaCutoff.get(), 'doubleSided:', m.pbr.doubleSided.get());

// WRITE — every channel setter is ASYNC + undoable (await each).
// alphaCutoff is only meaningful when alphaMode === 'mask', so set the mode FIRST.
await m.pbr.baseColor.set([0.1, 0.5, 0.9, 1.0]); // blue
await m.pbr.metallic.set(0.0);                   // dielectric
await m.pbr.roughness.set(1.0);                  // fully matte
await m.pbr.emissive.set([0.0, 0.4, 0.8]);       // cyan glow
await m.pbr.emissiveIntensity.set(1.5);
await m.pbr.alphaMode.set('mask');               // set BEFORE alphaCutoff
await m.pbr.alphaCutoff.set(0.25);
await m.pbr.doubleSided.set(true);
await m.setName('blue-rough');                   // rename via setName (async)

console.log('after setters - name:', m.name, 'baseColor:', JSON.stringify(m.pbr.baseColor.get()));
console.log('after setters - alphaMode:', m.pbr.alphaMode.get(), 'alphaCutoff:', m.pbr.alphaCutoff.get(), 'doubleSided:', m.pbr.doubleSided.get());

// Equality is by materialId, not handle reference — re-resolve and compare.
const same = getMaterial(m.id);
console.log('m equals re-resolved?', same ? m.equals(same) : false);
await Utils.wait.frame();
console.log('PBR roundtrip complete on "' + m.name + '"');

What you'll seeconsole: every PBR field read back, then re-read after the live setters flip the material from red metallic to blue rough.

Open in editor →

Get a material by name and delete it

Spawn a cube; create + assign a material; look it up by name; list every material; then delete the material (which also unassigns it).

Methods usedModelEditor.getMaterial ModelEditor.listMaterials ModelEditor.create.cube ModelEditor.create.material Utils.wait.frame node.translate material.assignTo material.delete

Example

// Look a material up by name, list every material, then delete it (which
// also unassigns it from every mesh). Self-contained from an empty scene.

const cube = await create.cube({ width: 1, height: 1, depth: 1, name: 'MatTarget' });
cube.xform({ t: [2.5, 1.3, -0.7] });
await select(null, { mode: 'clear' });
await Utils.wait.frame();

// getMaterial(idOrName) returns null when nothing matches.
const probe = getMaterial('nonexistent-material');
console.log('getMaterial("nonexistent-material"):', probe); // null

// create.material is async — give the asset something to look up + delete.
const mat = await create.material({
  name: 'scrap-mat',
  baseColor: [0.2, 0.6, 0.9, 1], // [r,g,b,a] 0..1
  metallic: 0.1,
  roughness: 0.8,
});
await mat.assignTo(cube); // bind so delete() has an assignment to clean up

// listMaterials() enumerates every material on the asset.
console.log('material count:', listMaterials().length);

// Round-trip the lookup by NAME (customer-facing: prefer names over ids).
const looked = getMaterial('scrap-mat');
console.log('roundtrip getMaterial by name:', looked?.name);

// delete() removes the material AND unassigns it from every mesh.
mat.delete();
await Utils.wait.frame();

// The name no longer resolves.
const after = getMaterial('scrap-mat');
console.log('post-delete getMaterial:', after); // null
console.log('material count after delete:', listMaterials().length);

What you'll seeconsole: null for a missing name, the looked-up material, the material count, then null after delete.

Open in editor →

Color toolkit: RGB / hex / HSL factories, lerp, multiply, to-hex

Color handle walk-through: every factory, channel getters, blend with lerp / multiply, and round-trip through hex and HSL.

Methods usedcolor.fromRGB color.fromHex color.fromHSL color.white color.black color.r color.g color.b color.clone color.toArray color.toHex color.toHexString color.toHSL color.lerp color.multiply color.equals

Example

// Color OO handle. Linear-space floats 0-1.
const red = MathLib.Color.fromRGB(1, 0.1, 0.1);
const hex = MathLib.Color.fromHex('#FF8800');
const teal = MathLib.Color.fromHSL(0.5, 0.6, 0.5);
const w = MathLib.Color.white();
const k = MathLib.Color.black();
console.log('red (r,g,b):', red.r, red.g, red.b);
console.log('hex tuple:', hex.toArray(), '| toHex (int):', hex.toHex(), '| toHexString:', hex.toHexString());

// Blend + tint.
const blended = red.lerp(w, 0.5);
const tinted = red.multiply(MathLib.Color.fromRGB(0.5, 0.5, 1));
const hsl = teal.toHSL();
console.log('lerp(red, white, .5):', blended.toArray());
console.log('multiply(red, [.5,.5,1]):', tinted.toArray());
console.log('teal.toHSL:', hsl.h.toFixed(2), hsl.s.toFixed(2), hsl.l.toFixed(2));

// Equality + clone.
console.log('red == red.clone()?', red.equals(red.clone()));
console.log('white != black?', !w.equals(k));

What you'll seeconsole: r/g/b channels, hex round-trip, HSL components, lerp toward white, and a tint via component-wise multiply.

Open in editor →

Selection

Select every mesh sharing a material

Build meshes, paint two materials across them, then pick the seed mesh's material and select every other mesh that shares it. Mass-edit shading in one pass.

Methods usedModelEditor.create.cube ModelEditor.create.material ModelEditor.scene.ls ModelEditor.scene.select mesh.material.get material.assignTo

Example

// Self-contained from an EMPTY scene: build meshes, assign two materials
// across them, then select everything sharing the seed mesh's material.

// 1. Two materials (create.material is ASYNC -> await).
const red  = await create.material({ name: 'Red',  baseColor: [0.8, 0.1, 0.1, 1], roughness: 0.5 });
const blue = await create.material({ name: 'Blue', baseColor: [0.1, 0.2, 0.8, 1], roughness: 0.5 });

// 2. Five cubes; alternate the two materials across them.
const meshes = [];
for (let i = 0; i < 5; i++) {
  const c = await create.cube({ width: 0.8, name: 'Cube' + i });
  c.translate.set([i * 1.2, 0, 0]);
  await (i % 2 === 0 ? red : blue).assignTo(c);   // even -> Red, odd -> Blue
  meshes.push(c);
  select(null, { mode: 'clear' });
}

// 3. Pick a seed mesh and read its material. mesh.material.get() returns a
//    Material handle (with .id / .name) or null when nothing is bound.
const seed = meshes[0];
const target = seed.material.get();

// 4. Find every mesh that shares the seed's material, select them in ONE
//    replace call, and report (never a silent no-op).
const matches = ls({ type: 'mesh' }).filter((m) => {
  const mat = m.material.get();
  return mat !== null && mat.id === target.id;
});
await select(matches);
console.log('seed', seed.name, 'uses', target.name + ';',
  'selected', matches.length, 'meshes sharing it:',
  matches.map((m) => m.name).join(', '));

What you'll seeconsole: count of meshes sharing the seed material; outliner: exactly those meshes are selected.

Open in editor →

Invert the selection across all meshes

Build the set of unselected meshes, then swap the selection so it contains exactly those instead. Invert-selection behavior for the mesh layer.

Methods usedModelEditor.scene.ls ModelEditor.scene.select

Example

// Swap the selection: whatever is selected becomes unselected and vice versa.
const all = ls({ type: 'mesh' });
const before = ls({selected: true}).filter((n) => n.type === 'mesh');
const beforeIds = new Set(before.map((m) => m.id));
const inverted = all.filter((m) => !beforeIds.has(m.id));

  select(null, {mode: 'clear'});
  for (const m of inverted) select(m, { add: true });
console.log('before:', before.length, 'meshes; after:', inverted.length, 'meshes');

What you'll seeconsole: before / after selection counts; outliner: every mesh that was unselected becomes selected.

Open in editor →

Run grow / shrink / invert / select-by-face-sides and convert across component modes

Spawn a subdivided cube; switch to vertex/edge/face mode; grow/shrink/invert; select-all, linked, loose, non-manifold, similar, sharp-edges, nth, interior; shortest-path; convert via toVertices/toEdges/toFaces/toIslands/toUVs; bulk-translate the selection.

Example

const cube = await create.cube({ width: 1, height: 1, depth: 1, subdivisionsX: 3, subdivisionsY: 3, subdivisionsZ: 3, name: 'SelCube' });
cube.translate.set([2.5, 1.3, -0.7]);
select(null, {mode: 'clear'});
await Utils.wait.frame();

function logSafe(label, fn) {
  try {
    fn();
    console.log(label, 'ok');
  } catch (err) {
    console.log(label, 'skipped:', err.message);
  }
}

// Object-level select + bulk translate (transforms live on the node handle).
select(cube);
cube.xform({ t: [0.1, 0, 0], relative: true });
console.log('object-mode translate applied');
select(null, {mode: 'clear'});

// Vertex mode — grow/shrink/invert + linked/loose, then walk the component
// domains via a convert chain: vertices → edges → faces → UVs → islands → vertices.
setComponentMode('vertex');
select(null, {mode: 'all'});
logSafe('grow', () => select.growSelection());
logSafe('shrink', () => select.shrinkSelection());
logSafe('invert', () => select.invertSelection());
logSafe('selectLinked', () => select.selectLinked());
logSafe('selectLoose', () => select.selectLoose());
logSafe('verts→edges', () => select.convertVerticesToEdges());
logSafe('edges→faces', () => select.convertEdgesToFaces());
logSafe('faces→UVs', () => select.convertFacesToUVs());
logSafe('UVs→islands', () => select.convertUVsToIslands());
logSafe('islands→verts', () => select.convertIslandsToVertices());

// Edge mode
setComponentMode('edge');
select(null, {mode: 'all'});
logSafe('edge.selectNonManifold', () => select.selectNonManifold());
logSafe('edge.selectSharpEdges', () => select.selectSharpEdges({ angleThreshold: 30 }));
logSafe('edge.selectSimilar', () => select.selectSimilar({ property: 'length', threshold: 0.1 }));
logSafe('edge.selectNth', () => select.selectNth(2));
logSafe('edge.shortestPath', () => select.shortestPath(0, 5));

// Face mode
setComponentMode('face');
select(null, {mode: 'all'});
logSafe('face.selectInteriorFaces', () => select.selectInteriorFaces());
logSafe('face.byFaceSides', () => select.selectByFaceSides(4));

setComponentMode('object');
select(null, {mode: 'clear'});

What you'll seeconsole: status line after every selection op; bulk translate confirms.

Open in editor →

Snap, Align & Distribute

Snap one object onto another

node.snapTo(target) copies the target node's world-space translate onto this node. Zero offset, polymorphic, one undo step.

Methods usedModelEditor.create.cube node.snapTo node.translate

Example

// Self-contained from an EMPTY scene: build a target + a mover, then snap.
// snapTo copies ONLY the target's world translate (rotate + scale untouched),
// in a single undo step. To copy t+r+s at once use node.matchTransform(target).

// 1. Target object, parked away from the origin so the snap is visible.
const target = await create.cube({
  width: 1,            // X size in scene units (>0); default 1
  height: 1,           // Y size; default 1
  depth: 1,            // Z size; default 1
  name: 'SnapTarget',
});
target.translate.set([3, 2, -1]);          // [x, y, z] world position to copy

// Clear selection so the next create() doesn't add to a multi-selection.
select(null, { mode: 'clear' });

// 2. Mover object, somewhere else entirely.
const mover = await create.cube({ width: 1, name: 'Mover' });
mover.translate.set([-4, 0, 5]);

// 3. Snap the mover onto the target's world position.
const before = mover.translate.get();      // [x, y, z] before the snap
mover.snapTo(target);                       // mover now shares target's translate
const after = mover.translate.get();

// 4. Report the move so it's not a silent no-op.
console.log(mover.name, 'moved from', JSON.stringify(before),
  'to', JSON.stringify(after),
  '| now matches', target.name, 'at', JSON.stringify(target.translate.get()));

What you'll seeconsole line with the moved node's new world translate, matching the target.

Open in editor →

Snap to the nearest scene transform

node.snapToNearest({ mode: "transform", range }) finds the closest OTHER scene transform within range and snaps to it (returns null if none).

Methods usedModelEditor.create.locator node.snapToNearest node.translate

Example

// Self-contained from an EMPTY scene: scatter a few markers, then snap a
// rover onto whichever one is closest within a search radius.

// 1. A handful of fixed markers the rover can latch onto. create.locator is
//    SYNC (no await): { name, position, scale }.
const a = create.locator({ name: 'MarkerA', position: [4, 0, 0] });
const b = create.locator({ name: 'MarkerB', position: [0, 0, 5] });
const c = create.locator({ name: 'MarkerC', position: [1.2, 0, 0] });

// 2. The rover starts near MarkerC but not on it.
const rover = create.locator({ name: 'Rover', position: [0, 0, 0] });

// 3. Snap to the nearest OTHER scene transform within range. Options:
//    mode: 'transform' searches other transforms (vs 'vertex' / 'surface',
//          which need a target mesh); range > 0 is the max world distance to
//          consider (past it the call is a no-op returning null);
//    checkOcclusion: 'auto' (default) | true (always skip hidden candidates,
//          throws when no viewport camera) | false (never skip). 'auto'
//          passes through in headless scripts.
const hit = rover.snapToNearest({
  mode: 'transform',
  range: 3,                  // only MarkerC (dist 1.2) is within 3 units
  checkOcclusion: 'auto',
});

// 4. Report the result so it's never a silent no-op.
if (hit) {
  console.log(rover.name, 'snapped to', hit.hitNode ? hit.hitNode.name : '(unknown)',
    'at', JSON.stringify(rover.translate.get()),
    '| travelled', hit.distance.toFixed(3), 'units');
} else {
  console.log(rover.name, 'found nothing in range; left at',
    JSON.stringify(rover.translate.get()),
    '(unused markers:', [a.name, b.name].join(', ') + ')');
}

What you'll seeconsole line with the snap distance, or "nothing in range" when no transform is within range.

Open in editor →

Snap to a mesh surface

Drop a locator onto the closest point of a target mesh surface using mesh.geometry.closestPoint(point, { space }) + node.translate.set(...). (node.snapToNearest mode:"surface" is unavailable from script — the surface branch calls a mesh method that is only exposed under mesh.geometry.)

Methods usedModelEditor.create.locator mesh.geometry.closestPoint node.translate

Example

// Self-contained from an EMPTY Model scene: build the target mesh, then drop a
// locator down onto the nearest point of its triangle surface. The surface
// query lives on mesh.geometry.closestPoint(...) (it is NOT reachable through
// node.snapToNearest('surface') from a script), so we compute the hit and write
// it onto the marker with node.translate.set(...).

// 1. Target surface — a sphere the marker will land on.
const ball = await create.sphere({
  radius: 1.0,            // 1 m radius; >0
  widthSegments: 24,      // longitude divisions (denser = smoother surface to hit)
  heightSegments: 16,     // latitude divisions
  name: 'SnapBall',
});
ball.translate.set([0, 0, 0]); // park the target at the origin

// 2. The marker we want to drop. create.locator is SYNC (no await).
const marker = create.locator({
  name: 'Marker',
  position: [0, 5, 0],    // start 5 m straight above the ball
  scale: [1, 1, 1],       // unit scale
});

// 3. Find the nearest point on the ball's surface to the marker's world
//    position. closestPoint returns { position, face, normal, distance,
//    barycentric } | null. space: 'world' puts the query + result in world
//    space ('object' would use the ball's local coords instead).
const start = marker.translate.get();           // [x, y, z] in scene units
const hit = ball.geometry.closestPoint(start, { space: 'world' });

if (hit) {
  const onSurface = hit.position.toArray();      // Vec3 -> [x, y, z]
  marker.translate.set(onSurface);               // drop the marker onto the surface
  select(null, { mode: 'clear' });
  console.log('Marker landed on', ball.name,
    'at', JSON.stringify(onSurface.map((v) => +v.toFixed(3))),
    '| travelled', hit.distance.toFixed(3), 'm');
} else {
  select(null, { mode: 'clear' });
  console.log('Target mesh is empty - marker did not move.');
}

What you'll seeconsole line with the surface-hit position + travel distance.

Open in editor →

Match a node exactly (t + r + s)

node.matchTransform(source) copies the source node's WORLD translate, rotate AND scale onto the target in a single undo step. It takes ONLY a source (a Node handle / name / {name|nodeId|id}) — it always copies all three components (no per-channel flags). Useful for stamping duplicates onto reference transforms.

Methods usedModelEditor.create.cube node.matchTransform node.translate node.rotate node.scale

Example

// Self-contained: build a SOURCE node at a distinct transform and a TARGET
// node at the origin, then copy the source's full transform onto the target.
// matchTransform takes ONLY the source — it ALWAYS copies translate + rotate +
// scale together (there are no per-channel option flags). Drive + verify BY
// NAME, never by id.

// 1) Source — a cube nudged + rotated + scaled to a distinctive pose.
const source = await create.cube({ name: 'Source' });
source.xform({ t: [2.5, 1.3, -0.7], r: [30, 45, 60], s: [1.5, 0.75, 2] });
await select(null, { mode: 'clear' });

// 2) Target — a second cube left at the origin with identity transform.
const target = await create.cube({ name: 'Target' });
await select(null, { mode: 'clear' });

// Snapshot BEFORE — target sits at origin / identity.
const before = {
  t: target.translate.get(),
  r: target.rotate.get(),
  s: target.scale.get(),
};
console.log('Target BEFORE: ' + JSON.stringify(before));

// 3) Copy the SOURCE's world transform onto the TARGET in one undoable step.
//    Resolve the source by NAME to prove the name-based path works.
target.matchTransform('Source'); // one Ctrl+Z reverts t, r AND s together

// Snapshot AFTER — should now equal the source's transform.
const after = {
  t: target.translate.get(),
  r: target.rotate.get(),
  s: target.scale.get(),
};
const src = {
  t: source.translate.get(),
  r: source.rotate.get(),
  s: source.scale.get(),
};
console.log('Target AFTER:  ' + JSON.stringify(after));
console.log('Source:        ' + JSON.stringify(src));

// Prove equality component-by-component (round to dodge float noise).
const round3 = (a) => a.map((v) => +v.toFixed(3));
const eq = (a, b) => JSON.stringify(round3(a)) === JSON.stringify(round3(b));
console.log('matched t/r/s: ' + JSON.stringify({
  translate: eq(after.t, src.t),
  rotate: eq(after.r, src.r),
  scale: eq(after.s, src.s),
}));

What you'll seeconsole shows Target TRS before (origin / identity) and after — after equals the Source's t+r+s; single Ctrl+Z reverts all three.

Open in editor →

Distribute and align a row of objects

node1.distribute([node2, node3], { axis }) spaces nodes evenly between the first and last; node1.align([node2, node3], { axis, mode }) snaps every node's axis component to the min / center / max of the set.

Methods usedModelEditor.create.cube Node.distribute Node.align node.translate

Example

// Five cubes, then space the middle three evenly and bottom-align them.
const cubes = [];
for (let i = 0; i < 5; i++) cubes.push(await create.cube({ width: 0.5, name: 'C' + i }));
cubes[0].translate.set([0, 0, 0]);
cubes[4].translate.set([8, 0, 0]);
cubes[0]?.distribute(cubes.slice(1), { axis: 'x' });
cubes[0]?.align(cubes.slice(1), { axis: 'y', mode: 'min' });
console.log(cubes.map(c => c.translate.get()[0]));   // [0, 2, 4, 6, 8]

What you'll seeconsole line with x-positions [0, 2, 4, 6, 8]; 5 cubes evenly spaced + bottom-aligned.

Open in editor →

Tune the viewport snap settings
dev.snapSettings is a getter/setter for the gizmo snap state shown in the channel box (snapAngle / snapStep / snapScale / snapMode).
Methods usedModelEditor.dev.snapSettings.snapAngle ModelEditor.dev.snapSettings.snapStep ModelEditor.dev.snapSettings.snapMode
Example
```
// Turn on 15-degree rotation snapping and a 0.25-unit translate step.
dev.snapSettings.snapAngle = 15;
dev.snapSettings.snapStep = 0.25;
dev.snapSettings.snapMode = 'rotate';
console.log('snap mode is now', dev.snapSettings.snapMode);
```
What you'll seechannel-box snap section shows 15° angle + 0.25 step + rotate mode.
Open in editor →

Snap the second selection onto the first, then verify

Use node.snapTo to copy the first selected node's world translate onto the second, then read both world translates back and assert they match within 1e-5.

Methods usedModelEditor.create.cube node.snapTo node.translate

Example

// Self-contained from an EMPTY scene: build two cubes, snap one onto the
// other, then read both world translates back and assert they coincide.

// 1. Target cube, parked off-origin.
const target = await create.cube({ width: 1, name: 'Target' });
target.translate.set([2.5, 1.3, -0.7]);   // [x, y, z] world position
select(null, { mode: 'clear' });

// 2. Mover cube, somewhere else.
const mover = await create.cube({ width: 1, name: 'Mover' });
mover.translate.set([-3, 0, 4]);

// 3. Snap, capturing before / after. snapTo copies the WORLD translate only
//    (rotate + scale unchanged) in one undo step.
const before = mover.translate.get();
console.log('mover before:', JSON.stringify(before));
mover.snapTo(target);
const after = mover.translate.get();
const want  = target.translate.get();
console.log('mover after: ', JSON.stringify(after));
console.log('target was:  ', JSON.stringify(want));

// 4. Verify the world translate matches, and report (never a silent no-op).
const dx = after[0] - want[0], dy = after[1] - want[1], dz = after[2] - want[2];
const dist = Math.sqrt(dx*dx + dy*dy + dz*dz);
console.log(dist < 1e-5 ? 'MATCH' : 'MISMATCH', 'residual delta=' + dist.toExponential(2));

What you'll seeconsole: mover world translate before / after; final line "MATCH" or "MISMATCH" with the residual delta.

Open in editor →

Distribute and bottom-align a row of selected nodes

Build a scattered row of cubes, evenly space them along X via node.distribute, then snap every Y to the minimum so the whole row sits on one baseline.

Methods usedModelEditor.create.cube node.distribute node.align node.translate

Example

// Self-contained from an EMPTY scene: build a scattered row, then tidy it
// with distribute (even X spacing) + align (shared minimum Y baseline).

// 1. Build five cubes at deliberately uneven X + Y so the tidy-up is visible.
const xs = [0, 1.2, 5.5, 6.0, 9];
const ys = [0, 2.3, 0.7, 3.1, 1.4];
const nodes = [];
for (let i = 0; i < xs.length; i++) {
  const c = await create.cube({ width: 0.5, name: 'Row' + i });
  c.translate.set([xs[i], ys[i], 0]);
  nodes.push(c);
  select(null, { mode: 'clear' });
}

// 2. distribute(others, { axis, spacing? }): with spacing OMITTED it spaces
//    the set evenly between the FIRST and LAST node (linear mode). Pass
//    { axis: 'x', spacing: 2 } instead to force a fixed 2-unit step.
nodes[0].distribute(nodes.slice(1), { axis: 'x' });

// 3. align(others, { axis, mode }): mode 'min' | 'center' | 'max' collapses
//    the chosen axis to the set's minimum / mean / maximum. 'min' on Y drops
//    everything to a shared baseline.
nodes[0].align(nodes.slice(1), { axis: 'y', mode: 'min' });

// 4. Report the tidy result so it's never a silent no-op.
for (const n of nodes) {
  const p = n.translate.get();
  console.log(n.name, 'x=' + p[0].toFixed(3), 'y=' + p[1].toFixed(3));
}

What you'll seeconsole: per-node x / y after the pass; viewport: evenly spaced, bottom-aligned row.

Open in editor →

Place spheres on a line and distribute them evenly

Spawn five small spheres, pin the first and last to fixed anchors, then call node.distribute to space the middle three evenly between them.

Methods usedModelEditor.create.sphere Node.distribute ModelEditor.create.group mesh.bbox node.translate

Example

// Spawn five small spheres, anchor the two ends, and let node.distribute
// space the middle three evenly between them. Self-contained from empty.
// Run in meter-mode for the cleanest spacing (cm/mm grids apply an extra
// unit conversion through distribute, so world spacing reads differently).
const spheres = [];
for (let i = 0; i < 5; i++) {
  // create.sphere is async. widthSegments/heightSegments tune the tessellation.
  const s = await create.sphere({
    radius: 0.2,         // small beads
    widthSegments: 16,   // longitudinal segments (default 32)
    heightSegments: 8,   // latitudinal segments (default 16)
    name: 'Bead_' + i,
  });
  await select(null, { mode: 'clear' });
  spheres.push(s);
}

// Anchor the first bead at x=0 and the last at x=8. The middle three sit at
// the origin until distribute slides them into place.
spheres[0].xform({ t: [0, 0, 0] });
spheres[4].xform({ t: [8, 0, 0] });

// Linear distribute: the anchor (this) + the LAST of 'others' stay fixed,
// everything in between is spaced evenly along the axis. Pass the other four
// beads as a positional array; omitting 'spacing' selects linear mode.
spheres[0].distribute(spheres.slice(1), { axis: 'x' });

// Read back each bead's world-space center X (bbox lives under .geometry).
for (const s of spheres) {
  const b = s.geometry.bbox({ space: 'world' });
  const cx = ((b.min.x + b.max.x) / 2).toFixed(2);
  console.log(s.name, 'x =', cx);
}

// create.group(nodes, opts) is async — pass the bead array positionally.
const group = await create.group(spheres, { name: 'BeadRow' });
console.log('grouped', spheres.length, 'beads under', group.name);

What you'll seeconsole: each sphere's final world X position; outliner: 5 spheres under one group.

Open in editor →

Spatial Queries

Fill a character with spheres

Build a closed volume, then fill it with small spheres on a regular grid, keeping only the ones whose centre sits inside the surface.

Methods usedModelEditor.create.sphere ModelEditor.create.group mesh.geometry.bbox mesh.geometry.pointInside node.translate

Example

// Self-contained from an EMPTY scene: build a watertight volume, then pack
// its interior with a grid of small spheres (keeping only inside hits).

// 1. The volume to fill. A sphere is closed (watertight) so the inside test
//    is well-defined.
const volume = await create.sphere({
  radius: 1.5,           // 1.5 m radius (>0); default 1
  widthSegments: 24,     // longitude divisions; default 32
  heightSegments: 16,    // latitude divisions; default 16
  name: 'Volume',
});
select(null, { mode: 'clear' });

// 2. Walk a regular grid over the volume's world-space bounding box.
//    bbox / pointInside both live on the mesh.geometry namespace; space:
//    'world' applies the volume's transform first ('object' = local coords).
const bb = volume.geometry.bbox({ space: 'world' });
const step = 0.6;          // grid spacing in scene units (smaller = denser)
const packed = [];

for (let x = bb.min.x; x <= bb.max.x; x += step) {
  for (let y = bb.min.y; y <= bb.max.y; y += step) {
    for (let z = bb.min.z; z <= bb.max.z; z += step) {
      // Keep only grid points inside the closed surface.
      if (volume.geometry.pointInside([x, y, z], { space: 'world' })) {
        const dot = await create.sphere({ radius: step * 0.35 });
        dot.translate.set([x, y, z]);
        packed.push(dot);
        select(null, { mode: 'clear' });
      }
    }
  }
}

// 3. Parent the cluster under one group. create.group is ASYNC -> await.
const group = await create.group(packed, { name: volume.name + '_filled' });

// 4. Report so it's never a silent no-op.
console.log('packed', packed.length, 'spheres into', volume.name,
  'under group', group.name);

What you'll seeconsole: "packed N spheres into <volume name>"; viewport: a group of small spheres clustered inside the volume.

Open in editor →

Measure the distance between two named parts

Build two named parts, look them up by name, read their world translates, and report the straight-line distance through MathLib.distance.

Methods usedModelEditor.create.cube ModelEditor.scene.ls MathLib.distance node.translate

Example

// Self-contained from an EMPTY scene: build two named parts, position them,
// then measure the straight-line distance by NAME lookup (not by id).

// 1. Build the two parts off-origin.
const headBuilt = await create.cube({ width: 0.8, name: 'Head' });
headBuilt.translate.set([0, 3, 0]);
select(null, { mode: 'clear' });
const handBuilt = await create.cube({ width: 0.4, name: 'Hand' });
handBuilt.translate.set([1.5, 0.5, 0.5]);

// 2. Re-resolve BY NAME so the recipe reads like real-world usage. ls accepts
//    { type, name } where name is a string OR a RegExp (case-insensitive here).
const head = ls({ type: 'mesh', name: /head/i })[0];
const hand = ls({ type: 'mesh', name: /hand/i })[0];

// 3. Read world translates and measure.
const a = head.translate.get();   // [x, y, z]
const b = hand.translate.get();
console.log(head.name, 'at', JSON.stringify(a));
console.log(hand.name, 'at', JSON.stringify(b));

// 4. MathLib.distance(a, b) = sqrt of the summed squared component deltas.
const d = MathLib.distance(a, b);
console.log('distance', head.name, '->', hand.name, '=', d.toFixed(4), 'units');

What you'll seeconsole: per-part position + the distance in scene units.

Open in editor →

Find the nearest mesh to a target point

Build a spatial index from every mesh centroid in the scene and query the closest one to a target point. Marks the hit with a locator so the answer is visible.

Methods usedModelEditor.scene.ls MathLib.kdTree3D ModelEditor.create.locator MathLib.distance mesh.bbox node.translate

Example

// Build a kd-tree from mesh centroids, then snap to the closest.
const target = [0, 1, 0];
const meshes = ls({ type: 'mesh' });
if (meshes.length === 0) { console.warn('Need at least one mesh in scene.'); return; }

const centroids = meshes.map((m) => {
  const bb = m.bbox();
  return [
    (bb.min.x + bb.max.x) / 2,
    (bb.min.y + bb.max.y) / 2,
    (bb.min.z + bb.max.z) / 2,
  ];
});
const tree = MathLib.kdTree3D(centroids);
const hit = tree.closest(target);
const winner = meshes[hit.index];

const marker = create.locator({ name: 'nearest-marker' });
marker.translate.set(centroids[hit.index]);
const dist = MathLib.distance(target, centroids[hit.index]);
console.log('nearest:', winner.name, 'at distance', dist.toFixed(4));

What you'll seeconsole: nearest mesh name + distance; viewport: locator placed on the centroid of the winning mesh.

Open in editor →

Select every mesh within a radius

Scatter several meshes, build a kd-tree over their centroids, and select every mesh whose centroid sits inside a sphere around a probe point.

Methods usedModelEditor.create.cube MathLib.kdTree3D ModelEditor.scene.ls ModelEditor.scene.select mesh.geometry.bbox

Example

// Self-contained from an EMPTY scene: scatter cubes, then select the ones
// whose centroid falls inside a probe sphere via a kd-tree radius query.

// 1. Scatter eight cubes: some near the origin, some far away.
const placements = [
  [0, 0, 0], [1, 0, 1], [-1, 0.5, 0], [0.5, -0.5, -1],   // inside the radius
  [6, 0, 0], [0, 7, 0], [0, 0, -8], [5, 5, 5],            // outside
];
const meshes = [];
for (let i = 0; i < placements.length; i++) {
  const c = await create.cube({ width: 0.6, name: 'Box' + i });
  c.translate.set(placements[i]);
  meshes.push(c);
  select(null, { mode: 'clear' });
}

// 2. Compute each mesh's world-space centroid (bbox lives on mesh.geometry).
const centroids = meshes.map((m) => {
  const bb = m.geometry.bbox({ space: 'world' });
  return [
    (bb.min.x + bb.max.x) / 2,
    (bb.min.y + bb.max.y) / 2,
    (bb.min.z + bb.max.z) / 2,
  ];
});

// 3. Build the kd-tree and run a radius query. within(point, radius) returns
//    { indices, distances } (paired arrays sorted ascending by distance).
const probe = [0, 0, 0];
const radius = 3;
const tree = MathLib.kdTree3D(centroids);
const result = tree.within(probe, radius);
const winners = result.indices.map((i) => meshes[i]);

// 4. Select the hits in ONE replace call, then report (never a silent no-op).
await select(winners);
console.log('selected', winners.length, 'of', meshes.length,
  'meshes within', radius, 'units of', JSON.stringify(probe) + ':',
  winners.map((m) => m.name).join(', '));

What you'll seeconsole: list of selected mesh names within the radius; outliner: exactly those meshes appear selected.

Open in editor →

Compute the bounding-box union of the selection

Build a spread of meshes, combine their bounding boxes into one envelope, then drop markers at the min and max corners so the combined volume is visible.

Methods usedModelEditor.create.cube ModelEditor.create.locator MathLib.distance mesh.geometry.bbox node.translate

Example

// Self-contained from an EMPTY scene: build a spread of meshes, then union
// their bounding boxes and mark the two extreme corners.

// 1. Three meshes of different sizes at different positions.
const a = await create.cube({ width: 1, height: 1, depth: 1, name: 'PartA' });
a.translate.set([-2, 0, 0]);
select(null, { mode: 'clear' });
const b = await create.cube({ width: 2, height: 0.5, depth: 1, name: 'PartB' });
b.translate.set([3, 1, 0]);
select(null, { mode: 'clear' });
const c = await create.sphere({ radius: 0.8, name: 'PartC' });
c.translate.set([0, -2, 2]);
select(null, { mode: 'clear' });

const parts = [a, b, c];

// 2. Union every part's WORLD bounding box (bbox lives on mesh.geometry).
const min = [Infinity, Infinity, Infinity];
const max = [-Infinity, -Infinity, -Infinity];
for (const m of parts) {
  const bb = m.geometry.bbox({ space: 'world' });
  const mn = [bb.min.x, bb.min.y, bb.min.z];
  const mx = [bb.max.x, bb.max.y, bb.max.z];
  for (let i = 0; i < 3; i++) {
    if (mn[i] < min[i]) min[i] = mn[i];
    if (mx[i] > max[i]) max[i] = mx[i];
  }
}

// 3. Drop markers at the two extreme corners (create.locator is SYNC).
const minMarker = create.locator({ name: 'UnionMin', position: min });
const maxMarker = create.locator({ name: 'UnionMax', position: max });

// 4. Report the envelope + its diagonal (never a silent no-op).
console.log('union bbox min', JSON.stringify(min.map((v) => +v.toFixed(3))),
  'max', JSON.stringify(max.map((v) => +v.toFixed(3))),
  '| diagonal', MathLib.distance(min, max).toFixed(3), 'units',
  '| markers', minMarker.name, '+', maxMarker.name);

What you'll seeconsole: union bbox min / max + diagonal length; viewport: two markers framing the combined volume.

Open in editor →

Snap a marker to the nearest vertex on a mesh

Build a mesh, index every vertex into a kd-tree, then snap a fresh marker to the vertex closest to a probe point.

Methods usedModelEditor.create.sphere MathLib.kdTree3D ModelEditor.create.locator mesh.verts node.translate

Example

// Self-contained from an EMPTY scene: build a mesh, index its vertices, then
// snap a marker onto whichever vertex is closest to a probe point.

// 1. A sphere gives a dense, evenly distributed vertex set to search.
const mesh = await create.sphere({
  radius: 1.5,           // 1.5 m radius (>0)
  widthSegments: 24,     // longitude divisions
  heightSegments: 16,    // latitude divisions
  name: 'Ball',
});
select(null, { mode: 'clear' });

// 2. Collect every vertex world position into a point cloud. mesh.verts.count
//    = vertex total; mesh.verts.position(i) returns a Vec3 (.x / .y / .z).
const points = [];
for (let i = 0; i < mesh.verts.count; i++) {
  const p = mesh.verts.position(i);
  points.push([p.x, p.y, p.z]);
}

// 3. Build the kd-tree and ask for the single closest vertex to the probe.
//    closest(point) returns { index, distance } (index into the point cloud).
const probe = [2, 0.5, 0.5];   // outside the sphere, off to +X
const tree = MathLib.kdTree3D(points);
const hit = tree.closest(probe);

// 4. Drop a marker on that vertex and report (never a silent no-op).
const winner = points[hit.index];
const marker = create.locator({ name: 'VertMarker', position: winner });
console.log('probe', JSON.stringify(probe),
  '-> nearest vertex', hit.index, 'at', JSON.stringify(winner.map((v) => +v.toFixed(3))),
  '| distance', hit.distance.toFixed(4), 'units | marker', marker.name);

What you'll seeconsole: nearest vertex index + position + distance; viewport: a marker named "VertMarker" sitting on that vertex.

Open in editor →

Build, query, expand, transform, and compare bounding boxes

Pull a mesh AABB, then construct boxes via from / fromCenterAndSize / fromPoints / empty. Read every property (center / min / max / size / width / height / depth / isEmpty), exercise expand / expandBox / clone / transformedBy, and run contains / intersects / equals predicates.

Example

// Build, query, expand, transform, and compare bounding boxes. Pull a real
// mesh AABB, then construct boxes via every static factory and exercise the
// full property + op + predicate surface. Self-contained from empty.

const cube = await create.cube({ width: 2, height: 1, depth: 0.5, name: 'BBoxCube' });
cube.xform({ t: [2.5, 1.3, -0.7] });
await select(null, { mode: 'clear' });
await Utils.wait.frame();

// MESH AABB — bbox lives under mesh.geometry; world space applies the
// node transform. min/max/center/size are Vec3 (each has .toArray()).
const bb = cube.geometry.bbox({ space: 'world' });
console.log('bb.min:', bb.min.toArray(), 'bb.max:', bb.max.toArray());
console.log('bb.center:', bb.center.toArray(), 'bb.size:', bb.size.toArray());
console.log('bb.width:', bb.width, 'bb.height:', bb.height, 'bb.depth:', bb.depth);
console.log('bb.isEmpty:', bb.isEmpty);

// STATIC FACTORIES — from(min,max) / fromCenterAndSize / fromPoints / empty.
const a = MathLib.BoundingBox.from([0, 0, 0], [1, 2, 3]);              // explicit min/max
const b = MathLib.BoundingBox.fromCenterAndSize([5, 0, 0], [2, 2, 2]); // center + extents
const c = MathLib.BoundingBox.fromPoints([                            // tight AABB over points
  [0, 0, 0], [1, 1, 1], [-1, 0.5, -0.5],
]);
const e = MathLib.BoundingBox.empty();                                // inverted/empty sentinel

console.log('a.toArray:', JSON.stringify(a.toArray())); // { min, max }
console.log('b.center:', b.center.toArray(), 'b.size:', b.size.toArray());
console.log('c.min:', c.min.toArray(), 'c.max:', c.max.toArray());
console.log('e.isEmpty:', e.isEmpty); // true

// OPS — every mutator returns a NEW box (BoundingBox is immutable).
const expanded = a.expand([3, 3, 3]);    // grow to include a point
console.log('a.expand([3,3,3]).max:', expanded.max.toArray());
const merged = a.expandBox(b);           // union of two boxes
console.log('a.expandBox(b) min/max:', merged.min.toArray(), merged.max.toArray());
const cloned = a.clone();
console.log('a.clone().equals(a):', cloned.equals(a)); // true

// PREDICATES.
console.log('a.contains([0.5,1,1.5]):', a.contains([0.5, 1, 1.5])); // true (inside)
console.log('a.intersects(b):', a.intersects(b));                   // false (disjoint)

// TRANSFORM — by a column-major 4x4 matrix; here a +5 translate along X.
const moved = a.transformedBy([
  1, 0, 0, 0,
  0, 1, 0, 0,
  0, 0, 1, 0,
  5, 0, 0, 1,
]);
console.log('a.transformedBy(+5x).min:', moved.min.toArray(), 'max:', moved.max.toArray());
console.log('bounding-box math complete.');

What you'll seeconsole: mesh AABB + 4 static-factory boxes + every property + expand / expandBox / clone results + contains / intersects predicates + transformedBy result.

Open in editor →

Build and query 2D and 3D spatial indexes

Construct MathLib.kdTree3D and MathLib.kdTree2D over a synthetic point cloud; demonstrate the KdTree3D + KdTree2D class re-exports.

Methods usedMathLib.kdTree3D MathLib.kdTree2D MathLib.KdTree3D MathLib.KdTree2D

Example

const points3 = [[0,0,0], [1,1,1], [2,0,0], [3,3,3], [0,2,1]];
const tree3 = MathLib.kdTree3D(points3);
console.log('kdTree3D instanceof KdTree3D:', tree3 instanceof MathLib.KdTree3D);

const closest3 = tree3.closest([1.1, 1.0, 1.0]);
console.log('3D closest to [1.1,1,1]:', JSON.stringify(closest3));

const within3 = tree3.within([0, 0, 0], 2.5);
console.log('3D within 2.5 of origin:', JSON.stringify({ count: within3.indices.length }));

const points2 = [[0,0], [1,0], [0,1], [1,1], [0.5,0.5]];
const tree2 = MathLib.kdTree2D(points2);
console.log('kdTree2D instanceof KdTree2D:', tree2 instanceof MathLib.KdTree2D);

const closest2 = tree2.closest([0.4, 0.6]);
console.log('2D closest to [0.4,0.6]:', JSON.stringify(closest2));

const knn2 = tree2.knearest([0, 0], 3);
console.log('2D 3-nearest to origin:', JSON.stringify(knn2));

What you'll seeconsole: tree types verified via instanceof; closest + within results.

Open in editor →

Attributes

Tidy the channel box & add a custom attribute

Hide channels you do not animate, add a user-defined float attribute, and list what is left. setKeyable controls channel-box visibility only; it does not lock the value.

Methods usednode.attr node.addAttr node.attrs

Example

// Pick the first selected node.
const n = ls({selected: true})[0];
if (!n) { console.log('Select an object first.'); return; }

// Hide the scale channels from the channel box (the value is still settable;
// keyable only controls visibility, independent of lock).
n.attr('scale').setKeyable(false);
console.log('scale keyable?', n.attr('scale').isKeyable());

// Add a custom float channel and make it keyable.
n.addAttr({ ln: 'wobbleAmount', at: 'float', dv: 0.5, k: true });
n.attr('wobbleAmount').set(0.75);
console.log('wobbleAmount =', n.attr('wobbleAmount').getAsString());

// List what shows in the channel box now (keyable attrs only).
console.log('keyable channels:', JSON.stringify(n.attrs({ keyable: true })));
console.log('custom channels:', JSON.stringify(n.attrs({ userDefined: true })));

What you'll seeconsole output shows scale keyable=false, wobbleAmount=0.75, and lists keyable + user-defined channels.

Open in editor →

Drive one attribute from another

Connect a source attribute so it drives a destination (attribute-driven connection). Pass { force: true } to replace an existing incoming connection in one undoable step.

Methods usedModelEditor.create.cube node.addAttr node.attr attribute.connectFrom

Example

// Add a driver channel on cube A and a driven channel on cube B,
// then wire them so B follows A. (Deselect between spawns so each polyCube
// makes exactly one cube.)
const A = await create.cube({ name: 'Driver' });   select(null, {mode: 'clear'});
const B = await create.cube({ name: 'Driven' });   select(null, {mode: 'clear'});
A.addAttr({ ln: 'amount', at: 'float', dv: 1, k: true });
B.addAttr({ ln: 'follows', at: 'float', dv: 0, k: true });

B.attr('follows').connectFrom(A.attr('amount'));
A.attr('amount').set(5);
console.log('B.follows =', B.attr('follows').get()); // 5

// Reconnect to a different source; force replaces the existing one.
const C = await create.cube({ name: 'Driver2' });  select(null, {mode: 'clear'});
C.addAttr({ ln: 'amount', at: 'float', dv: 9, k: true });
B.attr('follows').connectFrom(C.attr('amount'), { force: true });
console.log('B.follows now =', B.attr('follows').get()); // 9

What you'll seeconsole output shows B.follows=5 after driving from A, then =9 after reconnecting to C with force.

Open in editor →

Add a bounded slider attribute (min / max)

Use min and max on addAttr to clamp a custom channel to a range. Out-of-range set() throws so script errors surface loudly instead of silently clamping.

Methods usednode.addAttr node.attr

Example

// Add a normalized "wetness" slider on the first selected node.
const n = ls({selected: true})[0];
if (!n) { console.log('Select an object first.'); return; }

n.addAttr({ ln: 'wetness', at: 'float', dv: 0.5, k: true, min: 0, max: 1 });
n.attr('wetness').set(0.75);
console.log('wetness =', n.attr('wetness').get()); // 0.75

// Out-of-range writes throw (no silent clamp; the caller decides intent).
try {
  n.attr('wetness').set(2);
} catch (err) {
  console.log('out-of-range rejected:', err.message);
}

What you'll seeconsole: wetness=0.75; out-of-range write rejected with InvalidArgumentError.

Open in editor →

Hide an internal state attribute from the channel box

Use hidden:true to keep a custom attribute out of the channel box. Useful for rig-internal state that scripts read but artists should not edit.

Methods usednode.addAttr node.attr node.attrs

Example

const n = ls({selected: true})[0];
if (!n) { console.log('Select an object first.'); return; }

n.addAttr({ ln: 'rigState', at: 'string', dv: 'idle', hidden: true });
console.log('rigState =', n.attr('rigState').get()); // 'idle'

// hidden:true attrs do NOT appear in the keyable list, so the channel box
// reads keyable, so a hidden attr is effectively invisible to artists.
console.log('keyable channels:', JSON.stringify(n.attrs({ keyable: true })));

What you'll seeconsole: rigState=idle; hidden attribute does NOT appear in the keyable channel list.

Open in editor →

Clean up every custom attribute on a node

Iterate the user-defined attribute list and remove each one. Undo restores everything, including any connections that were live when the attr was removed.

Methods usednode.addAttr node.attrs node.removeAttr

Example

const n = ls({selected: true})[0];
if (!n) { console.log('Select an object first.'); return; }

// Seed a few custom attrs so the sweep has work to do.
n.addAttr({ ln: 'a', at: 'float', dv: 1 });
n.addAttr({ ln: 'b', at: 'float', dv: 2 });
console.log('before:', JSON.stringify(n.attrs({ custom: true })));

// custom: true is an alias for userDefined: true.
n.attrs({ custom: true }).forEach(name => n.removeAttr(name));
console.log('after:', JSON.stringify(n.attrs({ custom: true }))); // []

What you'll seeconsole: before list with custom attrs, after list empty.

Open in editor →

Wire and unwire attributes from the Node handle

Node.connect / Node.disconnect take both endpoints as paths; convenient when you have the source and destination Node handles in scope. Pass force:true to replace an existing incoming connection.

Methods usedModelEditor.create.cube node.addAttr node.connect node.attr node.disconnect

Example

const A = await create.cube({ name: 'Source' });   select(null, {mode: 'clear'});
const B = await create.cube({ name: 'Dest' });     select(null, {mode: 'clear'});
A.addAttr({ ln: 'driver', at: 'float', dv: 7, k: true });
B.addAttr({ ln: 'driven', at: 'float', dv: 0, k: true });

A.connect(B, 'driver', 'driven');
A.attr('driver').set(11);
console.log('B.driven =', B.attr('driven').get()); // 11

A.disconnect(B, 'driver', 'driven');
console.log('B.driven (post-disconnect) =', B.attr('driven').get()); // 0

What you'll seeconsole: B.driven=11 after connect, then =0 after disconnect.

Open in editor →

Paint a deformer falloff from distance to a reference point

Build a mesh + a twist deformer, then write a 1/(1+d) per-vertex weight from each vertex to a reference marker so the deform fades out with distance. Demonstrates the per-vertex weight setter on a live deformer.

Methods usedModelEditor.create.cube ModelEditor.create.locator mesh.verts mesh.deformers.add node.translate deformer.setWeight

Example

// Self-contained from an EMPTY scene: build a mesh + a twist deformer, then
// paint its per-vertex envelope weights by inverse distance to a marker so
// the twist fades out the further a vertex is from the marker.

// 1. A subdivided cube so there are enough vertices to show a falloff.
const mesh = await create.cube({
  width: 1, height: 3, depth: 1,
  subdivisionsX: 2, subdivisionsY: 6, subdivisionsZ: 2,   // denser = smoother falloff
  name: 'Limb',
});
select(null, { mode: 'clear' });

// 2. A reference marker the weight falls off from (create.locator is SYNC).
const ref = create.locator({ name: 'WeightSource', position: [0, 1.5, 0] });
const refPos = ref.translate.get();   // [x, y, z]

// 3. Add a twist deformer. deformers.add(type, opts) is ASYNC -> await;
//    'nonLinear' needs { mode: 'bend' | 'twist' | 'taper' | 'squash' |
//    'sine' | 'wave' }. The returned handle exposes per-vertex weights.
const twist = await mesh.deformers.add('nonLinear', { mode: 'twist' });

// 4. Paint inverse-distance weights: w = 1 / (1 + d). setWeight(i, w) writes
//    ONE vertex per undo entry (full-buffer assignment is rejected; use
//    setWeights(fn) for a single-undo bulk write instead).
let minW = Infinity, maxW = -Infinity;
for (let i = 0; i < mesh.verts.count; i++) {
  const p = mesh.verts.position(i);   // Vec3, undeformed base position
  const dx = p.x - refPos[0], dy = p.y - refPos[1], dz = p.z - refPos[2];
  const d = Math.sqrt(dx * dx + dy * dy + dz * dz);
  const w = 1 / (1 + d);              // 1 at the marker, fading toward 0
  twist.setWeight(i, w);
  if (w < minW) minW = w;
  if (w > maxW) maxW = w;
}

// 5. Prove the weights drive the deform: compare deformed vs base positions
//    and report the peak per-vertex displacement (never a silent no-op).
const deformed = mesh.deformers.evaluatedPositions();
const base = mesh.deformers.basePositions();
let peak = 0;
for (let i = 0; i < base.length; i += 3) {
  const dx = deformed[i] - base[i];
  const dy = deformed[i + 1] - base[i + 1];
  const dz = deformed[i + 2] - base[i + 2];
  peak = Math.max(peak, Math.sqrt(dx * dx + dy * dy + dz * dz));
}
console.log('painted', mesh.verts.count, 'verts;',
  'weight range [' + minW.toFixed(3) + ', ' + maxW.toFixed(3) + '];',
  'peak deform delta', peak.toFixed(4), 'm');

What you'll seeconsole: vertex count painted + min/max weight + a non-zero peak deform delta proving the weights drive the deform.

Open in editor →

Attribute lifecycle: lock, limits, keyable, getAsAngle/getAsString

Walk an Attribute through its full state space. nodeId + path identify it; get/set is the value pair; lock/isLocked guards writes; setLimits/getLimits/enableLimits enforce ranges; setKeyable/isKeyable toggles channel-box visibility; getAsAngle / getAsString are typed readers.

Methods usedModelEditor.create.cube node.attr node.addAttr attribute.nodeId attribute.path attribute.get attribute.set attribute.lock attribute.isLocked attribute.setLimits attribute.getLimits attribute.enableLimits attribute.isKeyable attribute.setKeyable attribute.getAsString attribute.getAsAngle

Example

// Self-contained from an empty Model scene. Walk one Attribute through its
// full state space: identity -> read/write -> limits -> lock -> keyable ->
// typed reads.
const cube = await create.cube({ width: 1, height: 1, depth: 1, name: 'AttrDeep' });
select(null, { mode: 'clear' });

// Add two user-defined channels. 'at' is float/int/bool/float3/string/enum
// (there is NO 'angle' type) - getAsAngle works on any float, treating the
// stored value as radians.
cube.addAttr({ ln: 'wobble', at: 'float', dv: 0.5, k: true, min: 0, max: 1 }); // keyable, bounded
cube.addAttr({ ln: 'spinAngle', at: 'float', dv: Math.PI / 4, k: false });     // 45 deg in radians

const wob = cube.attr('wobble'), ang = cube.attr('spinAngle');

// IDENTITY — nodeId + path locate the attribute.
console.log('id:', wob.nodeId, '| path:', wob.path);

// READ / WRITE.
console.log('initial get:', wob.get());
wob.set(0.75); console.log('after set 0.75:', wob.get());

// LIMITS — setLimits defines the range; enableLimits(true) starts enforcing.
wob.setLimits(0, 1); console.log('limits:', JSON.stringify(wob.getLimits()));
wob.enableLimits(true);
try { wob.set(2); } catch (e) { console.log('out-of-range rejected:', e.code); }
wob.enableLimits(false); wob.set(2); console.log('unbounded set 2:', wob.get()); // limits off -> accepted

// LOCK — guards writes entirely (independent of keyable + limits).
wob.lock(true); console.log('isLocked?', wob.isLocked());
try { wob.set(0); } catch (e) { console.log('locked rejected:', e.code); }
wob.lock(false);

// KEYABLE — channel-box visibility toggle; does NOT lock the value.
console.log('isKeyable:', wob.isKeyable());
wob.setKeyable(false); console.log('after setKeyable(false):', wob.isKeyable());
wob.setKeyable(true);

// TYPED READS.
console.log('wob.getAsString():', wob.getAsString());
console.log('ang.getAsString():', ang.getAsString());
console.log('ang.getAsAngle() deg:', ang.getAsAngle().toFixed(2));                  // default units = 'degrees' -> 45.00
console.log('ang.getAsAngle({radians}):', ang.getAsAngle({ units: 'radians' }).toFixed(3)); // 0.785

What you'll seeconsole: identity + r/w + bounds + lock + keyable + typed reads.

Open in editor →

Inspect a deformer handle: meshId, type, displayName, envelope, weights

DeformerHandle exposes the live deformer record. Identity: meshId + deformerId + deformerType + displayName. Common params: envelope + enabled. Per-vertex: weights[i] read + setWeight(i, w) write.

Methods usedModelEditor.create.cube Utils.wait.frame mesh.addSmooth node.translate deformerHandle.meshId deformerHandle.deformerId deformerHandle.deformerType deformerHandle.displayName deformerHandle.envelope deformerHandle.enabled deformerHandle.weights deformerHandle.setWeight

Example

// Inspect a live DeformerHandle end-to-end: identity, the common
// envelope/enabled attributes, and the per-vertex weight array.
// Self-contained from an empty Model scene.

// A subdivided cube gives the deformer enough vertices to weight-paint.
const cube = await create.cube({
  width: 1, height: 1, depth: 1,
  subdivisionsX: 2, subdivisionsY: 2, subdivisionsZ: 2, // 3x3x3 grid of verts per face
  name: 'DefIntro',
});
cube.xform({ t: [2.5, 1.3, -0.7] }); // park off-origin so BVH + renderer stay fresh
await select(null, { mode: 'clear' });
await Utils.wait.frame();

// Add a Smooth deformer. mesh.deformers.add(type, opts?) is async and
// returns the typed handle (SmoothHandle here).
const smooth = await cube.deformers.add('smooth');

// IDENTITY — every handle carries the host meshId + its own deformerId +
// the deformerType string + a human-readable displayName.
console.log('meshId:', smooth.meshId);
console.log('deformerId:', smooth.deformerId);
console.log('deformerType:', smooth.deformerType); // 'smooth'
console.log('displayName:', smooth.displayName);

// COMMON ATTRS — envelope (0..1 overall strength) + enabled (on/off toggle).
console.log('envelope:', smooth.envelope.get()); // default 1
console.log('enabled:', smooth.enabled.get());    // default true

// PER-VERTEX WEIGHTS — weights[] is one float per vertex (length === vertexCount).
console.log('weights.length:', smooth.weights.length);
console.log('weights[0]:', smooth.weights[0]);

// WRITE WEIGHTS — every write must go through setWeight(i, w); each call is
// one undo step. Ramp the first four verts from 0.5 up to 0.8.
for (let i = 0; i < Math.min(4, smooth.weights.length); i++) {
  smooth.setWeight(i, 0.5 + 0.1 * i); // i=0 -> 0.5, i=3 -> 0.8 (weights clamp to 0..1)
}
console.log('weights[0..3]:', [
  smooth.weights[0].toFixed(2), smooth.weights[1].toFixed(2),
  smooth.weights[2].toFixed(2), smooth.weights[3].toFixed(2),
].join(' '));

// FADE + TOGGLE — exercise the typed attribute setters (each is undoable).
smooth.envelope.set(0.5); // half strength
console.log('envelope after set 0.5:', smooth.envelope.get());
smooth.enabled.set(false); // disabled but retained in the stack
console.log('enabled after set false:', smooth.enabled.get());
smooth.enabled.set(true);  // re-enable

console.log('deformer-handle introspection done on "' + cube.name + '"');

What you'll seeconsole: handle identity + weights length + write evidence.

Open in editor →

DeformerAttribute: typed param access on a deformer record

DeformerAttribute is the per-parameter handle on a deformer. meshId + deformerId + param identify it; get/set is the typed value pair.

Methods usedModelEditor.create.cube Utils.wait.frame mesh.addBend node.translate deformerAttribute.meshId deformerAttribute.deformerId deformerAttribute.param deformerAttribute.get deformerAttribute.set

Example

// DeformerAttribute is the typed per-parameter handle hanging off a
// deformer record. Identity is (meshId, deformerId, param); get()/set() is
// the typed read/write pair. Self-contained from an empty Model scene.

const cube = await create.cube({
  width: 1.2, height: 1.2, depth: 1.2,
  subdivisionsX: 4, subdivisionsY: 4, subdivisionsZ: 4, // dense enough for the bend to read
  name: 'DefAttr',
});
cube.xform({ t: [5.0, 1.3, -0.7] });
await select(null, { mode: 'clear' });
await Utils.wait.frame();

// A Bend is a non-linear deformer — add it with mode:'bend'.
const bend = await cube.deformers.add('nonLinear', { mode: 'bend' });

// Pull two DeformerAttributes off the handle. envelope is number-typed;
// enabled is boolean-typed. curvature is the bend-specific shape attr.
const env = bend.envelope;       // DeformerAttribute<number>
const ena = bend.enabled;        // DeformerAttribute<boolean>
const curv = bend.curvature;     // DeformerAttribute<number> (bend-only)

// IDENTITY — each attribute names its mesh, deformer, and param slot.
console.log('env meshId:', env.meshId);
console.log('env deformerId:', env.deformerId);
console.log('env param:', env.param);     // 'envelope'
console.log('ena param:', ena.param);     // 'enabled'
console.log('curv param:', curv.param);   // 'curvature'

// INITIAL READS.
console.log('envelope.get():', env.get());
console.log('enabled.get():', ena.get());
console.log('curvature.get():', curv.get());

// TYPED WRITES — each set() lands one undo entry; wrong-typed values throw.
env.set(0.25);   // fade the bend to a quarter strength (0..1)
console.log('envelope after set 0.25:', env.get());
curv.set(1.5);   // stronger curvature (radians of bend per unit height)
console.log('curvature after set 1.5:', curv.get());
ena.set(false);  // disable without removing
console.log('enabled after set false:', ena.get());

// Restore.
env.set(1.0);
ena.set(true);
console.log('deformer-attribute read/write done on "' + cube.name + '"');

What you'll seeconsole: identity + initial reads + post-write reads.

Open in editor →

Vec3Attribute: read translate axes from a compound plug

Compound 3-vector handle on every Transform. Inspect the basePath plus the three per-axis Attribute<number> descriptors.

Methods usedvec3Attribute.basePath vec3Attribute.x vec3Attribute.y vec3Attribute.z

Example

// node.translate / node.rotate / node.scale are Vec3Attribute instances.
// Self-contained: spawn a cube off-origin, then walk the compound plug.
const cube = await create.cube({
  width: 1, height: 1, depth: 1, name: 'Vec3AttrDemo',
});
cube.translate.set([2.5, 1.3, -0.7]); // whole-vector write via the [x,y,z] setter

// The compound handle exposes basePath plus three per-axis Attribute<number>.
const t = cube.translate;
console.log('basePath:', t.basePath); // -> 'translate'
console.log('vector get():', JSON.stringify(t.get().map((v) => +v.toFixed(3))));
console.log('x.get():', t.x.get().toFixed(3),
  '| y.get():', t.y.get().toFixed(3),
  '| z.get():', t.z.get().toFixed(3));

// Per-axis writes flow through the SAME compound plug as the [x,y,z] setter:
// the other two components are preserved.
t.x.set(t.x.get() + 0.5); // bump X by 0.5 m, leave Y/Z untouched
await Utils.wait.frame();
console.log('after bumping x by 0.5:', JSON.stringify(cube.translate.get().map((v) => +v.toFixed(3))));

// Per-axis lock is independent: locking translate.x leaves Y/Z writable.
t.x.lock(true);
console.log('translate.x locked? (writes to X now throw)');
t.y.set(9.9);             // Y is still free
console.log('y after locked-x write:', cube.translate.y.get().toFixed(3));
t.x.lock(false);          // release the lock so the demo leaves a clean node

select(null, { mode: 'clear' });

What you'll seeconsole: basePath = "translate"; per-axis get() values matching the cube position; bumped X after a per-axis set.

Open in editor →

Outliner

Sort + lock the outliner for a clean review

Move named heroes to the top, lock finished assets, and filter for review.

Methods usedModelEditor.scene.ls ModelEditor.dev.outliner.expandAll ModelEditor.dev.outliner.setFilter ModelEditor.dev.outliner.setDisplayMode node.moveToIndex node.lock node.isLocked

Example

// Sort + lock for a clean outliner review pass.
// Promote anything named "Hero*" to the top of the sibling list.
const heroes = ls({ type: 'mesh', name: /^Hero/ });
for (const h of heroes) h.moveToIndex(0);

// Lock every mesh tagged "_FINAL" in its name so a stray drag won't disturb it.
for (const m of ls({ type: 'mesh', name: /_FINAL$/ })) {
  if (!m.isLocked) m.lock();
}

// Open the outliner all the way + filter to the heroes for a final pass.
dev.outliner.expandAll();
dev.outliner.setFilter('Hero');
dev.outliner.setDisplayMode({ showShapes: false, showTypes: true });

console.log('promoted', heroes.length, 'heroes; locked all _FINAL meshes.');

What you'll seeconsole line with hero count and lock count; outliner expanded + filtered to "Hero".

Open in editor →

Batch-rename every mesh with an index prefix

List every mesh in the scene, capture the original names for a verification pass, then rename each one as "<idx>_<oldName>".

Methods usedModelEditor.scene.ls node.rename

Example

// Prefix every mesh with a zero-padded index. Single undo for the whole pass.
// Capture the original list first so we can verify each rename landed.
const meshes = ls({ type: 'mesh' });
const before = meshes.map((m) => m.name);
console.log('renaming', meshes.length, 'meshes');

meshes.forEach((m, i) => {
  const idx = String(i + 1).padStart(3, '0');
  const newName = idx + '_' + before[i];
  m.rename(newName);
});

// Verification pass: report every before / after pair so the user can spot
// surprises (e.g., auto-disambiguation appending a numeric suffix).
meshes.forEach((m, i) => {
  console.log('  ' + before[i] + ' -> ' + m.name);
});
console.log('done; one Ctrl+Z reverts all', meshes.length, 'renames');

What you'll seeOutliner shows every mesh prefixed with "001_", "002_", ...; console reports before/after pairs; one undo step reverts everything.

Open in editor →

Group the selection under a named parent

Build a few parts, then wrap them under a fresh group named after a prefix you pick. The whole operation lands as one undoable batch.

Methods usedModelEditor.create.cube ModelEditor.create.group node.translate

Example

// Self-contained from an EMPTY scene: build a few parts, then wrap them all
// under one named group in a single undoable batch.

// 1. Build the parts to group.
const partNames = ['Wheel', 'Axle', 'Hub'];
const parts = [];
for (let i = 0; i < partNames.length; i++) {
  const c = await create.cube({ width: 0.6, name: partNames[i] });
  c.translate.set([i * 1.0, 0, 0]);
  parts.push(c);
  select(null, { mode: 'clear' });
}

// 2. Stamp the group with a stable prefix + a time suffix so repeated runs
//    don't collide on the auto-naming pass.
const groupName = 'Assembly_' + Date.now();

// 3. Wrap the parts under one group. create.group(nodes, { name }) is ASYNC
//    -> await; passing the nodes array reparents them under the new group.
const group = await create.group(parts, { name: groupName });

// 4. Report the result (never a silent no-op).
console.log('grouped', parts.length, 'children under', group.name);
for (const child of parts) console.log('  child:', child.name);

What you'll seeconsole: group name + child count + each child name; outliner: a new group containing the parts.

Open in editor →

Build a Group with two cube children, then read identity (name, id, nodeType, toString) and walk parent / children / descendants / ancestors.

Methods usedModelEditor.create.cube Utils.wait.frame ModelEditor.scene.ls node.translate node.parent node.children node.descendants node.ancestors node.equals node.name node.id node.nodeId node.nodeType node.toString

Example

// Build a small tree (Group with two cube children) then read identity and
// walk it in both directions with the Node API. Self-contained from empty.

const cube1 = await create.cube({ width: 1, height: 1, depth: 1, name: 'NavLeaf1' });
cube1.xform({ t: [2.5, 1.3, -0.7] });
await select(null, { mode: 'clear' });

const cube2 = await create.cube({ width: 0.6, height: 0.6, depth: 0.6, name: 'NavLeaf2' });
cube2.xform({ t: [5.0, 1.3, -0.7] });
await select(null, { mode: 'clear' });

// create.group(nodes, opts) is async — pass [] for an empty group, then
// reparent the leaves under it (setParent is async).
const group = await create.group([], { name: 'NavRoot' });
await cube1.setParent(group);
await cube2.setParent(group);
await Utils.wait.frame();

// IDENTITY — toString + name + nodeType + id/nodeId (id === nodeId).
console.log('group toString:', group.toString());
console.log('group name:', group.name, 'nodeType:', group.nodeType); // 'group'
console.log('group id matches nodeId?', group.id === group.nodeId);

// WALK DOWN — direct children vs every transitive descendant.
const direct = group.children();
console.log('direct children:', direct.map((c) => c.name).join(', '));
const all = group.descendants();
console.log('total descendants:', all.length);

// WALK UP — parent + the full ancestor chain from a leaf.
console.log('cube1 parent:', cube1.parent()?.name ?? '(root)');
const up = cube1.ancestors();
console.log('cube1 ancestors:', up.map((a) => a.name).join(' -> '));

// EQUALITY — by nodeId, not handle reference. Re-resolve by NAME and compare.
const same = ls({ name: 'NavLeaf1' })[0];
console.log('cube1 equals re-resolved handle?', same ? cube1.equals(same) : false);
console.log('scene-graph navigation complete.');

What you'll seeconsole: group toString + identity, direct + transitive child lists, leaf ancestors, equality across re-resolved handles.

Open in editor →

Reorder, reparent, unparent, and delete sibling nodes

Spawn three sibling cubes, swap their order with moveBefore / moveAfter / moveUp / moveDown, group two of them, then unparent and delete.

Methods usedModelEditor.create.cube Utils.wait.frame ModelEditor.scene.ls node.translate node.moveBefore node.moveAfter node.moveUp node.moveDown node.unparent node.delete

Example

// Spawn three sibling cubes, reshuffle their sibling order, group two of
// them, unparent one, and delete one. All structural Node ops are async.
// Self-contained from an empty Model scene.
const a = await create.cube({ width: 1, height: 1, depth: 1, name: 'OrderA' });
a.xform({ t: [2.5, 1.3, -0.7] });
await select(null, { mode: 'clear' });
const b = await create.cube({ width: 1, height: 1, depth: 1, name: 'OrderB' });
b.xform({ t: [5.0, 1.3, -0.7] });
await select(null, { mode: 'clear' });
const c = await create.cube({ width: 1, height: 1, depth: 1, name: 'OrderC' });
c.xform({ t: [7.5, 1.3, -0.7] });
await select(null, { mode: 'clear' });
await Utils.wait.frame();

const printOrder = (label) => {
  const names = ls({ type: 'mesh' })
    .filter((n) => /^Order/.test(n.name))
    .map((n) => n.name).join(', ');
  console.log(label + ':', names);
};
printOrder('initial');

// moveBefore / moveAfter — anchor relative to a named sibling.
await b.moveBefore(a);
printOrder('after b.moveBefore(a)');
await c.moveAfter(b);
printOrder('after c.moveAfter(b)');

// moveUp / moveDown — single-step bumps; no-op at the list boundaries.
await a.moveUp();
printOrder('after a.moveUp');
await b.moveDown();
printOrder('after b.moveDown');

// Group two cubes (empty group via [] then reparent), then unparent one.
const grp = await create.group([], { name: 'OrderGroup' });
await a.setParent(grp);
await b.setParent(grp);
console.log('grp children:', grp.children().map((n) => n.name).join(', '));
await a.unparent();
console.log('a parent after unparent:', a.parent()?.name ?? '(root)');

// Delete C — its handle goes stale; name lookups return undefined afterward.
await c.delete();
const remaining = ls({ type: 'mesh' }).filter((n) => /^Order/.test(n.name)).length;
console.log('after c.delete remaining Order* meshes:', remaining);

What you'll seeconsole: sibling order after each reorder + group children + post-unparent parent + post-delete count.

Open in editor →

Duplicate vs instance, recenter pivot, align axis, toggle visibility

Spawn a base cube, deep-clone it (independent geometry), make a sibling instance (shared geometry), recenter the pivot, align Y to the base, then hide / show / toggle / unlock.

Methods usedModelEditor.create.cube Utils.wait.frame ModelEditor.viewport.frameAll node.translate node.duplicate node.instance node.centerPivot node.align node.show node.hide node.toggleVisibility node.isHidden node.unlock

Example

// Compare duplicate (independent geometry) vs instance (shared geometry),
// recenter a pivot, align by axis, then cycle visibility + lock. All these
// Node ops are async. Self-contained from an empty Model scene.

const base = await create.cube({ width: 1, height: 1, depth: 1, name: 'BaseCube' });
base.xform({ t: [2.5, 1.3, -0.7] });
await select(null, { mode: 'clear' });
await Utils.wait.frame();

// DEEP CLONE — duplicate() makes an independent RawMesh; geometry edits to
// the clone do NOT propagate back to base. It rejects an 'offset' opt, so
// move it AFTER duplicating.
const dup = await base.duplicate({ name: 'BaseCube_clone' });
dup.xform({ t: [5.0, 1.3, -0.7] });
await select(null, { mode: 'clear' });

// SIBLING INSTANCE — instance() shares the SAME meshId as base; geometry
// edits to either propagate to both.
const inst = await base.instance();
inst.xform({ t: [7.5, 1.3, -0.7] });
await select(null, { mode: 'clear' });

// PIVOT — recenter base's pivot to its bounding-box center.
await base.centerPivot();

// ALIGN — snap dup's Y to base's Y. align takes a POSITIONAL array of
// targets plus { axis, mode }. With a single target, mode picks which edge
// to match: 'min' | 'center' | 'max'.
dup.align([base], { axis: 'y', mode: 'center' });

// VISIBILITY CYCLE — hide -> isHidden -> toggle -> show (each async).
await inst.hide();
console.log('inst hidden after hide():', inst.isHidden);          // true
await inst.toggleVisibility();
console.log('inst hidden after toggleVisibility():', inst.isHidden); // false
await inst.show();
console.log('inst hidden after show():', inst.isHidden);          // false

// LOCK — unlock is a no-op when the node is not locked.
await dup.unlock();
console.log('dup isLocked after unlock:', dup.isLocked); // false

await Utils.wait.frame();
viewport.frameAll();
console.log('duplicate / instance / pivot / align / visibility cycle complete.');

What you'll seeconsole: visibility flag at each transition + lock state; viewport: 3 cubes (base, deep-clone, instance) framed.

Open in editor →

Isolate, deisolate, showAll, and group selections

Spawn meshes; isolate a subset; deisolate; hide and reveal; create an empty group; spawn a hook profile.

Methods usedModelEditor.viewport.isolate ModelEditor.viewport.deisolate ModelEditor.viewport.showAll ModelEditor.create.group ModelEditor.create.hookProfile Utils.wait.frame ModelEditor.dev.snapSettings ModelEditor.dev.snapSettings.snapScale

Example

const cube = await create.cube({ name: 'IsoCube' });
cube.translate.set([2.5, 1.3, -0.7]);
select(null, {mode: 'clear'});

const sphere = await create.sphere({ name: 'IsoSphere' });
sphere.translate.set([5.0, 1.3, -0.7]);
select(null, {mode: 'clear'});

const hook = await create.hookProfile({ name: 'IsoHook' });
hook.translate.set([7.5, 1.3, -0.7]);
select(null, {mode: 'clear'});
await Utils.wait.frame();

viewport.isolate(cube);
console.log('isolated cube');
await Utils.wait.frame();

viewport.deisolate();
console.log('exited isolate mode');
await Utils.wait.frame();

viewport.showAll();
console.log('showAll fired');

// Resolve by name via the universal editor ls gateway.
const ref = ls('IsoCube')[0];
console.log('ls("IsoCube")[0] nodeId:', ref?.nodeId.slice(0, 8) ?? '(not found)');

const grp = create.group({ name: 'EmptyHolder' });
console.log('group:', grp.name);

// Snap settings facade
const before = dev.snapSettings.snapScale;
dev.snapSettings.snapScale = 0.25;
console.log('snapScale ' + before + ' → ' + dev.snapSettings.snapScale);

What you'll seeconsole: status after isolate / deisolate / showAll; group name; snapScale toggled.

Open in editor →

Collapse all and clear filter on the outliner

Set a filter; clear it; collapse all branches; spawn a few nodes to drive the outliner state.

Methods usedModelEditor.dev.outliner.collapseAll ModelEditor.dev.outliner.clearFilter ModelEditor.create.cube Utils.wait.frame node.translate

Example

const a = await create.cube({ name: 'OutlinerA' });
a.translate.set([2.5, 1.3, -0.7]); select(null, {mode: 'clear'});
const b = await create.cube({ name: 'OutlinerB' });
b.translate.set([5.0, 1.3, -0.7]); select(null, {mode: 'clear'});
const c = await create.cube({ name: 'OutlinerC' });
c.translate.set([7.5, 1.3, -0.7]); select(null, {mode: 'clear'});
await Utils.wait.frame();

dev.outliner.collapseAll();
console.log('collapseAll ok');

dev.outliner.clearFilter();
console.log('clearFilter ok');

What you'll seeconsole: outliner ops fired without throwing.

Open in editor →

Compound Forms

Engine Cylinder (compound form)

Vertical engine cylinder: central barrel + N stacked horizontal cooling fins + base flange with bolt circle + top cap + angled spark-plug boss with coaxial through-hole. Adapt the parameter constants at the top to fit your prompt.

Methods usedModelEditor.create.cylinder Transform.xform Mesh.boolean

Example

// Engine cylinder — adapt the constants below for your specific prompt.
const barrelDiameter = 36, barrelHeight = 70;
const finCount = 12, finOuterDiameter = 62, finThickness = 2;
const finBottomZ = 10, finSpacing = 5;
const flangeDiameter = 70, flangeThickness = 8;
const mountingBoltCount = 6, mountingBoltDiameter = 5, mountingBoltCircleDiameter = 56;
const capDiameter = 44, capHeight = 8;
const sparkPlugDiameter = 12, sparkPlugLength = 24, sparkPlugAngleDeg = 35;
const sparkPlugBoreDiameter = 5;

// 1. Barrel (vertical cylinder, base at Z=0).
const barrel = await create.cylinder({
  radiusTop: barrelDiameter / 2, radiusBottom: barrelDiameter / 2,
  height: barrelHeight, radialSegments: 48, name: 'engine-barrel',
});
barrel.xform({ t: [0, 0, barrelHeight / 2] });

// 2. Stacked cooling fins (horizontal disks along Z).
for (let i = 0; i < finCount; i++) {
  const z = finBottomZ + i * finSpacing;
  const fin = await create.cylinder({
    radiusTop: finOuterDiameter / 2, radiusBottom: finOuterDiameter / 2,
    height: finThickness, radialSegments: 48, name: `engine-fin-${i}`,
  });
  fin.xform({ t: [0, 0, z + finThickness / 2] });
  await barrel.boolean(fin, 'union');
}

// 3. Base flange with N bolt holes (manual radial placement).
const flange = await create.cylinder({
  radiusTop: flangeDiameter / 2, radiusBottom: flangeDiameter / 2,
  height: flangeThickness, radialSegments: 48, name: 'engine-flange',
});
flange.xform({ t: [0, 0, -flangeThickness / 2] });
for (let i = 0; i < mountingBoltCount; i++) {
  const theta = (i / mountingBoltCount) * Math.PI * 2;
  const bx = Math.cos(theta) * (mountingBoltCircleDiameter / 2);
  const by = Math.sin(theta) * (mountingBoltCircleDiameter / 2);
  const hole = await create.cylinder({
    radiusTop: mountingBoltDiameter / 2, radiusBottom: mountingBoltDiameter / 2,
    height: flangeThickness + 2, radialSegments: 24, name: `engine-flange-bolt-${i}`,
  });
  hole.xform({ t: [bx, by, -flangeThickness / 2] });
  await flange.boolean(hole, 'difference');
}
await barrel.boolean(flange, 'union');

// 4. Top cap.
const cap = await create.cylinder({
  radiusTop: capDiameter / 2, radiusBottom: capDiameter / 2,
  height: capHeight, radialSegments: 48, name: 'engine-cap',
});
cap.xform({ t: [0, 0, barrelHeight + capHeight / 2] });
await barrel.boolean(cap, 'union');

// 5. Spark-plug boss (angled cylinder + coaxial through-bore).
const angleY = 90 - sparkPlugAngleDeg;
const boss = await create.cylinder({
  radiusTop: sparkPlugDiameter / 2, radiusBottom: sparkPlugDiameter / 2,
  height: sparkPlugLength, radialSegments: 32, name: 'engine-spark-boss',
});
boss.xform({
  t: [capDiameter / 2, 0, barrelHeight + capHeight / 2],
  r: [0, angleY, 0],
});
await barrel.boolean(boss, 'union');

const bore = await create.cylinder({
  radiusTop: sparkPlugBoreDiameter / 2, radiusBottom: sparkPlugBoreDiameter / 2,
  height: sparkPlugLength + 2, radialSegments: 32, name: 'engine-spark-bore',
});
bore.xform({
  t: [capDiameter / 2, 0, barrelHeight + capHeight / 2],
  r: [0, angleY, 0],
});
await barrel.boolean(bore, 'difference');

console.log('engine cylinder:', barrel.name);

What you'll see12-fin vertical engine cylinder with a 35-degree spark-plug boss + coaxial through-hole. Z-extent reaches ~85mm.

Open in editor →

Centrifugal Impeller (compound form)

Backplate disk + central hub cylinder + axial through-bore + N radially-placed blades tilted backward. v1 uses rectangular blade slabs; true swept-curve blades land once a swept-curve primitive is available.

Methods usedModelEditor.create.cylinder ModelEditor.create.cube Transform.xform Mesh.boolean

Example

// Centrifugal impeller — adapt the constants below for your prompt.
const backplateDiameter = 80, backplateThickness = 4;
const hubDiameter = 24, hubHeight = 14;
const boreDiameter = 8;
const bladeCount = 12;
const bladeLength = 28, bladeHeight = 12, bladeThickness = 2;
const bladeBackTiltDeg = 45;

// 1. Backplate (base at Z=0).
const backplate = await create.cylinder({
  radiusTop: backplateDiameter / 2, radiusBottom: backplateDiameter / 2,
  height: backplateThickness, radialSegments: 48, name: 'impeller-backplate',
});
backplate.xform({ t: [0, 0, backplateThickness / 2] });

// 2. Hub on top of backplate.
const hub = await create.cylinder({
  radiusTop: hubDiameter / 2, radiusBottom: hubDiameter / 2,
  height: hubHeight, radialSegments: 32, name: 'impeller-hub',
});
hub.xform({ t: [0, 0, backplateThickness + hubHeight / 2] });
await backplate.boolean(hub, 'union');

// 3. Blades — rectangular slabs placed radially with backward tilt.
const bladeZ = backplateThickness + bladeHeight / 2;
const bladeCenterR = hubDiameter / 2 + bladeLength / 2;
for (let i = 0; i < bladeCount; i++) {
  const thetaDeg = (i / bladeCount) * 360;
  const thetaRad = (thetaDeg * Math.PI) / 180;
  const bx = Math.cos(thetaRad) * bladeCenterR;
  const by = Math.sin(thetaRad) * bladeCenterR;
  const blade = await create.cube({
    width: bladeLength, height: bladeThickness, depth: bladeHeight,
    name: `impeller-blade-${i}`,
  });
  blade.xform({
    t: [bx, by, bladeZ],
    r: [0, 0, thetaDeg + bladeBackTiltDeg],
  });
  await backplate.boolean(blade, 'union');
}

// 4. Axial through-bore.
const bore = await create.cylinder({
  radiusTop: boreDiameter / 2, radiusBottom: boreDiameter / 2,
  height: backplateThickness + hubHeight + 2, radialSegments: 24,
  name: 'impeller-bore',
});
bore.xform({ t: [0, 0, (backplateThickness + hubHeight) / 2] });
await backplate.boolean(bore, 'difference');

console.log('impeller:', backplate.name);

What you'll see12-blade impeller with 45-degree backward-tilted rectangular blade slabs + central hub + axial bore.

Open in editor →

Flange with Bolt Circle (compound form)

Flat circular flange: low cylinder + central through-bore + N bolt holes arranged on a circular pattern. Useful as a mounting plate or pipe-flange end cap.

Methods usedModelEditor.create.cylinder Transform.xform Mesh.boolean

Example

// Flange with bolt circle — adapt the constants below for your prompt.
const outerDiameter = 100, thickness = 10;
const centerBoreDiameter = 40;
const boltCount = 8, boltDiameter = 8, boltCircleDiameter = 80;

// 1. Flange disk.
const flange = await create.cylinder({
  radiusTop: outerDiameter / 2, radiusBottom: outerDiameter / 2,
  height: thickness, radialSegments: 48, name: 'flange-body',
});
flange.xform({ t: [0, 0, thickness / 2] });

// 2. Central through-bore.
const centerBore = await create.cylinder({
  radiusTop: centerBoreDiameter / 2, radiusBottom: centerBoreDiameter / 2,
  height: thickness + 2, radialSegments: 32, name: 'flange-center-bore',
});
centerBore.xform({ t: [0, 0, thickness / 2] });
await flange.boolean(centerBore, 'difference');

// 3. Bolt holes — manual radial placement (subtractive features = workflow B, not catalog).
for (let i = 0; i < boltCount; i++) {
  const theta = (i / boltCount) * Math.PI * 2;
  const bx = Math.cos(theta) * (boltCircleDiameter / 2);
  const by = Math.sin(theta) * (boltCircleDiameter / 2);
  const hole = await create.cylinder({
    radiusTop: boltDiameter / 2, radiusBottom: boltDiameter / 2,
    height: thickness + 2, radialSegments: 24, name: `flange-bolt-${i}`,
  });
  hole.xform({ t: [bx, by, thickness / 2] });
  await flange.boolean(hole, 'difference');
}

console.log('flange:', flange.name);

What you'll seeFlat disc 100mm OD + 40mm through-bore + 8 bolt holes on a 80mm circle.

Open in editor →

Ribbed Bracket (compound form)

L-shaped bracket with N stiffening gussets evenly distributed along the depth axis at the inner corner. v1 uses rectangular gussets; true triangular gussets land once a custom-profile extrude primitive is available.

Methods usedModelEditor.create.lShape ModelEditor.create.cube Transform.xform Mesh.boolean

Example

// Ribbed bracket — adapt the constants below for your prompt.
const armLength1 = 40, armLength2 = 30;
const thickness = 4, depth = 30;
const gussetCount = 3, gussetWidth = 14, gussetHeight = 14, gussetThickness = 3;

// 1. L-shaped bracket body.
const bracket = await create.lShape({
  armLength1, armLength2, thickness, depth, name: 'ribbed-bracket-body',
});

// 2. Gussets — rectangular slabs at the inner corner.
const denominator = gussetCount === 1 ? 2 : gussetCount + 1;
const innerX = thickness + gussetWidth / 2;
const innerY = thickness + gussetHeight / 2;
for (let i = 0; i < gussetCount; i++) {
  const t = (i + 1) / denominator;
  const dz = (t - 0.5) * depth;
  const gusset = await create.cube({
    width: gussetWidth, height: gussetHeight, depth: gussetThickness,
    name: `ribbed-bracket-gusset-${i}`,
  });
  gusset.xform({ t: [innerX, innerY, dz] });
  await bracket.boolean(gusset, 'union');
}

console.log('bracket:', bracket.name);

What you'll seeL-bracket (40mm + 30mm arms) with 3 rectangular gussets at the inner corner along the 30mm depth.

Open in editor →

Stepped Shaft with Keyway (compound form)

Stepped shaft: three coaxial cylinders of decreasing diameter (large, medium, small) along Z + a rectangular keyway groove cut into the large segment. Common power-transmission shaft form.

Methods usedModelEditor.create.cylinder ModelEditor.create.cube Transform.xform Mesh.boolean

Example

// Stepped shaft with keyway — adapt the constants below for your prompt.
const largeDiameter = 40, largeLength = 30;
const mediumDiameter = 28, mediumLength = 30;
const smallDiameter = 18, smallLength = 25;
const keywayWidth = 6, keywayDepth = 4, keywayLength = 20;

// 1. Large segment (base at Z=0).
const large = await create.cylinder({
  radiusTop: largeDiameter / 2, radiusBottom: largeDiameter / 2,
  height: largeLength, radialSegments: 48, name: 'shaft-large',
});
large.xform({ t: [0, 0, largeLength / 2] });

// 2. Medium segment stacked on top.
const medium = await create.cylinder({
  radiusTop: mediumDiameter / 2, radiusBottom: mediumDiameter / 2,
  height: mediumLength, radialSegments: 48, name: 'shaft-medium',
});
medium.xform({ t: [0, 0, largeLength + mediumLength / 2] });
await large.boolean(medium, 'union');

// 3. Small segment stacked on top of medium.
const small = await create.cylinder({
  radiusTop: smallDiameter / 2, radiusBottom: smallDiameter / 2,
  height: smallLength, radialSegments: 48, name: 'shaft-small',
});
small.xform({ t: [0, 0, largeLength + mediumLength + smallLength / 2] });
await large.boolean(small, 'union');

// 4. Keyway groove — rectangular slot subtracted from the large segment's side.
const groove = await create.cube({
  width: keywayDepth * 2, height: keywayWidth, depth: keywayLength,
  name: 'shaft-keyway-groove',
});
groove.xform({ t: [largeDiameter / 2, 0, largeLength - keywayLength / 2] });
await large.boolean(groove, 'difference');

console.log('shaft:', large.name);

What you'll see3-step shaft (40/28/18mm diameters stacked along Z) with a 6x4x20mm keyway groove in the large segment.

Open in editor →

Flanged Pipe Tee (compound form)

Flanged 3-way pipe tee: vertical pipe + horizontal pipe meeting at the origin + flange discs at each of the 3 open ends. The interior bore runs through both arms of the tee.

Methods usedModelEditor.create.cylinder Transform.xform Mesh.boolean

Example

// Flanged pipe tee — adapt the constants below for your prompt.
const pipeOuterDiameter = 30, pipeInnerDiameter = 22;
const verticalLength = 60, horizontalLength = 80;
const flangeDiameter = 50, flangeThickness = 6;

// 1. Vertical pipe.
const vertical = await create.cylinder({
  radiusTop: pipeOuterDiameter / 2, radiusBottom: pipeOuterDiameter / 2,
  height: verticalLength, radialSegments: 48, name: 'tee-vertical',
});
vertical.xform({ t: [0, 0, verticalLength / 2] });

// 2. Horizontal pipe — Y-rotated 90 degrees, centered at top of vertical.
const topZ = verticalLength;
const horizontal = await create.cylinder({
  radiusTop: pipeOuterDiameter / 2, radiusBottom: pipeOuterDiameter / 2,
  height: horizontalLength, radialSegments: 48, name: 'tee-horizontal',
});
horizontal.xform({ t: [0, 0, topZ], r: [0, 90, 0] });
await vertical.boolean(horizontal, 'union');

// 3. Three flange discs (bottom of vertical + both ends of horizontal).
const flangeBottom = await create.cylinder({
  radiusTop: flangeDiameter / 2, radiusBottom: flangeDiameter / 2,
  height: flangeThickness, radialSegments: 48, name: 'tee-flange-bottom',
});
flangeBottom.xform({ t: [0, 0, flangeThickness / 2] });
await vertical.boolean(flangeBottom, 'union');

const flangePosX = await create.cylinder({
  radiusTop: flangeDiameter / 2, radiusBottom: flangeDiameter / 2,
  height: flangeThickness, radialSegments: 48, name: 'tee-flange-posx',
});
flangePosX.xform({ t: [horizontalLength / 2 - flangeThickness / 2, 0, topZ], r: [0, 90, 0] });
await vertical.boolean(flangePosX, 'union');

const flangeNegX = await create.cylinder({
  radiusTop: flangeDiameter / 2, radiusBottom: flangeDiameter / 2,
  height: flangeThickness, radialSegments: 48, name: 'tee-flange-negx',
});
flangeNegX.xform({ t: [-horizontalLength / 2 + flangeThickness / 2, 0, topZ], r: [0, 90, 0] });
await vertical.boolean(flangeNegX, 'union');

// 4. Bore the interiors.
const innerVertical = await create.cylinder({
  radiusTop: pipeInnerDiameter / 2, radiusBottom: pipeInnerDiameter / 2,
  height: verticalLength + 2, radialSegments: 32, name: 'tee-vertical-bore',
});
innerVertical.xform({ t: [0, 0, verticalLength / 2] });
await vertical.boolean(innerVertical, 'difference');

const innerHorizontal = await create.cylinder({
  radiusTop: pipeInnerDiameter / 2, radiusBottom: pipeInnerDiameter / 2,
  height: horizontalLength + 2, radialSegments: 32, name: 'tee-horizontal-bore',
});
innerHorizontal.xform({ t: [0, 0, topZ], r: [0, 90, 0] });
await vertical.boolean(innerHorizontal, 'difference');

console.log('pipe tee:', vertical.name);

What you'll see3-way pipe tee with 30mm OD / 22mm ID + 50mm flange discs at all 3 open ends.

Open in editor →

Other

Catch + classify every error class in the scripting API

Every scripting-API error carries a stable .name + frozen .code + class-specific fields. Pattern-match on .name to dispatch; read class-specific properties for context.

Methods usedModelEditor.scene.ls ModelEditor.create.cube ModelEditor.create.group Utils.wait.until node.attr node.addAttr attribute.get attribute.set attribute.lock transform.freezeTransform attributeLockedError.code attributeLockedError.operation attributeLockedError.nodeId attributeLockedError.attrPath attributeNotFoundError.nodeId attributeNotFoundError.path deformerStaleError.code deformerStaleError.meshId deformerStaleError.deformerId deformerStaleError.deformerType editorChangedDuringSessionError.code editorChangedDuringSessionError.toolId editorChangedDuringSessionError.meshId editorChangedDuringSessionError.from editorChangedDuringSessionError.to historyNotInitializedError.code importFailedError.code importFailedError.filename importFailedError.format importFailedError.underlying interactiveSessionStaleError.code interactiveSessionStaleError.toolId interactiveSessionStaleError.meshId interactiveSessionStaleError.previousState invalidArgumentError.argName nodeNotFoundError.nodeId nodeStaleError.nodeId nodeStaleError.name operationBlockedByDialogError.code operationBlockedByDialogError.operation operationBlockedByDialogError.dialogId operationCancelledError.code operationCancelledError.reason operationNotApplicableError.operation operationNotApplicableError.reason operationNotInEditorError.operation operationNotInEditorError.currentEditor operationNotInEditorError.allowedEditors operationNotSupportedError.operation permissionDeniedError.code permissionDeniedError.resource permissionDeniedError.handle persistedHandleStaleError.code persistedHandleStaleError.persistKey persistedHandleStaleError.lastSeenName waitTimeoutError.code writeFailedError.code writeFailedError.fileName writeFailedError.reason

Example

// Every scripting-API error is a real CLASS on Utils.errors, carries a
// stable .name + frozen .code, and exposes class-specific fields. Use an
// instanceof ladder to dispatch; read the typed fields for context.
const E = Utils.errors;

function describe(err) {
  const head = { name: err.name, code: err.code };
  // Order matters only insofar as each branch reads its own typed fields.
  if (err instanceof E.NodeNotFoundError) return { ...head, nodeId: err.nodeId };
  if (err instanceof E.NodeStaleError) return { ...head, nodeId: err.nodeId, lastKnownName: err.lastKnownName };
  if (err instanceof E.AttributeNotFoundError) return { ...head, nodeId: err.nodeId, path: err.path };
  if (err instanceof E.AttributeLockedError) return { ...head, operation: err.operation, nodeId: err.nodeId, attrPath: err.attrPath };
  if (err instanceof E.InvalidArgumentError) return { ...head, argName: err.argName };
  if (err instanceof E.OperationNotApplicableError) return { ...head, operation: err.operation, reason: err.reason };
  if (err instanceof E.OperationNotInEditorError) return { ...head, operation: err.operation, currentEditor: err.currentEditor, allowedEditors: err.allowedEditors };
  if (err instanceof E.OperationNotSupportedError) return { ...head, operation: err.operation };
  if (err instanceof E.OperationBlockedByDialogError) return { ...head, operation: err.operation, dialogId: err.dialogId };
  if (err instanceof E.OperationCancelledError) return { ...head, reason: err.reason };
  if (err instanceof E.DeformerStaleError) return { ...head, meshId: err.meshId, deformerId: err.deformerId, deformerType: err.deformerType };
  if (err instanceof E.WaitTimeoutError) return head;
  if (err instanceof E.ImportFailedError) return { ...head, filename: err.filename, format: err.format };
  if (err instanceof E.WriteFailedError) return { ...head, fileName: err.fileName, reason: err.reason };
  return { ...head, message: err.message }; // catch-all for any other class
}

// Self-contained from an empty Model scene: provoke six REAL catches.
const cube = await create.cube({ width: 1, height: 1, depth: 1, name: 'ErrIntro' });
select(null, { mode: 'clear' });

// 1. NodeNotFoundError — snap to a name that does not exist.
try { cube.snapTo('missing-' + Date.now()); } catch (e) { console.log('1.', JSON.stringify(describe(e))); }
// 2. AttributeNotFoundError — read an attribute that was never added.
try { cube.attr('bogus').get(); } catch (e) { console.log('2.', JSON.stringify(describe(e))); }
// 3. InvalidArgumentError — write past an ENFORCED limit.
cube.addAttr({ ln: 'wet', at: 'float', dv: 0.5, k: true, min: 0, max: 1 });
cube.attr('wet').enableLimits(true);
try { cube.attr('wet').set(2); } catch (e) { console.log('3.', JSON.stringify(describe(e))); }
// 4. AttributeLockedError — write to a locked channel. node.translate.x is the
//    per-AXIS handle (Vec3AxisAttribute: .lock / .get / .set) — NOT
//    node.attr('translate.x') (the dotted path is not a DG plug and throws
//    AttributeNotFoundError). Locking the axis makes the next .set() throw.
cube.translate.x.lock(true);
try { cube.translate.x.set(5); } catch (e) { console.log('4.', JSON.stringify(describe(e))); }
cube.translate.x.lock(false);
// 5. Some operation error — freezing a group's transform may be unsupported.
const grp = await create.group([cube], { name: 'ErrGrp' });
try { grp.freezeTransform(); } catch (e) { console.log('5.', JSON.stringify(describe(e))); }
// 6. WaitTimeoutError — a predicate that never becomes true.
try { await Utils.wait.until(() => false, { timeoutMs: 80 }); } catch (e) { console.log('6.', JSON.stringify(describe(e))); }

What you'll seeconsole: six real catches with class-typed field readout.

Open in editor →

Browse, search, and run any registered Action

List every Action; search by keyword; inspect the descriptor (name / category / script snippet); check applicability; invoke by id.

Methods usedModelEditor.actions.list ModelEditor.actions.get ModelEditor.actions.search ModelEditor.actions.run

Example

const all = actions.list();
console.log('total actions:', all.length);

// Filter to only the Actions applicable in the current editor context.
const applicable = actions.list({ applicableOnly: true });
console.log('applicable right now:', applicable.length);

const hits = actions.search('select', { applicableOnly: false });
console.log('search "select" first 3:', JSON.stringify(hits.slice(0, 3).map(h => h.id)));

const target = hits[0]?.id ?? all[0]?.id;
if (target) {
  // get() returns the full descriptor: id / name / category / scriptSnippet.
  const info = actions.get(target);
  console.log('get(' + target + '):', JSON.stringify({ name: info?.name, category: info?.category }));

  const snippet = info?.scriptSnippet;
  console.log('snippet:', snippet ? snippet.slice(0, 60) + '...' : '(none)');

  // Applicability = membership in the applicable-only list.
  const ok = applicable.some((a) => a.id === target);
  console.log('isApplicable:', ok);

  if (ok) {
    try {
      await actions.run(target);
      console.log('ran', target, 'successfully');
    } catch (err) {
      console.log('run threw:', err.message);
    }
  }
}

What you'll seeconsole: total action count, first matches for "select", the descriptor + snippet for one action, applicability check, run result.

Open in editor →

Sleep with Utils.wait.ms and poll with Utils.wait.until

Demonstrate the two non-frame wait helpers: fixed-delay sleep and predicate poll.

Methods usedUtils.wait.ms Utils.wait.until Utils.wait.frame

Example

const t0 = performance.now();

await Utils.wait.ms(50);
const t1 = performance.now();
console.log('after ms(50): elapsed=' + (t1 - t0).toFixed(1) + 'ms');

let counter = 0;
const timer = setInterval(() => { counter++; }, 10);

try {
  await Utils.wait.until(() => counter >= 3, { timeoutMs: 1000, intervalMs: 20 });
  console.log('until() resolved at counter=' + counter);
} catch (err) {
  console.log('until() timed out:', err.message);
} finally {
  clearInterval(timer);
}

await Utils.wait.frame();
console.log('frame() returned');

What you'll seeconsole: timestamps before and after each wait; predicate-driven loop completes.

Open in editor →

Vec2 toolkit: build, blend, measure, normalize

2D vector handle walk-through: factories, axis getters, length, lerp, distance, dot, normalize.

Methods usedvec2.from vec2.zero vec2.one vec2.x vec2.y vec2.clone vec2.toArray vec2.add vec2.sub vec2.scale vec2.negate vec2.lerp vec2.normalize vec2.length vec2.lengthSq vec2.dot vec2.distanceTo vec2.distanceSqTo vec2.equals

Example

// Vec2 OO handle. Every math method returns a NEW Vec2 (immutable).
const a = MathLib.Vec2.from([3, 4]);
const b = MathLib.Vec2.from([0, 0]);
const ones = MathLib.Vec2.one();
const zero = MathLib.Vec2.zero();
console.log('a (x,y):', a.x, a.y, '| length:', a.length(), '| lengthSq:', a.lengthSq());
console.log('ones:', ones.toArray(), '| zero:', zero.toArray());

const sum = a.add(ones);
const diff = a.sub(zero);
const scaled = a.scale(2);
const neg = a.negate();
const mid = a.lerp(b, 0.5);
const nrm = a.normalize();
console.log('sum:', sum.toArray(), '| diff:', diff.toArray(), '| scaled:', scaled.toArray());
console.log('neg:', neg.toArray(), '| lerp(a, b, .5):', mid.toArray());
console.log('normalize(a).length() ~', nrm.length().toFixed(4));

console.log('dot(a, a):', a.dot(a));
console.log('distanceTo(b):', a.distanceTo(b), '| distanceSqTo(b):', a.distanceSqTo(b));
console.log('a == a.clone()?', a.equals(a.clone()), '| a == b?', a.equals(b));

What you'll seeconsole: axis getters, length, sum/diff/scale tuples, lerp midpoint, normalize length ~1, dot/distance.

Open in editor →

Vec3 toolkit: factories, cross, rotate, transform

3D vector walk-through: basis vectors, cross product, distance, normalize, and cross-type transforms (Quat / Mat3 / Mat4 / direction).

Example

// Vec3 OO handle. Immutable: every math method returns a NEW Vec3.
const a = MathLib.Vec3.from([1, 2, 3]);
const b = MathLib.Vec3.from([4, 5, 6]);
const ones = MathLib.Vec3.one();
const zero = MathLib.Vec3.zero();
const ex = MathLib.Vec3.unitX();
const ey = MathLib.Vec3.unitY();
const ez = MathLib.Vec3.unitZ();
console.log('a (x,y,z):', a.x, a.y, a.z);
console.log('ones:', ones.toArray(), '| zero:', zero.toArray());
console.log('basis:', ex.toArray(), ey.toArray(), ez.toArray());

const sum = a.add(b);
const diff = a.sub(b);
const cross = ex.cross(ey);
const scaled = a.scale(0.5);
const neg = a.negate();
const mid = a.lerp(b, 0.5);
const nrm = MathLib.Vec3.from([3, 0, 4]).normalize();
console.log('sum:', sum.toArray(), '| diff:', diff.toArray(), '| cross(ex, ey):', cross.toArray());
console.log('scaled:', scaled.toArray(), '| neg:', neg.toArray(), '| lerp(a, b, .5):', mid.toArray());
console.log('length:', a.length(), '| lengthSq:', a.lengthSq(), '| dot(a, b):', a.dot(b));
console.log('normalize([3,0,4]):', nrm.toArray(), '| distanceTo:', a.distanceTo(b), '| distanceSqTo:', a.distanceSqTo(b));
console.log('a == a.clone()?', a.equals(a.clone()));

// Cross-type transforms -- rotate ex by 90 deg around Z via three forms + a normalize-direction.
const rotZ = MathLib.Quat.fromAxisAngle([0, 0, 1], Math.PI / 2);
const mat3Z = MathLib.Mat3.fromQuat(rotZ);
const mat4Z = MathLib.Mat4.fromQuat(rotZ);
console.log('applyQuat(ex):', ex.applyQuat(rotZ).toArray());
console.log('applyMat3(ex):', ex.applyMat3(mat3Z).toArray());
console.log('applyMat4(ex):', ex.applyMat4(mat4Z).toArray());
console.log('transformDirection(ex):', ex.transformDirection(mat4Z).toArray());

What you'll seeconsole: axis getters, basis tuples, cross/dot/distance, then four transform variants on the X axis.

Open in editor →

Vec4 toolkit: homogeneous transform, blend, normalize

4D vector walk-through with the w-component driving homogeneous semantics: w=1 transforms as a point, w=0 as a direction.

Example

// Vec4 OO handle. Immutable -- every math method returns a NEW Vec4.
const a = MathLib.Vec4.from([1, 2, 3, 1]);
const b = MathLib.Vec4.from([0, 0, 0, 0]);
const ones = MathLib.Vec4.one();
const zero = MathLib.Vec4.zero();
console.log('a (x,y,z,w):', a.x, a.y, a.z, a.w);
console.log('ones:', ones.toArray(), '| zero:', zero.toArray());

const sum = a.add(ones);
const diff = a.sub(b);
const scaled = a.scale(2);
const neg = a.negate();
const mid = a.lerp(b, 0.5);
const nrm = a.normalize();
console.log('sum:', sum.toArray(), '| diff:', diff.toArray(), '| scaled:', scaled.toArray());
console.log('neg:', neg.toArray(), '| lerp(a, b, .5):', mid.toArray());
console.log('normalize(a).length() ~', nrm.length().toFixed(4));
console.log('lengthSq:', a.lengthSq(), '| dot(a, a):', a.dot(a));
console.log('a == a.clone()?', a.equals(a.clone()));

// Homogeneous transform -- w drives translation.
const translateBy = MathLib.Mat4.fromTranslation([10, 20, 30]);
const asPoint = MathLib.Vec4.from([1, 2, 3, 1]).applyMat4(translateBy);
const asDirection = MathLib.Vec4.from([1, 2, 3, 0]).applyMat4(translateBy);
console.log('point  (w=1):', asPoint.toArray());
console.log('direction (w=0):', asDirection.toArray());

What you'll seeconsole: axis getters, math results, then point vs direction transform contrast (translate applies only when w=1).

Open in editor →

Quat toolkit: axis-angle, slerp, compose, rotate, convert

Quaternion walk-through: every factory, every blend (multiply / slerp / lerp), and conversion to Mat4 / Euler.

Example

// Quat OO handle. Tuple order is [x, y, z, w] (w last, glTF / three.js convention).
const id = MathLib.Quat.identity();
const a = MathLib.Quat.from([0, 0, 0, 1]);
console.log('identity (x,y,z,w):', id.x, id.y, id.z, id.w, '| length:', id.length());
console.log('from([0,0,0,1]) == identity?', a.equals(id));

// Factories -- pick your rotation source.
const aroundZ = MathLib.Quat.fromAxisAngle([0, 0, 1], Math.PI / 2);
const fromEul = MathLib.Quat.fromEuler(0, Math.PI / 2, 0, 'XYZ');
const fromM3 = MathLib.Quat.fromMat3(MathLib.Mat3.fromQuat(aroundZ));
const lookFwd = MathLib.Quat.lookRotation([0, 0, -1], [0, 1, 0]);
const xToY = MathLib.Quat.setFromUnitVectors([1, 0, 0], [0, 1, 0]);
console.log('fromAxisAngle(z, 90 deg):', aroundZ.toArray());
console.log('fromEuler:', fromEul.toArray(), '| fromMat3:', fromM3.toArray());
console.log('lookRotation(-z):', lookFwd.toArray(), '| setFromUnitVectors(x->y):', xToY.toArray());

// Composition + blends.
const composed = aroundZ.multiply(aroundZ);
const slerped = MathLib.Quat.slerp(id, aroundZ, 0.5);
const lerped = id.lerp(aroundZ, 0.5);
const inv = aroundZ.inverse();
const conj = aroundZ.conjugate();
const nrm = aroundZ.normalize();
console.log('q*q:', composed.toArray(), '| inverse:', inv.toArray(), '| conjugate:', conj.toArray());
console.log('slerp(id, q, .5):', slerped.toArray(), '| lerp(id, q, .5):', lerped.toArray());
console.log('normalize(q):', nrm.toArray());

// Cross-type: rotate a Vec3, convert to matrix/euler.
console.log('rotate([1,0,0]):', aroundZ.rotate([1, 0, 0]).toArray());
console.log('toMatrix row 0:', aroundZ.toMatrix().toArray().slice(0, 4));
console.log('toEuler:', aroundZ.toEuler('XYZ').toArray());
console.log('angleTo(id):', aroundZ.angleTo(id).toFixed(4));
console.log('dot(q, q):', aroundZ.dot(aroundZ).toFixed(4));
console.log('q == q.clone()?', aroundZ.equals(aroundZ.clone()));

What you'll seeconsole: factory outputs, composed rotations, slerp/lerp midpoints, then rotate(Vec3) and Mat4/Euler conversions.

Open in editor →

Mat3 toolkit: identity, fromQuat, normal matrix, invert

3x3 matrix walk-through: column-major factories, multiply / invert / transpose, normal matrix from a non-uniform-scale 4x4, and Vec3 transform.

Methods usedmat3.identity mat3.from mat3.fromQuat mat3.fromMat4 mat3.normalMatrix mat3.clone mat3.toArray mat3.multiply mat3.invert mat3.transpose mat3.determinant mat3.equals mat3.transformVec3

Example

// Mat3 -- column-major 3x3.
const id = MathLib.Mat3.identity();
console.log('identity[0..3]:', id.toArray().slice(0, 3), '| det:', id.determinant());

// Build from quat / from Mat4 / from raw 9-element array.
const q = MathLib.Quat.fromAxisAngle([0, 1, 0], Math.PI / 2);
const rotMat3 = MathLib.Mat3.fromQuat(q);
const rotMat4 = MathLib.Mat4.fromQuat(q);
const fromM4 = MathLib.Mat3.fromMat4(rotMat4);
const fromRaw = MathLib.Mat3.from([1, 0, 0, 0, 1, 0, 0, 0, 1]);
console.log('fromQuat row 0:', rotMat3.toArray().slice(0, 3));
console.log('fromMat4 row 0:', fromM4.toArray().slice(0, 3));
console.log('from(raw9) det:', fromRaw.determinant());

// Composition + utilities.
const prod = rotMat3.multiply(rotMat3);
const inv = rotMat3.inverse();
const tps = rotMat3.transpose();
const cln = rotMat3.clone();
console.log('R*R row 0:', prod.toArray().slice(0, 3));
console.log('R^-1 row 0:', inv.toArray().slice(0, 3));
console.log('R^T row 0:', tps.toArray().slice(0, 3));
console.log('clone == orig?', rotMat3.equals(cln));

// Normal matrix -- inverse-transpose 3x3 of a non-uniform-scale 4x4.
const skew4 = MathLib.Mat4.fromTRS([0, 0, 0], q.toArray(), [2, 1, 1]);
const nm = MathLib.Mat3.normalMatrix(skew4);
console.log('normalMatrix row 0:', nm.toArray().slice(0, 3));

// Apply to a vector.
console.log('Mat3.transformVec3(ex):', rotMat3.transformVec3([1, 0, 0]).toArray());

What you'll seeconsole: identity diag, R*R / R^-1 / R^T rows, normal matrix from a (2,1,1)-scale, and transformVec3 result.

Open in editor →

Mat4 toolkit: TRS, lookAt, perspective, decompose, transform

4x4 matrix walk-through: every specialized factory, view + projection, decompose round-trip, and the four cross-type transform variants.

Example

// Mat4 -- column-major 4x4. Translation lives at indices 12, 13, 14.
const id = MathLib.Mat4.identity();
console.log('identity translation slot:', id.toArray().slice(12, 15), '| det:', id.determinant());

// Specialized factories.
const t = MathLib.Mat4.fromTranslation([10, 20, 30]);
const r = MathLib.Mat4.fromRotation(MathLib.Quat.fromAxisAngle([0, 1, 0], Math.PI / 2));
const s = MathLib.Mat4.fromScale([2, 2, 2]);
const fq = MathLib.Mat4.fromQuat(MathLib.Quat.identity());
const trs = MathLib.Mat4.fromTRS([1, 2, 3], MathLib.Quat.identity().toArray(), [2, 2, 2]);
const raw = MathLib.Mat4.from(id.toArray());
const sArr = s.toArray();
console.log('fromTranslation translation:', t.toArray().slice(12, 15));
console.log('fromRotation det:', r.determinant().toFixed(4));
console.log('fromScale diag:', sArr[0], sArr[5], sArr[10]);
console.log('fromQuat(id) det:', fq.determinant().toFixed(4));
console.log('fromTRS translation:', trs.toArray().slice(12, 15));
console.log('from(raw16) det:', raw.determinant());

// View + projection.
const view = MathLib.Mat4.lookAt([5, 5, 5], [0, 0, 0], [0, 1, 0]);
const persp = MathLib.Mat4.perspective(Math.PI / 4, 16 / 9, 0.1, 1000);
const orth = MathLib.Mat4.ortho(-10, 10, -10, 10, 0.1, 1000);
const pArr = persp.toArray();
const oArr = orth.toArray();
console.log('lookAt translation:', view.toArray().slice(12, 15));
console.log('perspective diag:', pArr[0].toFixed(3), pArr[5].toFixed(3));
console.log('ortho diag:', oArr[0].toFixed(3), oArr[5].toFixed(3));

// Math + composition.
const m = r.multiply(t);
const inv = m.inverse();
const tps = m.transpose();
const cln = m.clone();
console.log('R*T det:', m.determinant().toFixed(4), '| inv det:', inv.determinant().toFixed(4));
console.log('transpose row 0:', tps.toArray().slice(0, 4));
console.log('clone == orig?', m.equals(cln));

// Decompose round-trip.
const { translation, rotation, scale } = trs.decompose();
console.log('decompose:', translation.toArray(), rotation.toArray(), scale.toArray());

// Cross-type transforms.
console.log('transformPoint:', m.transformPoint([1, 0, 0]).toArray());
console.log('transformVector:', m.transformVector([1, 0, 0]).toArray());
console.log('transformDirection:', m.transformDirection([1, 0, 0]).toArray());
console.log('transformVec4:', m.transformVec4([1, 0, 0, 1]).toArray());

What you'll seeconsole: translation slot, projection diagonals, decompose triple, then point vs vector vs direction vs vec4 transforms.

Open in editor →

Euler toolkit: fromQuat, reorder, round-trip to Mat4 and Quat

Euler angle walk-through: convert from Quat / Mat4, change rotation order, and round-trip back to Quat / Mat4.

Methods usedeuler.fromQuat euler.fromMat4 euler.x euler.y euler.z euler.order euler.clone euler.toArray euler.reorder euler.toQuat euler.toMat4 euler.equals

Example

// Build a 90 deg rotation around Z and inspect it as Euler angles.
const q = MathLib.Quat.fromAxisAngle([0, 0, 1], Math.PI / 2);
const m = MathLib.Mat4.fromQuat(q);

const eXYZ = MathLib.Euler.fromQuat(q, 'XYZ');
const eYZX = eXYZ.reorder('YZX');
const fromM = MathLib.Euler.fromMat4(m, 'XYZ');
console.log('fromQuat (XYZ):', eXYZ.x.toFixed(3), eXYZ.y.toFixed(3), eXYZ.z.toFixed(3), eXYZ.order);
console.log('reorder (YZX):', eYZX.x.toFixed(3), eYZX.y.toFixed(3), eYZX.z.toFixed(3), eYZX.order);
console.log('fromMat4 (XYZ):', fromM.x.toFixed(3), fromM.y.toFixed(3), fromM.z.toFixed(3), fromM.order);

// Round-trip back to Quat / Mat4.
console.log('toQuat:', eXYZ.toQuat().toArray());
console.log('toMat4 row 0:', eXYZ.toMat4().toArray().slice(0, 4));

// Conversion + equality.
console.log('toArray:', eXYZ.toArray());
console.log('clone == orig?', eXYZ.equals(eXYZ.clone()));
console.log('XYZ == YZX (different orders)?', eXYZ.equals(eYZX));

What you'll seeconsole: XYZ Euler from a 90 deg Z rotation, reorder to YZX, fromMat4 result, and round-trip back to Quat / Mat4.

Open in editor →

Install an off-the-shelf M5 bolt

Drop an M5 hex-cap bolt into the scene from the bundled catalog (12,718 STEP parts). Use this pattern for ANY standard hardware: bolts, bearings, nuts, washers, standoffs, motors. The catalog is workflow A in DOCTRINE: try the catalog FIRST before composing geometry from primitives.

Methods usedModelEditor.catalog.search ModelEditor.catalog.install

Example

// Workflow A: try the bundled catalog FIRST before composing geometry.
// Self-contained from an empty Model scene.

// 1. Search the catalog by customer keyword. search() is SYNCHRONOUS and
//    returns CatalogPart[] ({ id, name, license, tags, ... }) ranked by
//    relevance (name matches beat tag matches). Empty query -> [].
const hits = catalog.search('M5 bolt');
console.log('found ' + hits.length + ' M5-bolt candidates: ' +
  hits.slice(0, 3).map((h) => h.name + ' [' + h.license + ']').join(', '));

if (hits.length === 0) {
  console.log('Catalog has no M5 bolt registered in this build - nothing to install.');
} else {
  // 2. Install the top hit. install(id, opts?) is ASYNC -> await. The only
  //    option is position (world-space meters); default is [2.5, 1.3, -0.7]
  //    so consecutive installs do not stack invisibly on the origin.
  const bolt = await catalog.install(hits[0].id, {
    position: [10, 0, 0],   // place this bolt 10 m down +X
  });
  console.log('installed "' + bolt.name + '" with ' + bolt.faces.count + ' faces');
}

// NOTE: the catalog is for ADDITIVE parts. To DRILL a hole for an M5 bolt
// (subtractive feature), use workflow B: mesh.boolean(other, 'difference')
// with a 5 mm-diameter cylinder. See the compound-engine-cylinder gallery
// entry for an example of N bolt holes drilled on a flange.

What you'll seeM5 hex-cap bolt installed at [10, 0, 0]; the catalog covers ~12K parts under CC0 / CC-BY / MIT / Apache-2.0 licenses.

Open in editor →