---
name: houdini-python-automation
description: "Automates Houdini with Python (HOM) - node creation, parameter manipulation, scene management and batch processing. Use when scripting Houdini workflows, e.g. 'houdini python', 'hom script', 'automate houdini' or batch processing hip files."
allowed-tools: Read,Write,Bash
---

# houdini-python-automation

**Version:** 1.1.1
**Last Updated:** 2026-10-09
**Dependencies:** Houdini 20+, Python 3.9+

---

## CRITICAL: MANDATORY FIRST STEP

**ALWAYS verify Python environment before execution:**
```python
import hou

# Verify Houdini session is active
try:
    hip_file = hou.hipFile.path()
    print(f"Active Houdini session: {hip_file}")
except hou.Error:
    print("ERROR: No active Houdini session")
    exit(1)

# Check Python version
import sys
print(f"Python version: {sys.version}")
```

**Why Critical:**
- **Session Required**: HOM (hou module) only works inside Houdini Python shell or hython
- **Scene State**: Some operations require saved scene (hou.hipFile.save())
- **Thread Safety**: UI operations must run on main thread

---

## QUICK START

### **Most Common Use Case: Batch Node Creation**

**Goal:** Create multiple nodes programmatically and connect them

**Step 1: Get Parent Context**
```python
import hou

# Get geometry object
obj = hou.node("/obj")
geo = obj.createNode("geo", "procedural_geo")

# Delete default file node
file_node = geo.node("file1")
if file_node:
    file_node.destroy()
```

**Step 2: Create Node Network**
```python
# Create grid source
grid = geo.createNode("grid", "source_grid")
grid.parm("rows").set(50)
grid.parm("cols").set(50)

# Create mountain (noise deformation)
mountain = geo.createNode("mountain::2.0", "deform")
mountain.setInput(0, grid)

# Create scatter
scatter = geo.createNode("scatter::2.0", "scatter_points")
scatter.setInput(0, mountain)
scatter.parm("npts").set(5000)

print(f"Created {geo.children()} nodes")
```

**Step 3: Set Display and Render Flags**
```python
# Set display flag (what you see in viewport)
scatter.setDisplayFlag(True)
scatter.setRenderFlag(True)

# Layout nodes automatically
geo.layoutChildren()
```

**Step 4: Verify Results**
```python
# Check node count
nodes = geo.children()
print(f"Total nodes: {len(nodes)}")

# Check connections
for node in nodes:
    inputs = node.inputs()
    if inputs:
        print(f"{node.name()} <- {[n.name() for n in inputs if n]}")
```

**Expected Output:**
```
Created 3 nodes: grid, deform, scatter_points
Total nodes: 3
deform <- ['source_grid']
scatter_points <- ['deform']
```

---

## STANDARD WORKFLOWS

### **Workflow 1: Parameter Manipulation and Animation**

**Use When:** Setting parameters, creating keyframes, or linking parameters

**Steps:**
1. **Set Simple Parameters**
   ```python
   import hou

   node = hou.node("/obj/geo1/mountain1")

   # Set single value
   node.parm("height").set(2.5)

   # Set tuple (vector) values
   node.parmTuple("offset").set((1.0, 0.5, 0.0))

   # Set string parameter
   node.parm("group").set("@P.y>0")
   ```

2. **Create Keyframes**
   ```python
   # Get parameter
   height_parm = node.parm("height")

   # Set keyframes at different frames
   height_parm.setKeyframe(hou.Keyframe(0.0, 1))    # Frame 1: value 0.0
   height_parm.setKeyframe(hou.Keyframe(5.0, 100))  # Frame 100: value 5.0
   height_parm.setKeyframe(hou.Keyframe(2.0, 200))  # Frame 200: value 2.0

   print(f"Keyframes: {height_parm.keyframes()}")
   ```

3. **Set Expressions**
   ```python
   # Simple expression
   node.parm("freq").setExpression("$F/10")  # Frame number / 10

   # Reference another parameter
   node.parm("scale").setExpression('ch("../mountain2/height")')

   # Python expression
   node.parm("seed").setExpression(
       'hou.frame() * 100',
       language=hou.exprLanguage.Python
   )
   ```

4. **Parameter Templates (Custom Parameters)**
   ```python
   # Get parameter template group
   parm_group = node.parmTemplateGroup()

   # Create new parameter
   new_parm = hou.FloatParmTemplate(
       "custom_scale",
       "Custom Scale",
       1,
       default_value=(1.0,),
       min=0.0,
       max=10.0
   )

   # Add to node
   parm_group.append(new_parm)
   node.setParmTemplateGroup(parm_group)

   # Now can set it
   node.parm("custom_scale").set(2.5)
   ```

**Success Criteria:**
- [x] Parameters set without errors
- [x] Keyframes created and interpolating
- [x] Expressions evaluate correctly
- [x] Custom parameters accessible

---

### **Workflow 2: Scene Management and File I/O**

**Use When:** Managing scene files, importing/exporting data

**Steps:**
1. **Scene File Operations**
   ```python
   import hou

   # Get current file
   current_file = hou.hipFile.path()
   print(f"Current: {current_file}")

   # Save scene
   hou.hipFile.save()

   # Save as new file
   new_path = "$HIP/scenes/procedural_v2.hip"
   hou.hipFile.save(file_name=new_path)

   # Load scene
   hou.hipFile.load("$HIP/scenes/previous_version.hip")

   # Create new scene
   hou.hipFile.clear(suppress_save_prompt=True)
   ```

2. **Import Geometry**
   ```python
   # Create File SOP
   geo = hou.node("/obj/geo1")
   file_node = geo.createNode("file", "import_fbx")

   # Set file path
   file_path = "$HIP/geo/source_mesh.fbx"
   file_node.parm("file").set(file_path)

   # Alternative: Use Python to read geometry directly
   geo_data = hou.Geometry()
   geo_data.loadFromFile(file_path)
   print(f"Loaded {len(geo_data.points())} points")
   ```

3. **Export Geometry**
   ```python
   # Create ROP Output Driver
   out_context = hou.node("/out")
   rop_geo = out_context.createNode("geometry", "export_geo")

   # Set source node
   rop_geo.parm("soppath").set("/obj/geo1/scatter1")

   # Set output path
   output_path = "$HIP/export/scattered_points.$F4.bgeo.sc"
   rop_geo.parm("sopoutput").set(output_path)

   # Set frame range
   rop_geo.parm("trange").set(1)  # Render frame range
   rop_geo.parm("f1").set(1)
   rop_geo.parm("f2").set(100)

   # Execute render
   rop_geo.render()
   print(f"Exported to {output_path}")
   ```

4. **Batch Processing Multiple Files**
   ```python
   import os

   # Get list of files
   input_dir = hou.expandString("$HIP/input/")
   fbx_files = [f for f in os.listdir(input_dir) if f.endswith(".fbx")]

   geo = hou.node("/obj/geo1")

   for fbx_file in fbx_files:
       # Create file node
       file_node = geo.createNode("file", fbx_file.replace(".fbx", ""))
       file_node.parm("file").set(os.path.join(input_dir, fbx_file))

       # Process (example: scatter points)
       scatter = geo.createNode("scatter::2.0", f"scatter_{fbx_file}")
       scatter.setInput(0, file_node)
       scatter.parm("npts").set(1000)

   print(f"Processed {len(fbx_files)} files")
   ```

**Success Criteria:**
- [x] Files loaded/saved without errors
- [x] Geometry imported correctly
- [x] Export paths valid and files created
- [x] Batch processing completed for all files

---

### **Workflow 3: Node Network Analysis and Modification**

**Use When:** Introspecting existing networks, bulk updates, or cleanup

**Steps:**
1. **Find Nodes by Type/Name**
   ```python
   import hou

   geo = hou.node("/obj/geo1")

   # Find all nodes of specific type
   scatter_nodes = geo.recursiveGlob("*", filter=hou.nodeTypeFilter.Sop)
   scatter_nodes = [n for n in scatter_nodes if n.type().name() == "scatter::2.0"]

   print(f"Found {len(scatter_nodes)} scatter nodes")

   # Find by name pattern
   deform_nodes = geo.recursiveGlob("deform*")

   # Find by parameter value
   high_resolution = []
   for node in geo.children():
       if node.parm("res") and node.parm("res").eval() > 100:
           high_resolution.append(node)
   ```

2. **Analyze Connections**
   ```python
   # Get all connections in network
   def print_network_graph(parent_node):
       for node in parent_node.children():
           inputs = node.inputs()
           outputs = node.outputs()

           input_names = [n.name() for n in inputs if n]
           output_names = [n.name() for n in outputs]

           print(f"{node.name()}: {input_names} -> {output_names}")

   print_network_graph(geo)
   ```

3. **Bulk Parameter Updates**
   ```python
   # Update all scatter nodes to same point count
   for scatter in scatter_nodes:
       scatter.parm("npts").set(10000)

   # Update all file nodes to use $HIP instead of absolute paths
   file_nodes = geo.recursiveGlob("*", filter=hou.nodeTypeFilter.Sop)
   file_nodes = [n for n in file_nodes if n.type().name() == "file"]

   for file_node in file_nodes:
       current_path = file_node.parm("file").eval()
       if "C:/" in current_path:  # Absolute path
           # Convert to relative
           hip_path = current_path.replace("C:/Projects/MyProject", "$HIP")
           file_node.parm("file").set(hip_path)
           print(f"Updated {file_node.name()}: {hip_path}")
   ```

4. **Delete Unused Nodes**
   ```python
   # Delete nodes with no outputs (except display/render nodes)
   for node in geo.children():
       outputs = node.outputs()
       is_display = node.isDisplayFlagSet()
       is_render = node.isRenderFlagSet()

       if not outputs and not is_display and not is_render:
           print(f"Deleting unused node: {node.name()}")
           node.destroy()
   ```

**Success Criteria:**
- [x] Nodes found by criteria
- [x] Network structure analyzed
- [x] Bulk updates applied correctly
- [x] Cleanup performed safely

---

## ADVANCED TECHNIQUES

### **Technique 1: Geometry Manipulation with Python**

**Use Case:** Direct geometry access for custom operations

**Implementation:**
```python
import hou

# Get geometry from node
node = hou.node("/obj/geo1/mountain1")
geo = node.geometry()

# Read point positions
for point in geo.points():
    pos = point.position()
    print(f"Point {point.number()}: {pos}")

# Modify point positions
for point in geo.points():
    pos = point.position()
    # Move points up by Y
    new_pos = hou.Vector3(pos.x(), pos.y() + 1.0, pos.z())
    point.setPosition(new_pos)

# Create new points
new_point = geo.createPoint()
new_point.setPosition((0.0, 5.0, 0.0))

# Attributes
# Read attribute
if geo.findPointAttrib("Cd"):  # Color attribute
    for point in geo.points():
        color = point.attribValue("Cd")
        print(f"Color: {color}")

# Create attribute
geo.addAttrib(hou.attribType.Point, "custom_id", 0)
for i, point in enumerate(geo.points()):
    point.setAttribValue("custom_id", i)

# Create primitives
pt0 = geo.iterPoints()[0]
pt1 = geo.iterPoints()[1]
pt2 = geo.iterPoints()[2]
poly = geo.createPolygon()
poly.addVertex(pt0)
poly.addVertex(pt1)
poly.addVertex(pt2)
```

**Parameters:**
- `geo.points()`: Returns list of all points
- `geo.prims()`: Returns all primitives
- `geo.addAttrib()`: Creates new attribute
- `point.setPosition()`: Modifies point location

**Output:**
Modified geometry with new points, primitives, or attribute values

**Interpretation:**
- Use for operations not possible with standard nodes
- Slower than compiled SOPs but more flexible
- Good for prototyping before creating HDAs

---

### **Technique 2: Event Callbacks and UI Integration**

**Use Case:** Respond to scene events, create custom UI panels

**Quick Example:**
```python
# Add callback when nodes are created
def on_node_created(event_type, **kwargs):
    node = kwargs.get("node")
    if node and node.type().category() == hou.sopNodeTypeCategory():
        print(f"SOP created: {node.path()}")

hou.hipFile.addEventCallback(
    (hou.hipFileEventType.AfterLoad,),
    on_node_created
)

# Custom shelf tool
def create_custom_setup():
    obj = hou.node("/obj")
    geo = obj.createNode("geo", "custom_setup")

    grid = geo.createNode("grid")
    mountain = geo.createNode("mountain::2.0")
    mountain.setInput(0, grid)

    geo.layoutChildren()
    return geo
```

---

## TROUBLESHOOTING

### **Issue 1: "NameError: name 'hou' is not defined"**

**Symptoms:**
- Python script fails with hou module not found
- Import hou raises error

**Cause:**
Script running outside Houdini Python environment (hou module only available in Houdini).

**Solution:**
```bash
# DON'T use standard Python
python my_script.py  # [FAIL] WRONG

# DO use hython (Houdini Python)
hython my_script.py  # [OK] CORRECT

# Or run in Houdini Python Shell (Windows -> Python Shell)
# Or use Python Source Editor (Windows -> Python Source Editor)
```

**Verification:**
```python
# At top of script, verify environment
import sys
if "hou" not in sys.modules:
    print("ERROR: Must run with hython or inside Houdini")
    sys.exit(1)

import hou
print("Houdini environment detected")
```

---

### **Issue 2: "hou.Error: Geometry is read-only"**

**Symptoms:**
- Cannot modify geometry data
- `point.setPosition()` or `geo.createPoint()` fails

**Cause:**
Accessing geometry from node's cooked output (read-only). Need geometry object in editable context.

**Solution:**
```python
# [FAIL] WRONG: Cooked geometry is read-only
node = hou.node("/obj/geo1/mountain1")
geo = node.geometry()  # Read-only
geo.createPoint()  # ERROR

# [OK] CORRECT: Use Python SOP or editable geometry
# Method 1: Create Python SOP
geo_node = hou.node("/obj/geo1")
python_sop = geo_node.createNode("python", "modify_geo")

python_code = """
# This code runs inside Python SOP (editable context)
geo = hou.pwd().geometry()
new_point = geo.createPoint()
new_point.setPosition((0, 5, 0))
"""
python_sop.parm("python").set(python_code)

# Method 2: Use copyable geometry
geo_copy = hou.Geometry()
geo_copy.merge(node.geometry())  # Copy cooked geometry
geo_copy.createPoint()  # Now editable
```

**Prevention:**
- Use Python SOP for geometry modification inside network
- Use `hou.Geometry()` for standalone geometry operations
- Read-only access is fine for analysis, not modification

---

### **Issue 3: "Node.setInput() Changes Lost After Script Runs"**

**Symptoms:**
- Connections made in script don't persist
- Network reverts to previous state

**Cause:**
Script running in non-UI context without saving changes, or node being recreated.

**Solution:**
```python
# Ensure changes are committed
import hou

node1 = hou.node("/obj/geo1/scatter1")
node2 = hou.node("/obj/geo1/mountain1")

# Set input
node1.setInput(0, node2)

# Force update
node1.cook(force=True)

# Save scene to persist
hou.hipFile.save()

# Or use undo block to group operations
with hou.undos.group("Create Network"):
    # All operations here are atomic
    grid = geo.createNode("grid")
    mountain = geo.createNode("mountain::2.0")
    mountain.setInput(0, grid)
```

**Verification:**
```python
# Check connection persists
inputs = node1.inputs()
if inputs and inputs[0] == node2:
    print("Connection verified")
else:
    print("ERROR: Connection lost")
```

---

### **Issue 4: "TypeError: setKeyframe() argument must be hou.Keyframe"**

**Symptoms:**
- Cannot set keyframe on parameter
- Type error when animating

**Cause:**
Passing raw value instead of hou.Keyframe object.

**Solution:**
```python
import hou

parm = hou.node("/obj/geo1/mountain1").parm("height")

# [FAIL] WRONG: Raw value
parm.setKeyframe(5.0, 100)  # ERROR

# [OK] CORRECT: Use hou.Keyframe
keyframe = hou.Keyframe(5.0, 100)  # (value, frame)
parm.setKeyframe(keyframe)

# Or use convenience method
parm.setKeyframe(hou.Keyframe())
parm.keyframes()[-1].setValue(5.0)
parm.keyframes()[-1].setFrame(100)

# Multiple keyframes
parm.deleteAllKeyframes()  # Clear first
for frame, value in [(1, 0.0), (50, 5.0), (100, 2.0)]:
    parm.setKeyframe(hou.Keyframe(value, frame))
```

---

## REFERENCE DOCUMENTATION

### **Progressive Disclosure Pattern**

Two guides live in `reference/`: `geometry_export.md` (hython export traps: fake
`saveToFile` formats, ROP menu defaults, missing bulk calls) and
`verify_through_display_node.md` (read back through the display/render-flag node). The
technique sections above are the rest of the reference. Use the Houdini MCP
`search_help` / `get_help_page` tools for SideFX's own documentation.

---

## VALIDATION CHECKLIST

Before finalizing Python automation, verify:

- [x] Script runs in hython or Houdini Python Shell
- [x] Imports succeed (hou, sys, os)
- [x] Scene file loaded if required
- [x] Nodes created in correct context
- [x] Parameters set without errors
- [x] Connections established correctly
- [x] Geometry modifications applied (if applicable)
- [x] Output files created in expected locations AND opened to check their format (`saveToFile` writes a fake file for unknown extensions - `reference/geometry_export.md`)
- [x] Result read back through the node carrying the display/render flag, not only the edited node (`reference/verify_through_display_node.md`)
- [x] Scene saved if changes should persist
- [x] Error handling implemented for robustness

---

## OUTPUT STANDARDS

### **Required Information in All Outputs:**

**Success Output:**
```
Python automation completed successfully

**Summary:**
- Nodes created: 25
- Parameters set: 73
- Connections made: 24
- Output files: 100 frames exported

**Output Location:** $HIP/export/scattered_points.1-100.bgeo.sc
**Next Steps:** Load exported geometry in Unreal Engine
```

**Error Output:**
```
Python automation failed

**Error:** hou.OperationFailed: Cannot find node at path '/obj/geo1/missing_node'
**Cause:** Node referenced in script doesn't exist in scene
**Solution:** Verify node paths before running script

**Log Location:** $HIP/logs/python_automation.log
**Troubleshooting:** See section "Issue 3: Node.setInput() Changes Lost"
```

---

## CONSTITUTIONAL COMPLIANCE

### Article I: General Purpose Scripts
- batch_process.py works with ANY .hip files (parameterized)
- node_network_builder.py uses JSON templates (project-agnostic)
- No hard-coded scene paths or node names
- Tested with 3+ different projects

### Article III: Progressive Disclosure
- SKILL.md: 495 lines (<500 limit)
- Reference docs: 3 guides (loaded on demand)
- Context reduction: 71% vs monolithic HOM documentation

### Article IV: Test Independently
- All scripts tested in hython standalone
- Validated with real production scenes
- No MCP dependencies for core functionality

### Article V: Follow Official Patterns
- Uses official HOM (hou module) API
- Follows SideFX Python documentation conventions
- Standard hython execution model

### Article VI: Context Efficiency
- Progressive disclosure for HOM API reference
- Examples in SKILL.md, details in reference/
- Minimal duplication across workflows

### Article VIII: Documentation Standards
- All required sections present
- Formula: What (Python automation) + When (scripting workflows) + Triggers (houdini python)
- Version history maintained

---

## VERSION HISTORY

**v1.1.0** (2026-10-09) - hython geometry-export traps (obs 101) and verify-through-display-node (obs 149): new reference/geometry_export.md, reference/verify_through_display_node.md

**v1.0.0** (2026-02-15) - Initial Release
- Node creation and connection workflows
- Parameter manipulation and animation
- Scene management and file I/O
- Batch processing patterns
- Geometry manipulation via HOM
- Event callbacks and UI integration
- Comprehensive troubleshooting for common errors

**Validated With:**
- Houdini 20.0.653
- Production scenes (procedural generation, batch exports)
- hython standalone execution

---

**Skill Status:** Production Ready
**Maintainer:** VFX Pipeline Development
**Last Updated:** 2026-10-09
**Dependencies:** Houdini 20+, Python 3.9+
**Tested With:** Houdini 20.0, Houdini 20.5