composio-community Blender Geometry Nodes
Overview
This skill enables Claude to guide users through creating procedural systems in Blender using Geometry Nodes and procedural material workflows.
The workflow focuses on:
- procedural modeling
- node-based generation
- reusable systems
- procedural materials
- non-destructive workflows
- creative iteration
- scalable asset generation
The goal is to create flexible procedural setups that can generate complex geometry, patterns, environments, and effects without manually modeling every detail.
Unlike traditional modeling workflows, Geometry Nodes prioritize systems, logic, and procedural generation over direct mesh editing.
Setup
Before starting:
Install Blender: https://www.blender.org
Open Blender and create a new project.
Switch to the Geometry Nodes Workspace.
Create or select an object.
Add a Geometry Nodes modifier.
Open the Geometry Nodes editor.
Recommended tools:
- Blender
- Reference images
- Node Wrangler add-on
- Material Preview mode
Recommended add-ons:
- Node Wrangler
- Extra Mesh Objects
Inputs Required
- Procedural modeling idea
- Shape references
- Material references
- Distribution or pattern requirements
Optional:
- Existing meshes
- Texture maps
- Height maps
- Reference environments
When to Use This Skill
Use this skill when:
- generating procedural environments
- scattering objects
- creating procedural materials
- building reusable modeling systems
- creating abstract motion graphics
- designing scalable assets
- automating repetitive geometry tasks
When NOT to Use
Do NOT use this skill for:
- highly specific manual sculpting
- organic character sculpting
- direct polygon-by-polygon modeling
- workflows requiring unique hand-crafted geometry only
Example Use Case
Create a procedural sci-fi environment with repeating structures and dynamic materials.
Claude should:
- Create a Geometry Nodes system
- Scatter procedural objects
- Generate controlled randomness
- Apply procedural material logic
- Maintain editable node structures
- Allow scalable adjustments through parameters
Final result should:
- remain fully procedural
- support fast iteration
- generate consistent patterns
- maintain non-destructive control
- remain easily editable
Core Geometry Nodes Principles
1. Think Procedurally, Not Manually
Geometry Nodes workflows focus on systems rather than direct editing.
Instead of:
- manually placing objects
- hand-modeling repeated details
The workflow should:
- define rules
- generate geometry procedurally
- automate repetition
- expose editable controls
Procedural thinking improves:
- scalability
- flexibility
- iteration speed
2. Use Node-Based Logic
Geometry Nodes workflows depend on:
- node relationships
- data flow
- procedural operations
Common node systems:
- object distribution
- instancing
- noise systems
- curve generation
- attribute manipulation
Good node organization improves:
- readability
- debugging
- reusability
3. Keep Workflows Non-Destructive
Geometry Nodes should remain editable and parameter-driven.
Preferred workflow:
- expose controls
- use modifiers
- preserve reusable systems
Avoid:
- destructive mesh conversion too early
- hardcoded values
- overly rigid node trees
Non-destructive systems improve:
- experimentation
- scalability
- long-term flexibility
4. Combine Geometry & Materials Procedurally
Procedural materials should support procedural geometry.
Examples:
- noise-driven materials
- procedural wear
- animated shaders
- height-based color variation
Material nodes and Geometry Nodes should work together to create cohesive procedural systems.
5. Creative Thinking Is Essential
Geometry Nodes are not only technical systems.
Strong workflows require:
- creative experimentation
- visual iteration
- procedural problem solving
- abstract thinking
Claude should encourage:
- iterative experimentation
- reusable procedural logic
- visually driven refinement
Workflow
1. Define the Procedural Goal
Start by identifying:
- what should be generated
- how variation should behave
- what controls should remain editable
Examples:
- procedural buildings
- terrain systems
- abstract motion graphics
- sci-fi panel systems
- procedural vegetation
Define:
- scale
- repetition
- randomness
- material behavior
2. Build Base Geometry
Start with:
- curves
- primitive meshes
- point systems
- distribution surfaces
Keep the base structure simple initially.
Focus on:
- procedural flexibility
- scalable structure
- reusable logic
3. Create Node Logic
Use Geometry Nodes to:
- distribute instances
- manipulate geometry
- randomize attributes
- generate patterns
- control procedural behavior
Common nodes:
- Instance on Points
- Noise Texture
- Random Value
- Curve to Mesh
- Join Geometry
Maintain:
- clean node organization
- labeled groups
- reusable structures
4. Add Procedural Materials
Use shader nodes to create:
- procedural surfaces
- animated materials
- noise variation
- stylized shading
Combine:
- Geometry Nodes
- procedural materials
- attribute-driven shaders
This improves:
- realism
- visual cohesion
- procedural control
5. Add Variation & Controls
Expose parameters for:
- scale
- randomness
- density
- spacing
- color variation
Good procedural systems should:
- remain editable
- adapt quickly
- support experimentation
Avoid:
- overly fixed systems
- hardcoded layouts
- inflexible node trees
6. Optimize the Node Tree
As systems grow:
- organize node groups
- remove unnecessary nodes
- simplify logic
- improve readability
Good organization improves:
- performance
- maintainability
- debugging speed
7. Final Validation
Before rendering or exporting validate:
- procedural consistency
- material behavior
- geometry stability
- scalability
- node organization
Test:
- parameter adjustments
- randomization behavior
- performance impact
- rendering quality
Output Expectations
The final output should include:
- reusable procedural systems
- editable Geometry Nodes workflows
- procedural material integration
- scalable generation logic
- non-destructive procedural assets
The workflow itself should remain:
- modular
- organized
- editable
- scalable
- production-friendly
Execution Strategy (for AI agents)
The agent should:
- Think procedurally instead of manually
- Build reusable node systems
- Keep workflows non-destructive
- Organize node structures clearly
- Combine geometry and materials cohesively
- Encourage experimentation and iteration
The workflow should optimize for:
- scalability
- flexibility
- procedural control
- visual quality
- creative experimentation
Best Practices
- Keep node trees organized
- Use reusable node groups
- Expose editable parameters
- Avoid destructive workflows
- Combine geometry and shader logic
- Validate procedural systems frequently
- Prioritize scalable procedural design
Notes
- Geometry Nodes reward experimentation and creative thinking
- Procedural systems scale far better than manual repetition
- Good node organization significantly improves workflow quality
- Procedural materials enhance procedural geometry dramatically
- Non-destructive workflows improve iteration speed and flexibility