What if you want to discuss generative AI in the context of Houdini?

reaction-diffusion setup in COPs that starts from a single point and spreads across the surface. I feed that pattern into Vellum to drive rest length and pressure, so wherever it reaches, the cloth wants to grow. It can’t grow outward freely, so it folds in on itself, and you get this brain-like look.

I'm finishing the solver and soon I will announce beta testing.
Are you guys intrested is something like this?

💎 More works:
→ Instagram
→ LinkedIn

Hello ! I'm learning solaris and in tuts some are using layout to put objects in scene with brushes , was it taken off by sidefx ?

KineFX often whinges when skeletons are cyclic (Hierarchy traversal failed: computeHierarchyResult.FoundCycle).

There's a good section on CGWiki to fix this, but it only works if there truly aren't cycles.

If the skeleton actually has cycles, you need to detect and repair them. I made a HDA for this purpose.

It can mark, split or remove cycles. Marking cycles can help for other graph traversal problems too.

Free download below:

https://github.com/MysteryPancake/Houdini-Fun/tree/main?tab=readme-ov-file#-hda-repair-cycles

https://www.orbolt.com/asset/MysteryPancake::repair_cycles::1.0

Hey everyone,

I’ve been working on a project called Houdini Oversimplified for a while, but I realized I never actually introduced it here.

The idea behind HOS is pretty simple: breaking down Houdini topics in a way that feels easier to follow and less intimidating. Everything in the project is free to access.

Here’s the project so far:

https://volcano-jar-f61.notion.site/HOUDINI-OVER-SIMPLIFIED-HOS-3ad392019a5e80a48678e81cb47dfbd3

I thought I’d share it here in case it’s useful to anyone. Thanks for taking a look.

From vehicle movement to rocket thrust, everything is driven by simulation in Houdini.
Early WIP — more to come.

#TeslaRoadster #TeslaRoadster2026 #HoudiniFX #SideFXHoudini #VFX #CGI #PhysicsSimulation #ProceduralAnimation #NoKeyframes #3DArtist

This is a triangulated mesh, and a subset of those edges from ConvertLine

Are you aware of some function, or node combo that could be abused to detect if a Poly has a cycle somewhere ? Without going full VEX

I'm trying to see if I can use this for a cheap Kruskal minimum spanning tree implementation without having to reimplement the data structures and algorithms that are needed to compute a MST efficiently

Maybe this is computed as a side effect of another function / op.

I just downloaded it and this is what I’m seeing. I tried deleting and reinstalling it, but that didn’t work. Does anyone know what this is? Thanks.

I am watching this tutorial https://youtu.be/J4xHdSZ-YbQ and at 6:10 he shows what the extendcurve vop does, its basically extending the lines on the frames that we have set earlier and saved as @ normalisedage attribute

I've tried to achieve this through scatter + vdb + convert + mountain as well as adding noise to the displacement, and so far it looks very far from this. Is simulation the only way to achieve something like this?

Those 2 primitives are fighting polyexpand really hard.

The template lines are the polyexpand result, and you can see that there is an extra segment, and they didn't fuse together as one prim as it should. Instead they just collide and it's breaking everything downstream.

I've tried too much tricks already to try and fix this with no success.

Also, this is the root cause of a larger problem, those are just 2 prims that I managed to identify from a larger set. I need something to find them and fix them..

Partial solution so far:

Weirdly enough, if I Reverse SOP, Prim 0 OR BOTH, it produces a correct input for polyexpand

But not if I reverse Prim 1 ....

I've uploade a MWE here:

Prims 0 and 2 from this subset:

https://github.com/alecail/houdini/blob/main/subset.bgeo

Download Raw file a on the right,

Load in Stash SOP

Polyexpand in Output: Offset Curves

Offset Value = 11

Facet Unique points / Exploded View to reveal the problem

Solution so far:

A single Reverse SOP in Reverse mode before the polyexpand

Why it works doesn't make sense to me, because if this was an orientation problem, whatever problem existed before the Reverse would , should still be there after the reverse, because I doubt the algorithms have a preference for a certain winding

Lastly, I checked this theory by Mirroring the geometry, and it's also fixing the problem for Polyexpand.

Again , it' s nonsensical. Unless it's a bug in Polyexpand SOP, found by fuzzing.

Here is the absolute minimum geo that I could produce that make polyexpand fail :

This in pointWrangle

addprim(0,"poly",array(addpoint(0, set(73, 0, 68)),addpoint(0, set(-68, 0, 73)),addpoint(0, set(-73, 0, -68)),addpoint(0, set(68, 0, -73))));

addprim(0,"poly",array(addpoint(0, set(436, 0, 8)),addpoint(0, set(280, 0, 115)),addpoint(0, set(128, 0, 2)),addpoint(0, set(284, 0, -105))));

To PolyExpand in Offset Curves, offset=40

Polypath won't fix it

One Reverse SOP fixes it.

My guess is that there is a bug in Polyexpand that has to deal with the last segment of the polygon, going from the last point to the first, as it always seems to be around that segment

This would explain why sometimes Reverse seems to fix the problem, or PolyPath, or something else, because it's somehow changing the order of the points enough for Polyexpand not to fall in that case. Just my opinion as a developer (not real estate developer, the other one).

Houdini already uses Qt for drawing UI overlays, but nor (yet) for compositional guides so I built a small Python tool that calculates the guides mathematically and uses Qt Painter to draw them directly over the viewport while respecting the camera framing and aspect ratio and packaged it into a shelftool for houdini called PhiAxis.

The idea is very simple: open it, choose your guide, check the composition, keep building your scene and move to the next stages of production. (It's not a guarantee for a great shot it's just a helper guide you maybe even want to intentionally BREAK these guides/rules for more interesting storytelling)
I also tested it against frames from films and games that clearly use these composition rules to make sure everything lines up properly.

i know there's a similar bigger tools for this but as far as i know they are paid and more complex than this one

so it's a simple/FREE/lightweight solution
It’s now available on GitHub a simple double-click installer.
Tested on Houdini 20.5 through 22.

https://github.com/abdulkarimnoah01/PhiAxis
https://github.com/abdulkarimnoah01/PhiAxis/releases/tag/v0.8.1 [PhiAxis-0.8.1.zip]

Custom central stone geometries share procedural rules, spacing, and distribution with the different style outer pave rows.

Say you have this set of buildings.

I'm looking for a way to make reasonable set of roads to connect all the buildings.

This is more or less a minimum spanning tree with a few additional (secondary) roads, but on which graph ?

The roads should probably to around the buildings somehow, but not through. At this point those are not city blocks.

Here are the buildings so that everybody can work on the same set:

addprim(0,"poly",array(addpoint(0, set(-102, 0, 438)),addpoint(0, set(-115, 0, 412)),addpoint(0, set(-46, 0, 377)),addpoint(0, set(-33, 0, 404))));

addprim(0,"poly",array(addpoint(0, set(-774, 0, 431)),addpoint(0, set(-758, 0, 457)),addpoint(0, set(-825, 0, 496)),addpoint(0, set(-840, 0, 470))));

addprim(0,"poly",array(addpoint(0, set(-503, 0, -512)),addpoint(0, set(-475, 0, -534)),addpoint(0, set(-453, 0, -513)),addpoint(0, set(-507, 0, -458)),addpoint(0, set(-545, 0, -441)),addpoint(0, set(-564, 0, -464))));

addprim(0,"poly",array(addpoint(0, set(311, 0, -365)),addpoint(0, set(241, 0, -332)),addpoint(0, set(228, 0, -359)),addpoint(0, set(223, 0, -390)),addpoint(0, set(295, 0, -418)),addpoint(0, set(305, 0, -390))));

addprim(0,"poly",array(addpoint(0, set(243, 0, -213)),addpoint(0, set(209, 0, -281)),addpoint(0, set(235, 0, -295)),addpoint(0, set(270, 0, -226))));

addprim(0,"poly",array(addpoint(0, set(-233, 0, -140)),addpoint(0, set(-222, 0, -62)),addpoint(0, set(-240, 0, -38)),addpoint(0, set(-309, 0, -83)),addpoint(0, set(-312, 0, -114)),addpoint(0, set(-252, 0, -163))));

addprim(0,"poly",array(addpoint(0, set(464, 0, -492)),addpoint(0, set(459, 0, -462)),addpoint(0, set(383, 0, -474)),addpoint(0, set(388, 0, -504))));

addprim(0,"poly",array(addpoint(0, set(-541, 0, -158)),addpoint(0, set(-543, 0, -188)),addpoint(0, set(-466, 0, -191)),addpoint(0, set(-465, 0, -161))));

addprim(0,"poly",array(addpoint(0, set(-24, 0, -361)),addpoint(0, set(-6, 0, -386)),addpoint(0, set(28, 0, -372)),addpoint(0, set(51, 0, -353)),addpoint(0, set(56, 0, -341)),addpoint(0, set(31, 0, -267)),addpoint(0, set(2, 0, -260)),addpoint(0, set(-20, 0, -312))));

addprim(0,"poly",array(addpoint(0, set(-250, 0, -355)),addpoint(0, set(-239, 0, -383)),addpoint(0, set(-167, 0, -354)),addpoint(0, set(-114, 0, -286)),addpoint(0, set(-135, 0, -265))));

addprim(0,"poly",array(addpoint(0, set(-434, 0, 29)),addpoint(0, set(-462, 0, 101)),addpoint(0, set(-490, 0, 90)),addpoint(0, set(-462, 0, 18))));

addprim(0,"poly",array(addpoint(0, set(32, 0, 407)),addpoint(0, set(66, 0, 319)),addpoint(0, set(95, 0, 311)),addpoint(0, set(116, 0, 386)),addpoint(0, set(55, 0, 426))));

addprim(0,"poly",array(addpoint(0, set(-307, 0, -216)),addpoint(0, set(-376, 0, -181)),addpoint(0, set(-389, 0, -208)),addpoint(0, set(-321, 0, -243))));

addprim(0,"poly",array(addpoint(0, set(390, 0, 431)),addpoint(0, set(364, 0, 376)),addpoint(0, set(310, 0, 253)),addpoint(0, set(331, 0, 232)),addpoint(0, set(386, 0, 286)),addpoint(0, set(414, 0, 352)),addpoint(0, set(420, 0, 428))));

addprim(0,"poly",array(addpoint(0, set(-410, 0, -267)),addpoint(0, set(-468, 0, -213)),addpoint(0, set(-498, 0, -215)),addpoint(0, set(-498, 0, -264)),addpoint(0, set(-494, 0, -292)),addpoint(0, set(-484, 0, -303)),addpoint(0, set(-462, 0, -324)),addpoint(0, set(-448, 0, -322)),addpoint(0, set(-425, 0, -302))));

addprim(0,"poly",array(addpoint(0, set(-566, 0, 330)),addpoint(0, set(-494, 0, 359)),addpoint(0, set(-506, 0, 387)),addpoint(0, set(-577, 0, 358))));

addprim(0,"poly",array(addpoint(0, set(66, 0, -83)),addpoint(0, set(58, 0, 13)),addpoint(0, set(29, 0, 21)),addpoint(0, set(18, 0, -17)),addpoint(0, set(8, 0, -53)),addpoint(0, set(37, 0, -91))));

addprim(0,"poly",array(addpoint(0, set(-100, 0, 507)),addpoint(0, set(-121, 0, 528)),addpoint(0, set(-176, 0, 473)),addpoint(0, set(-154, 0, 452))));

addprim(0,"poly",array(addpoint(0, set(470, 0, -288)),addpoint(0, set(496, 0, -272)),addpoint(0, set(454, 0, -208)),addpoint(0, set(429, 0, -224))));

addprim(0,"poly",array(addpoint(0, set(428, 0, -10)),addpoint(0, set(477, 0, -68)),addpoint(0, set(499, 0, -89)),addpoint(0, set(566, 0, -103)),addpoint(0, set(595, 0, -97)),addpoint(0, set(578, 0, -21)),addpoint(0, set(519, 0, 3)),addpoint(0, set(438, 0, 18))));

addprim(0,"poly",array(addpoint(0, set(97, 0, 193)),addpoint(0, set(111, 0, 269)),addpoint(0, set(81, 0, 274)),addpoint(0, set(68, 0, 198))));

addprim(0,"poly",array(addpoint(0, set(214, 0, 224)),addpoint(0, set(143, 0, 252)),addpoint(0, set(132, 0, 224)),addpoint(0, set(204, 0, 196))));

addprim(0,"poly",array(addpoint(0, set(-258, 0, 411)),addpoint(0, set(-248, 0, 439)),addpoint(0, set(-320, 0, 466)),addpoint(0, set(-330, 0, 437))));

addprim(0,"poly",array(addpoint(0, set(259, 0, 266)),addpoint(0, set(283, 0, 248)),addpoint(0, set(329, 0, 309)),addpoint(0, set(305, 0, 327))));

addprim(0,"poly",array(addpoint(0, set(82, 0, -346)),addpoint(0, set(108, 0, -362)),addpoint(0, set(149, 0, -297)),addpoint(0, set(124, 0, -281))));

addprim(0,"poly",array(addpoint(0, set(186, 0, 334)),addpoint(0, set(160, 0, 320)),addpoint(0, set(158, 0, 290)),addpoint(0, set(169, 0, 259)),addpoint(0, set(198, 0, 253)),addpoint(0, set(235, 0, 285)),addpoint(0, set(237, 0, 315)),addpoint(0, set(215, 0, 328))));

addprim(0,"poly",array(addpoint(0, set(-201, 0, -291)),addpoint(0, set(-207, 0, -261)),addpoint(0, set(-283, 0, -277)),addpoint(0, set(-276, 0, -307))));

addprim(0,"poly",array(addpoint(0, set(-455, 0, 395)),addpoint(0, set(-435, 0, 264)),addpoint(0, set(-405, 0, 261)),addpoint(0, set(-326, 0, 344)),addpoint(0, set(-326, 0, 374)),addpoint(0, set(-429, 0, 410))));

addprim(0,"poly",array(addpoint(0, set(-732, 0, -125)),addpoint(0, set(-778, 0, -159)),addpoint(0, set(-745, 0, -229)),addpoint(0, set(-718, 0, -216)),addpoint(0, set(-703, 0, -203)),addpoint(0, set(-702, 0, -126))));

addprim(0,"poly",array(addpoint(0, set(-60, 0, 358)),addpoint(0, set(-137, 0, 367)),addpoint(0, set(-140, 0, 337)),addpoint(0, set(-64, 0, 328))));

addprim(0,"poly",array(addpoint(0, set(763, 0, -104)),addpoint(0, set(746, 0, -79)),addpoint(0, set(682, 0, -121)),addpoint(0, set(699, 0, -146))));

addprim(0,"poly",array(addpoint(0, set(655, 0, 253)),addpoint(0, set(642, 0, 226)),addpoint(0, set(712, 0, 194)),addpoint(0, set(725, 0, 221))));

addprim(0,"poly",array(addpoint(0, set(-486, 0, -8)),addpoint(0, set(-508, 0, 13)),addpoint(0, set(-561, 0, -43)),addpoint(0, set(-539, 0, -63))));

addprim(0,"poly",array(addpoint(0, set(88, 0, -504)),addpoint(0, set(25, 0, -435)),addpoint(0, set(-2, 0, -421)),addpoint(0, set(-53, 0, -450)),addpoint(0, set(-49, 0, -527)),addpoint(0, set(-26, 0, -528)),addpoint(0, set(67, 0, -526))));

addprim(0,"poly",array(addpoint(0, set(754, 0, 23)),addpoint(0, set(753, 0, -7)),addpoint(0, set(830, 0, -8)),addpoint(0, set(831, 0, 22))));

addprim(0,"poly",array(addpoint(0, set(-192, 0, 46)),addpoint(0, set(-115, 0, 37)),addpoint(0, set(-112, 0, 67)),addpoint(0, set(-109, 0, 116)),addpoint(0, set(-135, 0, 131)),addpoint(0, set(-189, 0, 76))));

addprim(0,"poly",array(addpoint(0, set(526, 0, 121)),addpoint(0, set(564, 0, 54)),addpoint(0, set(590, 0, 69)),addpoint(0, set(553, 0, 136))));

addprim(0,"poly",array(addpoint(0, set(-545, 0, -378)),addpoint(0, set(-521, 0, -305)),addpoint(0, set(-549, 0, -296)),addpoint(0, set(-573, 0, -369))));

addprim(0,"poly",array(addpoint(0, set(-649, 0, -120)),addpoint(0, set(-689, 0, -186)),addpoint(0, set(-663, 0, -202)),addpoint(0, set(-623, 0, -136))));

addprim(0,"poly",array(addpoint(0, set(-517, 0, 163)),addpoint(0, set(-565, 0, 103)),addpoint(0, set(-541, 0, 84)),addpoint(0, set(-493, 0, 144))));

addprim(0,"poly",array(addpoint(0, set(284, 0, -149)),addpoint(0, set(286, 0, -119)),addpoint(0, set(209, 0, -115)),addpoint(0, set(208, 0, -145))));

addprim(0,"poly",array(addpoint(0, set(-337, 0, -407)),addpoint(0, set(-401, 0, -450)),addpoint(0, set(-385, 0, -475)),addpoint(0, set(-321, 0, -432))));

addprim(0,"poly",array(addpoint(0, set(-718, 0, 412)),addpoint(0, set(-743, 0, 428)),addpoint(0, set(-785, 0, 364)),addpoint(0, set(-756, 0, 337)),addpoint(0, set(-679, 0, 343)),addpoint(0, set(-681, 0, 373))));

addprim(0,"poly",array(addpoint(0, set(106, 0, -244)),addpoint(0, set(114, 0, -216)),addpoint(0, set(41, 0, -193)),addpoint(0, set(32, 0, -222))));

addprim(0,"poly",array(addpoint(0, set(-16, 0, -103)),addpoint(0, set(36, 0, -161)),addpoint(0, set(58, 0, -141)),addpoint(0, set(7, 0, -83))));

addprim(0,"poly",array(addpoint(0, set(-138, 0, -231)),addpoint(0, set(-139, 0, -201)),addpoint(0, set(-216, 0, -203)),addpoint(0, set(-215, 0, -233))));

addprim(0,"poly",array(addpoint(0, set(-728, 0, 199)),addpoint(0, set(-739, 0, 227)),addpoint(0, set(-811, 0, 198)),addpoint(0, set(-799, 0, 170))));

addprim(0,"poly",array(addpoint(0, set(171, 0, 383)),addpoint(0, set(201, 0, 386)),addpoint(0, set(195, 0, 462)),addpoint(0, set(165, 0, 460))));

addprim(0,"poly",array(addpoint(0, set(-331, 0, 504)),addpoint(0, set(-338, 0, 475)),addpoint(0, set(-262, 0, 459)),addpoint(0, set(-256, 0, 488))));

addprim(0,"poly",array(addpoint(0, set(-274, 0, -416)),addpoint(0, set(-330, 0, -313)),addpoint(0, set(-360, 0, -315)),addpoint(0, set(-353, 0, -392)),addpoint(0, set(-299, 0, -432))));

addprim(0,"poly",array(addpoint(0, set(-525, 0, -246)),addpoint(0, set(-585, 0, -198)),addpoint(0, set(-604, 0, -222)),addpoint(0, set(-543, 0, -269))));

addprim(0,"poly",array(addpoint(0, set(14, 0, -389)),addpoint(0, set(28, 0, -416)),addpoint(0, set(96, 0, -380)),addpoint(0, set(82, 0, -353))));

addprim(0,"poly",array(addpoint(0, set(563, 0, -403)),addpoint(0, set(533, 0, -403)),addpoint(0, set(532, 0, -480)),addpoint(0, set(562, 0, -480))));

addprim(0,"poly",array(addpoint(0, set(768, 0, 271)),addpoint(0, set(755, 0, 298)),addpoint(0, set(686, 0, 264)),addpoint(0, set(699, 0, 237))));

addprim(0,"poly",array(addpoint(0, set(-482, 0, 498)),addpoint(0, set(-516, 0, 429)),addpoint(0, set(-489, 0, 416)),addpoint(0, set(-455, 0, 485))));

addprim(0,"poly",array(addpoint(0, set(554, 0, 427)),addpoint(0, set(478, 0, 417)),addpoint(0, set(423, 0, 352)),addpoint(0, set(442, 0, 328)),addpoint(0, set(566, 0, 366))));

addprim(0,"poly",array(addpoint(0, set(-613, 0, 59)),addpoint(0, set(-594, 0, 82)),addpoint(0, set(-654, 0, 131)),addpoint(0, set(-673, 0, 108))));

addprim(0,"poly",array(addpoint(0, set(-323, 0, 261)),addpoint(0, set(-286, 0, 193)),addpoint(0, set(-260, 0, 208)),addpoint(0, set(-296, 0, 275))));

addprim(0,"poly",array(addpoint(0, set(815, 0, 289)),addpoint(0, set(786, 0, 296)),addpoint(0, set(766, 0, 222)),addpoint(0, set(795, 0, 214))));

addprim(0,"poly",array(addpoint(0, set(394, 0, 485)),addpoint(0, set(325, 0, 451)),addpoint(0, set(338, 0, 424)),addpoint(0, set(407, 0, 458))));

addprim(0,"poly",array(addpoint(0, set(155, 0, -393)),addpoint(0, set(148, 0, -422)),addpoint(0, set(223, 0, -441)),addpoint(0, set(230, 0, -412))));

addprim(0,"poly",array(addpoint(0, set(-404, 0, -424)),addpoint(0, set(-377, 0, -410)),addpoint(0, set(-413, 0, -342)),addpoint(0, set(-440, 0, -356))));

addprim(0,"poly",array(addpoint(0, set(693, 0, 84)),addpoint(0, set(719, 0, 99)),addpoint(0, set(679, 0, 165)),addpoint(0, set(653, 0, 150))));

addprim(0,"poly",array(addpoint(0, set(-187, 0, -160)),addpoint(0, set(-263, 0, -167)),addpoint(0, set(-260, 0, -197)),addpoint(0, set(-184, 0, -189))));

Hi everyone! I’d like to share a short preview of my showreel. You can watch the full reel on YouTube https://youtu.be/ifS32_6vaJU?si=QohLAwvANBQke0KB

Hi everyone!
I'm a beginner learning Houdini 22, and I've been studying the built-in Candle Flame preset by breaking down its node network and trying to understand why each operation is used.
There's a Volume Wrangle after the Pyro Solver containing this line:
f@bluezone_mask += f@flame;
From what I understand, bluezone_mask is initially created from the higher-temperature regions and is later used to control the flame's color.
I understand what the addition does and how it affects the final appearance. What I'm struggling with is the reasoning behind choosing this particular operation in the first place.
Why would an FX artist think to add flame to bluezone_mask? What makes flame a useful attribute to combine with this mask, and why addition specifically?
More generally, how do experienced Houdini artists develop the intuition to decide which attributes to combine and how to manipulate them to achieve a desired result?
I'm trying to learn how to think through these decisions rather than just memorize what individual nodes do.
I'd really appreciate any insights. Thanks!

Hey everyone! I just recently finished my Bachelor’s degree and wanted to get some feedback on my showreel (finding a job right now is very exhausting, as we all know).

I am working mostly with Houdini, but also added some Unreal projects to have a broader skillset. I'd love to go into FX/TD, but honestly literally any paying job would be great. I've also been teaching myself Python on the side to expand my technical workflows.

Any feedback, critique, or thoughts on the reel would be hugely appreciated!

I was lucky to present at today’s Houdini Hive in Tokyo. Still pretty nervous when it comes to these things. Not sure why I get asked, but happy people enjoy Houdini for games. Thanks everyone for the support. 🐥