LLM + RAG Robotic_Arm Generator (Grasshopper C# STEP_00–STEP_09)

Wickerson Studios Product Summary

Robotic Arm — LLM + RAG Generator (Grasshopper C# STEP Pipeline)

Build high-LOD robotic arm CAD assemblies in Rhino/Grasshopper using a clean, modular STEP_00–STEP_09 node series. This system is engineered for real Grasshopper workflows: BasePlane-safe, performance-aware, and designed so your ArmPrompt can cause major, visible changes in geometry—without breaking the pipeline.

What it does

• Generates a complete robotic arm assembly: skeleton → joints → links → tool/end effector → panels → fasteners → sensors
• Optional LLM + RAG prompting converts your ArmPrompt + reference image + metadata into structured CFG/SFG overrides
• Includes an animation driver node so joints move with smooth trig cycles (great for exploration, demos, and render sequences)
• Finishes with export packaging + a QA metrics report (counts, validity, bounding box, warnings)

Why it’s different

• Not a toy prompt demo: it’s a production-style pipeline built the way serious GH systems are built—stateful, stable, capped, modular.
• Prompt actually matters: the ArmPrompt is translated into downstream geometry drivers (joint count, link proportions, joint housings, tool style, panel logic, sensor density, etc.) so changing prompt language changes the robot in a big way.
• Learnable architecture: each STEP is a clean lesson in state, parsing, kinematics, solid-building, placement, and export.

Perfect for

• Computational designers, digital fabrication studios, educators
• Anyone who wants a reusable “prompt → parametric assembly” template in Grasshopper
• Creating rapid robotic concepts for visuals, speculative engineering, or teaching

Get it at

https://www.wickersonstudios.com

README .txt (download + full text)

Download: https://www.wickersonstudios.com

0) WHAT THIS IS

This is a 10-node Grasshopper C# “STEP” pipeline that generates a high-LOD,

BasePlane-safe robotic arm CAD assembly (curves + Breps) from a Master CFG/SFG

and an AI-driven ArmPrompt workflow.

You get:

• A reproducible parametric robot-arm generator (joints, links, panels,

fasteners, sensors, tools) that stays stable in Grasshopper

• An optional OpenAI-powered “Prompt → CFG/SFG/RAG” step that makes the arm

radically change form based on the ArmPrompt + reference images + metadata

• Animation support (STEP_02a) to drive joint motion with smooth trig cycles

• Export packaging (STEP_08) and QA metrics reporting (STEP_09)

This is built as a learning product AND a production-friendly template.

1. REQUIREMENTS
2. • Rhino 8 + Grasshopper (recommended)
3. • Grasshopper C# Script component (the “C#” node)
4. • Internet + OpenAI API key (optional; only needed for STEP_01b)

• If you do not provide a key, the system falls back to deterministic
• generation so the pipeline still runs.

2) INCLUDED NODES (STEP MAP)

STEP_00 — INIT / MASTER CFG+SFG / EngineState

STEP_01b — OpenAI Prompting (ArmPrompt + Ref Image URL + metadata → CFG/SFG/RAG)

STEP_02a — ANIM DRIVER (internal time + trig patterns → JOINT_DEGS list)

STEP_02 — BasePlane-safe Arm Skeleton (joint frames + axes + curves)

STEP_03 — Links from Skeleton (3D link cylinders/solids + link centerlines)

STEP_04 — Joint Solids (revolute housing, caps, brackets; BasePlane-safe)

STEP_05 — End Effector / Tooling (tool breps + optional cutters + envelope)

STEP_06 — Panels + Fasteners + Sensors (procedural placement, proper offsets)

STEP_07 — Assembly / Optional Boolean Pass (lightweight merging + stabilization)

STEP_08 — Export & Packaging (dir/prefix, JSON/CSV, optional mesh/IFC hooks)

STEP_09 — QA Metrics / Report (counts, bbox, validity, warnings)

NOTE:

Some deployments choose to merge STEP_07 + STEP_08 depending on your needs.

3) QUICK START (10 MINUTES)

A) Create a new Grasshopper file in Rhino.

B) Drop 10x C# Script components and name them:

S00_ARM_INIT

S01B_ARM_OPENAI

S02A_ARM_ANIM

S02_ARM_SKELETON

S03_ARM_LINKS

S04_ARM_JOINTS

S05_ARM_TOOLING

S06_ARM_HARDWARE_PANELS

S08_ARM_EXPORT_PACKAGING

S09_ARM_QA_METRICS

C) Paste the matching script code into each C# component.

D) Wire the outputs to the next step’s inputs EXACTLY by name.

(You can use “Relays” and “Scribbles” to keep the canvas clean.)

E) Set STEP_00 Run=true and provide:

• Seed (int)

• cfg (string)

• sfg (string)

F) (Optional) STEP_01b:

• Provide your OpenAI API key

• Set ArmPrompt (string)

• Provide ReferenceImageUrl (string) and/or metadata text (string)

• Choose OverrideMode: merge (recommended), append, or replace

G) Turn on STEP_02a Run=true to animate the arm over time.

H) Preview Breps/Curves at each step (joints/links/panels etc.).

4) THE MASTER CFG (HOW YOU CONTROL GEOMETRY)

The pipeline uses a Master CFG string (key=value; per line or semicolon).

Examples of CFG keys you will typically control:

• robot scale & proportions

• joint count

• link lengths, radii, taper

• joint housing sizes

• panel spacing / thickness / jitter

• fastener patterns

• sensor densities / offsets

• LOD caps (segment counts, max counts)

• performance caps (time budget / batching)

Tip:

If you want BIG, visible changes, change:

• jointCount

• baseReach / linkLen[] profile

• jointAxis modes

• endEffector type

• panel enable/spacing/rotation

• LOD/segmentation (within reason)

5) SFG (STRUCTURED FOCUS GUIDANCE)

SFG is a “channel” text block:

reference: ...

program: ...

style: ...

massing: ...

facade: ...

math: ...

notes: ...

For robot arms:

• “massing” describes kinematic silhouette

• “math” describes joint patterns (e.g. sine-cycled, easing, clamping)

• “notes” describes manufacturing/assembly logic

6) ARMPROMPT (MAKE THE ROBOT CHANGE)

ArmPrompt is the primary creative control for STEP_01b.

Use it to specify:

• Arm type (6-axis industrial / cobot / surgical / SCARA / delta)

• Material language (aluminum castings / carbon fiber / anodized plates)

• Joint styles (large harmonic drive housings / slim bearings / exposed bolts)

• Cable routing style (external chain / internal channels / braided looms)

• End effector (gripper / spindle / welder / suction / tool changer)

• Performance intent (reach, payload, stiffness, speed)

• Aesthetic (brutalist, aerospace, toy-like, biotech, etc.)

If you provide a reference image URL, STEP_01b can translate it into CFG.

7) ANIMATION (STEP_02a)

STEP_02a is an internal time driver:

Inputs:

• Run (bool)

• Reset (bool)

• Tick (bool) — can be a Toggle True or Timer-triggered boolean

• Dt (double) — time step, e.g. 0.1

• UseInternalTime (bool)

Outputs:

• TIME_OUT (double)

• JOINT_DEGS (List<double>) — wire to STEP_02 joint degrees input

This creates smooth undulating motion via trig/easing modes.

You can pick per-joint phase offsets, amplitude, bias, and smoothing.

8) EXPORT (STEP_08)

Suggested defaults:

ExportDir:

C:\Wickerson\Exports\RobotArm

ExportPrefix:

ARM_{seed}_{yyyyMMdd_HHmm}

STEP_08 writes JSON/CSV manifests and any selected exports.

If you do not want disk writes, keep ExportDir blank / Run=false.

9) TROUBLESHOOTING

• “Nothing outputs”:

• Confirm Run=true for the step
• Confirm you wired the correct upstream outputs into the correct input names
• • “Empty Sensors/Panels/Fasteners”:
• Confirm enable keys in CFG (and that STEP_06 is Run=true)
• • “Too heavy / slow”:
• Reduce LOD caps: maxSeg, maxParts, fastenerCount, panelCount
• Turn off cutters/booleans first
• • “Parts are rotated / offset”:
• Ensure BasePlane is consistent (WorldXY recommended)
• Confirm STEP_02 uses the same plane used by downstream steps

10) LICENSE / USAGE

This system is provided for educational and production use as a template.

You are responsible for validating engineering safety, structural integrity,

and manufacturing feasibility for real-world fabrication.

WICKERSON STUDIOS — THE WICKERSON WAY

Computational design assets, Grasshopper C# pipelines, and LLM-RAG workflows:

https://www.wickersonstudios.com