Stats
Actions
Tags
From spirograph
Interpretive guidance for generating OpenSCAD code for Gridfinity desktop/drawer organizers. Provides pattern selection frameworks, dimensional constraints, and stacking system integration specific to the Gridfinity ecosystem. Use when generating OpenSCAD files for Gridfinity bins, baseplates, or accessories.
How this skill is triggered — by the user, by Claude, or both
Slash command
/spirograph:gridfinity-openscadThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
Generates OpenSCAD code for desktop and drawer storage items compatible with Gridfinity (42mm grid, 7mm height units).
Generates OpenSCAD code for desktop and drawer storage items compatible with Gridfinity (42mm grid, 7mm height units).
Official specifications:
Pattern references (read as needed):
Grid constraint: All bins align to 42mm × 42mm grid. This affects:
Baseplate socket system: Bins don't sit flat on surface. They:
Stacking system: Bins can stack on top of each other:
Critical parameter relationships:
// Core Gridfinity dimensions (NEVER change these)
grid_size = 42; // Base grid unit
bin_size = 41.5; // Actual bin dimension (0.5mm tolerance)
height_unit = 7; // Vertical unit
corner_radius = 3.75; // Filleted corners
stacking_lip = 4.4; // Optional lip height
// User parameters
grid_x = 2; // Grid units wide (2 = 84mm)
grid_y = 3; // Grid units deep (3 = 126mm)
height_u = 4; // Height units (4u = 28mm)
// Calculated dimensions
bin_width = bin_size * grid_x; // 83mm (not 84mm!)
bin_depth = bin_size * grid_y; // 124.5mm (not 126mm!)
bin_height = height_unit * height_u; // 28mm
Why this matters: User requests "2×3×4 bin" but must understand that means 83mm × 124.5mm × 28mm actual size, not 84mm × 126mm × 28mm.
Gridfinity and OpenGrid share 84mm alignment:
Design implication: When creating combo systems, use 84mm as common denominator for alignment across both standards.
Use this decision tree to select pattern:
| User wants to store | Primary pattern | Alternative | Read module |
|---|---|---|---|
| Generic desktop organization | Basic Bin | Divided Bin (if categories) | basic_bin.md |
| Sorted small parts (resistors, screws) | Divider Bin | Multiple basic bins | divider_bin.md |
| Maximum drawer space efficiency | Basic Bin (exact drawer dimensions) | Lite Bin (vase mode) | basic_bin.md, lite_bin.md |
| Rapid printing / minimal filament | Lite Bin | Basic Bin (if strength needed) | lite_bin.md |
| Custom baseplate for drawer/desk | Baseplate | N/A | baseplate.md |
Ask these questions:
Default: When unclear, use Basic Bin - most versatile, user can refine.
Always declare these parameters at top of file:
// Grid dimensions (what user specifies)
grid_x = 2; // Grid units wide (1 unit = 42mm)
grid_y = 3; // Grid units deep
height_u = 4; // Height units (1u = 7mm)
// Gridfinity constants (NEVER change)
grid_size = 42; // Standard grid spacing
bin_size = 41.5; // Actual bin size (0.5mm tolerance)
height_unit = 7; // Height increment
corner_radius = 3.75; // Fillet radius
// Structural parameters (print quality)
wall_thickness = 2.0; // 1.6-2.4mm typical for bins
base_thickness = 2.0; // First layer above base profile
// Optional features
include_stacking_lip = true; // Add 4.4mm lip for stacking
include_magnets = false; // Add magnet holes (6mm × 2mm)
include_label = false; // Add label recess
Why this order: User dimensions first (grid units), then ecosystem constants, then structural parameters, then optional features.
Every bin needs proper base profile. Standard integration:
module gridfinity_base_profile() {
// Z-shaped profile that locks into baseplate
// See ./common_items/basic_bin.md for complete module
// First ~5mm of bin height is dedicated to base
}
union() {
// Base profile (required)
gridfinity_base_profile();
// Bin body above base
translate([0, 0, 5]) // Start above base profile
bin_body();
// Optional stacking lip at top
if (include_stacking_lip) {
translate([0, 0, bin_height])
stacking_lip();
}
}
Common mistake: Ignoring base profile and creating flat-bottom bin. Won't lock into baseplate.
When user says "I need a bin for X":
Estimate grid dimensions for their items:
Calculate actual bin dimensions:
actual_width = bin_size * grid_x; // 41.5mm per unit
actual_depth = bin_size * grid_y;
actual_height = height_unit * height_u;
Calculate usable interior:
interior_width = actual_width - wall_thickness*2;
interior_depth = actual_depth - wall_thickness*2;
interior_height = actual_height - base_thickness; // Minus base profile
// First height unit loses ~5mm to base profile
// So 4u (28mm) bin has ~23mm usable height
Inform user of actual dimensions:
Critical understanding: First height unit is partially consumed by base profile.
// Height budget for 1u (7mm) bin:
// - ~5mm: Base profile (socket engagement)
// - ~2mm: Usable interior height
// Result: 1u bins are VERY shallow, rarely practical
// Recommended minimum: 3u (21mm)
// - ~5mm: Base profile
// - ~2mm: Base thickness above profile
// - ~14mm: Usable interior
// Result: Enough space for most small items
Guidance: Suggest minimum 3u for functional bins, unless user specifically needs shallow compartments.
Read the module file, don't reinvent. Each pattern has complete module in ./common_items/:
// DON'T write basic_bin() from scratch
// DO read ./common_items/basic_bin.md and use/adapt the module
// Option 1: Include external file
include <modules/gridfinity_modules.scad>
basic_bin(grid_x=2, grid_y=3, height_u=4);
// Option 2: Paste module directly (user preference)
[paste module from basic_bin.md]
basic_bin(grid_x=2, grid_y=3, height_u=4);
When to adapt vs use as-is:
Only add features if:
Available features:
// Four corners of each grid unit
translate([corner_offset, corner_offset, -0.1])
cylinder(d=6, h=2.1, $fn=30);
Placement: At corners of each 42mm grid square, 8mm from edges.
// At top of bin, mirrors base profile inverted
translate([0, 0, bin_height])
stacking_lip(); // See basic_bin.md for module
Critical: Lip must match base profile geometry for proper stacking.
// Front face, typically 45° overhang (no supports)
translate([bin_width/2, 0, bin_height - 8])
rotate([45, 0, 0])
cube([bin_width*0.6, 10, 10], center=true);
Design consideration: Also serves as finger grip for lifting bin.
// M3 screw holes at corners
translate([corner_offset, corner_offset, -0.1])
cylinder(d=3.2, h=base_thickness+0.2, $fn=20);
Use case: Non-magnetic surfaces or extra-strong anchoring.
Problem: User requests "2×2 bin", code uses 84mm × 84mm dimensions, bin doesn't fit baseplate socket.
Why it fails: Grid spacing is 42mm, but bin size must be 41.5mm to allow 0.5mm tolerance for fit.
Better approach:
// DON'T:
bin_width = 42 * grid_x; // Results in too-tight fit
// DO:
bin_width = 41.5 * grid_x; // Proper tolerance
Problem: User wants 1u (7mm) bin for small parts, code generates bin, but interior is < 2mm tall and useless.
Why it fails: ~5mm of first height unit is consumed by base socket profile.
Better approach:
// When user requests 1u bin:
echo("WARNING: 1u bins have only ~2mm usable interior.");
echo("Recommend minimum 3u (21mm) for functional storage.");
// Suggest alternative
height_u = 3; // Override to practical minimum
Problem: Code creates bin with flat bottom, looks correct in preview, but won't lock into baseplate.
Why it fails: Gridfinity requires specific Z-shaped base profile for socket engagement.
Better approach:
// DON'T: Start with flat cube
cube([bin_width, bin_depth, bin_height]);
// DO: Use proper base module
gridfinity_base_profile(); // Required locking geometry
translate([0, 0, 5])
bin_walls(); // Bin body above base
Problem: User wants stackable bins, code adds simple rim at top, but bins don't stack properly.
Why it fails: Stacking lip must be inverted mirror of base profile for proper engagement.
Better approach:
// DON'T: Add simple cylinder rim
translate([0, 0, bin_height])
cylinder(r=40, h=4.4); // Wrong geometry
// DO: Use proper stacking lip module
translate([0, 0, bin_height])
stacking_lip(); // Mirrors base profile inverted
Problem: Module has magic numbers scattered throughout instead of grid-based calculations.
Why it fails: User can't easily adjust to different sizes; violates Gridfinity modularity principle.
Better approach:
// DON'T:
cube([83, 124.5, 28]); // What grid size is this?
// DO:
cube([
bin_size * grid_x,
bin_size * grid_y,
height_unit * height_u
]);
Before delivering OpenSCAD code:
Required elements:
Dimensional accuracy:
Pattern compliance:
Code quality:
$fn specified for cylinders/curves (e.g., $fn=40)User communication:
Pattern modules are organized as:
./common_items/
├── basic_bin.md - Standard Gridfinity bin (most common)
├── baseplate.md - Grid baseplate with sockets
├── divider_bin.md - Bin with internal compartments
└── lite_bin.md - Thin-wall vase mode variant
Workflow:
84mm alignment enables combining systems:
// 2×2 Gridfinity baseplate (84mm × 84mm)
gridfinity_baseplate(grid_x=2, grid_y=2);
// Same width as 3-slot OpenGrid item (3 × 28mm = 84mm)
// Can mount side-by-side on shared 84mm width surface
Use case: Desktop organization (Gridfinity bins) with wall-mounted tool storage (OpenGrid) sharing common width alignment for visual coherence.
Design consideration: When creating hybrid workspace, use 84mm width increments for alignment across both systems.
Gridfinity Ecosystem:
Related skills:
Official resources:
npx claudepluginhub racurry/neat-little-package --plugin spirographPlans Gridfinity baseplates for 3D printing by calculating optimal grid sizes from measurements, slicing large grids for printer beds, computing padding for fits, converting metric/imperial units, and guiding STL generation.
Provides parametric OpenSCAD models for BCI hardware including electrode holders, paste adapters, headset hooks, pogo combs, fNIRS housings, and eurorack frames. Use for designing, modifying, or 3D-printing neuromodulation components.