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

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.

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.

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

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'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]

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))));

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

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 am trying to draw some hair on metahuman head

I am clicking head to plant guide groom in groom guide node and nothing is showing but when I click on group selection tool it's showing hair but not body I want to sculpt them help please

Does anyone know if the new NVIDIA RTX Spark (Windows ARM, not DGX Spark) will support Houdini, Solaris, and Karma XPU?
I’m planning to buy one for product visualization and VFX work. Will Houdini run properly on Windows ARM, and will Karma XPU be able to use its NVIDIA GPU?
Any thoughts on compatibility, potential performance, or whether it’s worth considering over a traditional RTX workstation?

Hello, I am making a simulation of cloth flowing from a shelf. I was thinking I would do it in two steps.

Firstly, simulate the cloth falling down and pull it into the shelf, so it drapes nicely. After that, do a second simulation where the cloth slowly flows out. I am using Attach to geometry constraints to move the cloth, but I am encountering problems making me question whether this setup is viable.

I managed to delete the first Attach to geometry constraints before the second simulation by overwriting the attributes. However, I don't know if I can change constraints like stiff and bend? If I use a second Configure cloth node, that would override my rest state, wouldn't it? I was hoping I could use this setup to have finer control how my cloth drapes before the main simulation without dialing it in over one large sim, but maybe I am wrong?

Hi everyone! I'm sharing SpeedTree Bridge for Houdini, a free, open-source tool I've been developing to reduce the repeated setup involved in bringing SpeedTree assets into Houdini.

Version 0.5.2 imports OBJ/FBX exports with .stmat definitions and textures, builds materials for Arnold, Redshift or Karma, and supports OBJ and Solaris/USD workflows. You can also transfer a saved .spm project through an installed SpeedTree Modeler, then update manually or after saving.

A few practical details:

• Repeated updates keep the tree object and preserve transforms, existing shader edits and downstream SOP nodes.

• Solaris setup includes material bindings, a camera, optional lighting and a renderer-specific render output.

• Karma uses MaterialX and supports CPU/XPU settings.

• Camera framing accounts for transformed tree bounds and the render aspect ratio.

• The native UI has separate General, Materials, Render and Export tabs, plus batch .stmat import.

It's MIT-licensed, with source code, downloads and installation instructions here:

https://github.com/sdomasov269-maker/SpeedTreeHoudiniBridge

English interface screenshots and a longer overview:

https://www.artstation.com/artwork/xdd3mY

Current scope: static geometry. Wind animation, Alembic and automatic displacement aren't included. Local testing is documented for Windows, Houdini 21.0.596/22.0.368 and SpeedTree Modeler 10.2. Adapters target Houdini 19–22, but older versions still need end-to-end testing. Arnold/Redshift need integrations compatible with your exact Houdini build; live .spm export needs a Modeler edition with command-line export support. Those applications and licenses aren't bundled.

I'd appreciate feedback from people using SpeedTree in Houdini, especially on material transfer and update workflows. If you find a problem, please include your Houdini build, renderer version and reproduction steps in a GitHub issue.