Skip to main content
skill CX Codex

blender-geometry-nodes — Claude Code skill: features and install

The blender-geometry-nodes Claude Code skill helps build Geometry Nodes setups in Blender. It comes into play for procedural assets, surface scattering, and modifier inputs.

MIT 563 installs ★ 2,624 updated 2026-11-13

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add EL4CTEO/blender-skills --skill blender-geometry-nodes -a claude-code
Open on GitHub

What blender-geometry-nodes does

The skill covers Geometry Nodes fields, domains, attributes, instances, and Simulation, Repeat, and For Each Element zones. It uses scripts/gn_builder.py to create node trees from a JSON spec: inspect socket names with --describe, then pass the spec and apply the tree to an object.

The guide also covers lists, SDF grids, node tools, and simulation baking. It explains modifier inputs, attribute export, and API changes across Blender versions. Socket names change between versions, so the guide recommends checking them for the target version; its builder examples use Blender 5.3.

What it helps with

  • build a Geometry Nodes tree from a JSON spec
  • scatter instances across a surface using density and a mask
  • preserve or convert attributes across geometry domains
  • prepare instances and evaluated geometry for export

Example prompts for the agent

  • Build a surface scatter from scatter.json and set Density to control the distribution.
  • Show the sockets for GeometryNodeDistributePointsOnFaces and GeometryNodeInstanceOnPoints.
  • Create a procedural environment setup with exposed modifier inputs.

How to install blender-geometry-nodes

1Skills CLI (Vercel)

npx skills add EL4CTEO/blender-skills --skill blender-geometry-nodes -a claude-code

2Manually: put the files in place

~/.claude/skills/blender-geometry-nodes/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/blender-geometry-nodes/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about blender-geometry-nodes

How do I install blender-geometry-nodes in Claude Code?

Run npx skills add EL4CTEO/blender-skills --skill blender-geometry-nodes -a claude-code. The skill file is at ~/.claude/skills/blender-geometry-nodes/SKILL.md.

What does blender-geometry-nodes do?

It guides an agent through building Blender Geometry Nodes trees, using fields and attributes, managing instances, and preparing geometry for export.

Which Blender versions does the skill cover?

The guide focuses on Blender 5.3 and describes API and socket changes in 5.2 and 5.3. It recommends inspecting socket names with --describe before building a tree.

Source text

SKILL.md · MIT
---
name: blender-geometry-nodes
description: Geometry Nodes in Blender 5.3 - fields, domains, attributes, instancing, zones (simulation/repeat/for-each), closures/bundles, lists, SDF grids, node tools, baking, plus a JSON-to-node-tree builder and socket inspector. Use for scattering, procedural assets/environments, parametric tools and modifier inputs.
license: MIT
metadata:
  author: blender-agent-skills
  version: "1.2.0"
---

# Geometry Nodes

The execution model is in `blender-core`. Build trees with `scripts/gn_builder.py`, a compact JSON spec that's far cheaper than raw bpy. Look up exact socket names first, because they change between versions:
```
scripts/gn_builder.py -- --describe GeometryNodeDistributePointsOnFaces GeometryNodeInstanceOnPoints
scripts/gn_builder.py -- --spec scatter.json --apply Ground --set Density=20 Seed=3 Mask=@paint_mask
```
`--set Name=@attr` feeds a modifier input from a named attribute. The result reports evaluated vert/face counts and node warnings. The spec format is in the script docstring; full examples are in [references/recipes.md](references/recipes.md).

## Core concepts (get these right or nothing works)
- **Geometry** flows left→right through sockets with **circle** shapes. **Fields** (diamond sockets) are functions evaluated per element **on the node that consumes them**, in that node's domain/context.
- **Domains**: Point, Edge, Face, Face Corner, Spline, Instance, Layer. `Capture Attribute` freezes a field at a point in the graph (before topology changes), and `Evaluate on Domain` converts between domains.
- **Attributes**: built-ins (`position`, `normal`, `sharp_face`, `material_index`, `UVMap`...) plus named ones via `Store Named Attribute`. Named attributes persist after the modifier. That's how GN data reaches shaders (Attribute node) and exporters (glTF `export_attributes`, which exports names starting with `_`).
- **Instances** are cheap (one mesh, many transforms). **Realize Instances** only when you must edit per-instance geometry or export a single mesh. Realize as late as possible.
- Inputs exposed on the group interface become **modifier inputs** (5.2: `mod.properties.inputs.<identifier>.value`). Panels group them, menu sockets give enums.

## Zones and advanced types
| Feature | Nodes | Use |
|---|---|---|
| Simulation zone | `GeometryNodeSimulationInput/Output` (paired) | per-frame state: growth, particles, erosion; bake to keep |
| Repeat zone | `GeometryNodeRepeatInput/Output` | iterate N times (L-systems, relaxation, recursive subdivision) |
| For Each Element | `GeometryNodeForeachGeometryElementInput/Output` | run a sub-graph per element (per building lot, per island) |
| Closures / Bundles (5.0+) | `NodeClosureInput/Output`, `NodeCombineBundle`/`NodeSeparateBundle`, Evaluate Closure | pass functions/structured data around; reusable "strategy" node groups |
| Lists (5.2) | `GeometryNodeFieldToList`, `ListGetItem`, `ListLength`, `SortList`, `FilterList` | real arrays, not fields |
| Grids/SDF (4.x–5.x) | `MeshToSDFGrid`, `SDFGridBoolean`, `SDFGridFillet`, `SDFGridOffset`, `GridToMesh` | smooth booleans, remeshing, fillets, voxel effects |
| Grids/lists/curves (5.3) | `GridSolvePoisson`, `RasterizePoints`, `GridTopologyBoolean`, `GridDeactivateVoxels`, `GetGridNames`, `CombineList`, `ConstructCurves`, `GeometryMaterials`, `FunctionNodeGetVectorComponent` | fluid-like/voxel effects, fixed small lists, curves from position lists |
| Physics (5.2, experimental) | `GeometryNodeXPBDSolver` + bundles | node-based cloth/hair, see `blender-simulation` |
| Gizmos | `GizmoLinear/Dial/Transform` | viewport handles for inputs |
Zones need `input.pair_with_output(output)` (spec key `pairs`), plus items on the output node (`repeat_items`, `state_items`, ...; spec 4th node field).

## Procedure
1. Sketch the data flow: source geometry → selection/masks (fields) → generate/instance → transform/randomize → realize/merge → set materials/shading → output.
2. `--describe` every node type you'll use, then write the spec and build. Check `node_warnings` and the evaluated counts.
3. Expose only meaningful inputs (density, seed, scale range, materials), with min/max set.
4. Look at it (`look`), check `blender-asset-qa` if the result will be exported (realized geometry), and check `blender-game-optimization` for instance counts and tris.
5. Ship: either keep it procedural (the .blend/asset library), or apply the modifier / `visual_geometry_to_objects` for exporters.

## Rules
- Randomness: always expose a `Seed`, and use `Random Value` with the ID/Index field so results stay stable when counts change.
- Scale-independent setups use `Object Info` (Relative) and real units. Apply the object scale or read it explicitly.
- Materials: `Set Material` inside the tree. The material must exist in the file, and instances keep their own materials.
- Shading: GN output loses auto-smooth unless you add `Set Shade Smooth` + (5.x) the `Smooth by Angle` essentials group, or store `sharp_edge`.
- UVs: primitives output `UVMap` via their UV output. Store it with `Store Named Attribute` (Face Corner, 2D Vector, name `UVMap`) or it's dropped.
- Performance: avoid realizing millions of instances, prefer Points + instances for scatter, use `Merge by Distance` sparingly, and simulation zones need baking for playback/export (`object.geometry_node_bake_single` or modifier `bakes`).
- Node tools (`ng.is_tool = True`, `is_mode_edit` etc.) turn a group into an operator in the 3D View menus, for editing workflows.

## Gotchas
- 5.2: `mod["Socket_2"]` no longer works. Use `getattr(mod.properties.inputs, ident).value`, and `.type = "ATTRIBUTE"` + `.attribute_name` for attribute inputs. Compare and Random Value **sockets changed**: Random Value now has single dynamic `Min`/`Max`/`Value` sockets typed by `data_type`. Link by name, and `--describe` when unsure.
- 5.3: Import PLY's output is `Geometry` (was `Mesh`) and is a point cloud for Gaussian-splat files. Curve to Mesh adds `Miter Scale`; Realize Instances adds `Preserve Normals` (negative-scale instances).
- Sockets that are disabled for the current mode/data type are still in `node.inputs` with the same name. The builder picks the **enabled** one. Set `data_type`/`mode` props first (the builder sets props before links).
- `nt.interface.new_socket(...)` is the 4.0+ API (`ng.inputs.new` is gone).
- Exporters see the **evaluated** mesh. Instances become glTF instancing (`export_gpu_instances`) or are realized on export.

© blender-agent-skills · MIT · EL4CTEO/blender-skills

Similar skills

All skills for Game dev and 3D: Unity, Unreal, Godot, Blender →

From the same set28

The whole set →
blender-lighting-lookdev The blender-lighting-lookdev Claude Code skill sets up lighting, cameras and material look-dev in Blender 5.3. It activates for render scenes, asset presentations and consistent material checks. CX Codex +1 606installs blender-retopology-uv The blender-retopology-uv Claude Code skill covers retopology and UV work in Blender 5.3. Use it to turn a sculpt or scan into a game mesh, or prepare UVs for texturing and baking. CX Codex +1 603installs blender-texture-baking blender-texture-baking — a skill for Claude Code that runs Cycles baking pipelines in Blender 5.3. Triggers when transferring high-poly sculpt details to game assets or converting procedural node networks to images. CX Codex +1 587installs blender-rendering blender-rendering — a skill for Claude Code configures Blender 5.3 rendering for stills, animation, and turntables. It covers single-frame, animation, and turntable jobs. CX Codex +1 582installs blender-scene-setup The blender-scene-setup Claude Code skill sets up and audits Blender scenes. It runs while starting a project, organizing a .blend file, or preparing a handoff or export. CX Codex +1 558installs blender-sculpting blender-sculpting — a skill for Claude Code runs procedural sculpting workflows in Blender 5.3 for organic models and characters. Used when building base meshes, adding surface details, and preparing bake sources. CX Codex +1 558installs blender-facial-shapekeys blender-facial-shapekeys is a Claude Code skill that configures facial rigs and shape keys in Blender 5.3 for ARKit 52 and engine export. Runs when preparing 3D character faces for animation or export. CX Codex +1 548installs blender-workflow-recipes blender-workflow-recipes — a skill for Claude Code and Cursor chains Blender 5.3 workflows with QA gates for multi-stage 3D asset generation. Runs on complete multi-stage asset requests. CX Codex +1 543installs

Project sponsors

Companies that keep this analytics open