Houdini Poly Extrude: Advanced Techniques Beyond the Basics

Have you ever spent hours tweaking settings in Houdini only to see your extruded geometry look stiff or unrefined?

Is the Poly Extrude node leaving you with uneven faces or messy topology? Many intermediate artists hit a wall when basic extrusions don’t deliver the control they need. Complex projects demand precise edges, custom bevels, and smooth transitions—but trial and error wastes time.

This guide tackles those frustrations head-on. We’ll dive into advanced techniques for the Poly Extrude node, showing you how to master edge rails, randomization, and multi-input workflows without sacrificing performance.

Here you’ll find hands-on tutorials, real-world examples, and practical tips to refine your models faster and with cleaner topology. Ready to move beyond the basics and master extrusions in Houdini?

How can I drive per-primitive/per-edge extrusion with attributes instead of manual groups?

Manually creating face or edge groups breaks procedural flexibility. By leveraging attributes you can define extrusion behavior per-primitive or per-edge in a single PolyExtrude node. Attributes let you encode distance, inset or divisions directly on geometry, then use group expressions or the “Local Attributes” mode to drive extrusion without ever touching group selectors again.

For per-primitive control, assign a float attribute such as “extrudeDist” via an Attribute Wrangle:

• Place an Attribute Wrangle set to run over primitives.
• Write: f@extrudeDist = noise(@P) * 0.2; to vary distance.
• In PolyExtrude enable Local Attributes.
• Map the Depth parameter to the attribute using: $EXTRUDEDIST.

Edge-level extrusion works similarly. In an Attribute Wrangle over edges, set an integer flag like i@edgeExtrude = @curveu > 0.5;. Switch PolyExtrude’s Group type to “Edge Group” and enter the expression @edgeExtrude==1. This will drive selective edge extrusion based on your procedural criteria without ever painting or updating manual groups.

How do I preserve or reconstruct UVs, normals and clean topology when extruding complex meshes?

When you apply PolyExtrude to dense or procedural meshes, UV seams can stretch, normals can invert and topology can collapse. A robust workflow splits attribute preservation into three stages: preparing a quad-friendly base, extruding with attribute-aware settings and post-extrusion repair. Each stage uses Houdini nodes like Facet, AttributeTransfer and Clean to maintain shading and deformation fidelity.

UV Preservation: Before extrusion, store existing UVs in a detail or point attribute using the Attribute Capture SOP. Enable “Transform Extrusion” in PolyExtrude, which carries UV coordinates across offset faces. After extruding, apply UV Flatten scoped to the new faces, then UV Layout to relax stretched islands while respecting original seams.

Normal Consistency: Set PolyExtrude’s “Local Normals” mode to generate offsets perpendicular to each face, preventing inverted normals on complex curvature. Immediately follow with a Facet SOP, unchecking “Output Unique Points” to unify shared normals. If hard edges are needed, pre-mark crease edges in an edge group and use the “Preserve Hard Edges” option in Facet.

Topology Cleanup: Extruding dense regions often creates n-gons and T-junctions. Use the Clean SOP with “Remove Collinear Points” and “Merge Points” thresholds tuned to your mesh scale. For quad-based models, insert edge loops using the Edge Loop SOP before extrusion. In cases of extreme distortion, a quick remesh via Remesh SOP followed by Quadrangulate restores uniform topology.

Key steps in summary:

• Capture UVs with Attribute Capture before extrude
• Use Local Normals in PolyExtrude + Facet SOP post-extrude
• Pre-crease or add loops for edge control
• Clean n-gons with Clean SOP or remesh/quadrangulate

How can I create procedural animated extrusions (growth, noise-based offset, and fracture-ready shells)?

To drive animated extrusions in Houdini, leverage the PolyExtrude SOP’s distance parameter with per-vertex attributes and VEX. First, generate a ramp attribute (e.g., “grow”) via an Attribute Wrangle: use fit(@P.y, minY, maxY, 0, 1) to normalize along a direction. Then reference that attribute in the extrude distance as chf(“maxdist”) * detail(0, “grow”, 0) * (fit(sin(@Time*freq), -1, 1, 0, 1)). This ties expansion speed to both position and time.

For noise-based offsets, compute a noise field in a Point Wrangle before extruding. For example:

v@offset = normalize(@N) * snoise(@P * scale + @Time * animSpeed) * amp;

Feed this “offset” vector into the PolyExtrude’s Output Back Input, set Transform Extrusion to On, and use the local extrude transform parameter to reference the offset attribute. This approach ensures each face extrudes along its own normal with frame-dependent variation.

• Use Attribute VOPs to swap between noise types (snoise, curl noise) without rewriting VEX.
• Animate noise amplitude with channel references (chf) or CHOPs for fine control.

To prepare fracture-ready shells, perform a two-pass extrusion: first inward for thickness, then outward to create an outer shell. Assign a piece ID via a Connectivity SOP, then group by “class” from connectivity. In the inner PolyExtrude, enable Solid Extrusion and reference the piece group to maintain watertight geometry. Finally, feed both shells to the Voronoi Fracture SOP for consistent fracture faces with matching topology.

How do I implement advanced extrusion patterns using VEX and Attribute Wrangles?

Which attributes to create (prim/point: @extrude, @inset, @localN, @orient) and best practices for populating them

To drive a procedural extrude you must define per-face or per-point parameters. Create a primitive attribute @extrude for pull distance, @inset for edge inset, @localN for local normals, and a quaternion @orient for rotation. Best practices:

• Compute @localN via primnormal(0, @primnum) to ensure consistent face orientation.
• Use detail or point promotion sparingly; keep extrusion data as prim attributes to avoid interpolation issues.
• Name attributes with clear prefixes and data types: f@ for floats, v@ for vectors, q@ for quaternions.
• Normalize any noise-driven offsets to prevent unintended scaling artifacts during extrusion.

Step-by-step VEX example: compute per-face thickness + inset and feed results to the PolyExtrude node

Below is a simplified Wrangle snippet in run-over primitives mode. It calculates a noise-based thickness and proportional inset, captures face normals, and builds an orientation quaternion for twist effects.


float base = chf("thickness");
float n = noise(@P * chf("scale"));
f@extrude = base * fit(n, 0, 1, 0.5, 1.5);
f@inset = f@extrude * chf("inset_ratio");
v@localN = primnormal(0, @primnum);
float angle = chf("twist") * f@extrude;
q@orient = quaternion(radians(angle), v@localN);


After this Wrangle, connect a PolyExtrude SOP. In its parameters:

• Enable “Distance” > Use Attribute, set to extrude.
• Enable “Inset” > Use Attribute, set to inset.
• Under “Local Attributes,” point Local Normal to localN.
• Under “Transform Extruded Front,” set Orientation Attribute to orient.

This pipeline yields procedurally varied thickness, insets, and per-face twisting fully driven by your custom VEX logic.

What performance, precision and troubleshooting techniques help with heavy or production Poly Extrude setups?

When driving a high-resolution model through multiple Poly Extrude nodes, viewport lag and memory spikes can stall iteration. To optimize, isolate your extrude to relevant polygon groups or use the Group parameter inside the node instead of prefix nodes. This reduces unnecessary calculations and keeps your network lightweight.

For precision, leverage attribute-based offsets. Create a float attribute (e.g., “extrude_amt”) per face using Attribute Create or VEX. In your Poly Extrude node, reference that attribute in the Distance field with @extrude_amt. This procedural approach ensures each face extrudes accurately and can be driven by masks or noise without manual keyframing.

• Enable Pack and Instance: After extrusion, pack geometry to lower memory footprint and accelerate viewport interaction.
• Use inline Caching: Bypass re-computation by caching heavy extrusion results with File Cache or ROP Geometry Output.
• Limit iterations: In procedural loops, control the extrude count with a detail attribute rather than hardcoding, so you can quickly dial down for previews.
• Viewport Display: Switch the Display flag to a low-res proxy or bounding box if real-time speed is critical.

Troubleshooting extrude artifacts often starts with normals. Inconsistent normals will invert faces when extruding. Insert a Normal or Facet node before extrusion to unify orientation. Use the Geometry Spreadsheet and the Group field to confirm only intended primitives are targeted. If you see gaps or overlaps, enable “Output Back” in the Facet node to visualize hidden faces and correct group assignments.