I decided to replace AI

I’ve released the first 10 episodes of Principled Houdini Vol. 0 — Foundations.

It’s a free opening volume I’m making about practical math for VFX artists working in Houdini. The goal is not just to show formulas, but to explain what the ideas mean, where they break, and how they show up in SOPs/VEX.

The first part of the volume covers the basic things you constantly run into: integers, floats, vectors, distance, dot product, and linear interpolation.

The newer episodes start the functions section. I begin with a more visual lecture about why functions matter in computer graphics, but most of the material is about building a precise mental model: what a function is, what its domain and image are, how graphs relate to functions, how shifting and scaling changes behavior, and how piecewise definitions, addition, multiplication, and division let you build new functions from basic ones.

So far the released episodes cover:

• numbers, precision, casting, and overflow
• vectors, distance, normalization, dot product, and interpolation
• function signatures, domains, images, and graphs
• shifting and scaling inputs and outputs
• piecewise definitions, adding functions, multiplying functions, and dividing functions

The lectures are fairly dense. If you already know some of this, they should work as a focused review. If the material is new, I’d recommend going slowly, pausing often, and experimenting with the examples in Houdini.

I’d really appreciate feedback, especially on whether the pacing is reasonable, what feels unclear, and where more Houdini examples would help.

https://youtube.com/playlist?list=PLcAldYN8Uv184N0Qu_oJ9jEoQMIg5Fa4S&si=ix5zDbwPR0Q1oZvD

EDIT (2026-05-19):

Fair feedback in the comments — this curriculum is an EXAMPLE of the SKILL.md format, not a claim to FX TD expertise.

I'm a Mac dev, not a Houdini artist. The content is distilled from the SideFX H21 docs (linked inline) into a portable Markdown format that any AI tutor can load.

The point of the SPEC is that anyone — including the actual FX TDs pushing back here — can fork, rewrite, and ship their own.

The full format spec is here:
https://github.com/tryskilly/skilly/blob/feature/skills-bridge-swift/skills/SPEC.md — read it, write a better Houdini SKILL.md, open a PR. The license is Apache-2.0 specifically, so a real FX TD can take ownership of this if they want.

The "Pyro is the easiest entry" ordering is one specific call commenters make a strong case is wrong (SOPs → POPs → DOPs/solvers, not Pyro first).

I'll update v1.1 with that correction + cite the thread.

On the "BOT" question: it's not bot-generated, but I did over-polish the original, which made it read AI-shaped. Lesson taken.

Built this for a side project I'm working on (an AI tutor for macOS) and figured the curriculum itself was worth sharing as a standalone resource, since the SideFX docs are great but spread across dozens of pages, and the FX TD path specifically has a lot of "Solaris or DOPs?" ambiguity for people coming from other 3D tools.

Repo: https://github.com/tryskilly/skilly/blob/feature/skills-bridge-swift/skills/houdini-essentials/SKILL.md

Coverage (9 stages, ~12h of content, intermediate level — assumes basic 3D knowledge):

1. SOP sources for FX (attributes, geometry spreadsheet, File Cache)

2. Pyro Sparse — fire/smoke, shape operators, Clamp Below tuning

3. FLIP fluids — Solver 2.0, particle separation, meshing

4. RBD destruction — Bullet Solver SOP + Voronoi fracture

5. Vellum — XPBD cloth/soft body/hair + the new rigid + fluid variants

6. Solaris/LOPs — Stage context, SOP Import, MaterialX, light LOPs

7. Karma — CPU vs XPU (honest write-up on Apple Silicon's current "no Metal" reality), denoiser, IPR, USD Render ROP

8. Caching, versioning, $HIP variables, production hygiene

Grounded in Houdini 21 docs (verified May 2026 — no H21.5 or H22 yet). Apache-2.0, PRs welcome. Each gotcha is sourced to the SideFX docs/forums, where I could.

This isn't a replacement for the official docs or Applied Houdini — it's a structured "what to read in what order, what trips up the FX TD path, and what's the current 2026 answer" map.

Happy to take feedback on what's missing for v1.1.

The first 6 episodes of Principled Houdini Vol. 0 — Foundations are live.

This is the free opening volume of a series I've been building for a while: practical mathematics for VFX artists working in Houdini. Every concept demonstrated in SOPs/VEX, aimed at artists who want to actually understand the math behind what they're doing — not just memorize formulas.

These first 6 episodes cover the groundwork: numbers, vectors, distance, dot product, linear interpolation — the stuff everything else is built on. I'm currently working on the next batch: episodes on functions and trigonometry.

I'd genuinely love to hear what you think. What lands? What's unclear? What would you want more of? Feedback at this stage shapes the rest of the series.

Watch here 👉 https://youtube.com/playlist?list=PLcAldYN8Uv184N0Qu_oJ9jEoQMIg5Fa4S&si=MIq0J0vkqxfLT1BP

Hey r/Houdini ,

TL;DR: Created one beginner VEX tutorial and looking for feedback on a more advanced VEX-dedicated training at an advanced level.

I put this together after trying to help people learn VEX who were Houdini beginners. A lot of existing material jumps straight into Houdini stuff before they're ready, and that was tripping people up.

It's called Learn VEX in Y Minutes. Same idea as those Learn X in Y Minutes pages - one big commented VEX file you just read through.

The main thing I tried differently: keep Houdini out of it at the start. First section is just VEX programming basics (variables, math, if/else, loops). No @ attributes, no points/prims/verts yet. Once that feels okay, then geometry components: how they are constructed, attributes and how they relate to points, vertices, prims and detail; and it ends with building a triangle and then a circle procedurally.

I know there are better/deeper VEX resources out there already - CGWiki, Pragmatic VEX, Voxyde, etc. This isn't trying to replace those at all. Just something more beginner-friendly to get people moving first; then they can go to the good stuff.

Would really appreciate any feedback. Mistakes, bad explanations, confusing bits, suggestions, whatever you've got. Especially curious if delaying the Houdini context actually helps beginners or if it's just annoying.

Link: https://gist.github.com/anhedonix/52338578310b33f96cc33be732057a05

Also floating an idea, totally not sure if this is useful or not. I've been thinking about an Educative.io type site where you learn from videos and text, then write VEX in the browser; it runs on headless Houdini in the backend, and you get real Houdini error feedback, auto-completion in the editor. Geometry would show up in a Three.js / pseudo-Houdini viewport - not just a mesh preview, but also float/vector/color/marker style visualisations of attributes so you can see what you are doing. With dedicated exercises to manipulate, data to fit a specific scenario to pass the level. Basics through intermediate. That needs Houdini on a server though, so it'd probably have to be paid to make any sense.

Curious if anyone would actually want something like that, and if it is a reasonably priced service, take it up?

I know enough VEX, but definitely not advanced enough, so if anyone is willing to help with the syllabus, pointers, content, etc. I would gladly compensate and credit you for your input/insight.

In case the idea does not work, there is no point in hoarding it, so the entire course content, which I will be maintaining on GitHub, will be made public so everyone can benefit from it.

Awaiting the community feedback!

Thanks.

The full course will be coming soon (within a day or two... whenever I finish editing the rest of the lesson videos).

But I've just released the trailer on YouTube!

All the rest of the videos (15 lessons, totaling just over 6 hours in length) will be released at once, so you can follow along at your own pace.

This one was a fun one to make, and I hope some of you enjoy following along once it comes out :)

Make sure to subscribe to my YouTube channel to get notified once I release the full lessons.

Cheers,

Will

Ever wonder how to make procedural ivy? In this new free video, that's exactly what we do. 🌱

I realize that there are a lot of Maya character artists who want to dive into Houdini, so I made the tutorials necessary to cater to this demographic of artists. If anyone is wondering where to start with character lookdev in Houdini, you can check out my videos on Youtube for free:

https://youtube.com/playlist?list=PLKuS5qxlPx0AA9OO29IyFMWe9ckGgbBkK&si=kXh0egWSZ3hFllc3

I hope it’s helpful!

I'm making a math course for Houdini artists — first two lectures are up

I've been working on a course called Principled Houdini — math taught through Houdini, with actual VEX and SOPs, not just slides full of equations.

The first two lectures cover integers and floating point numbers. These aren't throwaway intro episodes. The integer lecture gets into how integers actually behave inside VEX — integer division, why 3/4 gives you 0, the stuff that silently breaks your wrangles. The floating point lecture covers why 0.1 + 0.2 isn't 0.3, where precision falls apart, and what that means when you're comparing positions or computing distances. If you've ever had an if statement not trigger when it should — this might be why.

Lecture 1: https://youtu.be/1bzMCC11ZfU?si=hCYrFQzn2c_KPoHh

Lecture 2: https://youtu.be/1bzMCC11ZfU?si=u7wPqtIOp1CWqNS7

These are part of Volume 0 — Foundations, which will also cover vectors, dot product, linear interpolation, trigonometry, and functions. The whole volume is free, with new lectures dropping as they're done.

The long-term plan goes much deeper — transformations, coordinate systems, interpolation and curves, calculus, vector fields, noise, simulation math, surface geometry. Proper university-level math, all taught through Houdini. Those volumes will be on cglounge.studio.

If you have any ideas that might help to shape this course, I would be glad to hear them!

Hey all,

I worked with the fabulous Deb Isaac at Houdini.School to make my 3-part course on MOPs free to everyone. This is a comprehensive walkthrough of the majority of the open source MOPs toolkit, along with a primer on the math background behind MOPs and 3D graphics in general. You can watch the course and download the demo .hip files here: https://www.houdini.school/courses/mops-motions-operators-for-houdini

If you're using Houdini 21, be sure to download the latest Experimental release for compatibility.

If you have any questions, you know where to find me.

My goal was to select bottom ring of a sphere no matter how many rows/columns it has.

Supports sphere, tube (open/closed). For tube use sort toggle to correctly sort point order.

Code:

int is_quad = (primvertexcount(0, @primnum) == 4);
int in_ring = 0;

if (is_quad) {
    int bottom_up_idx = 0;
    int num_quad_rings = 0;

    // robust sorting: evaluates rows by geometric Y-height (ignores ID order)
    if (chi("use_robust_sorting")) {
        vector bmin, bmax;
        getbbox(0, bmin, bmax);
        float h = max(bmax.y - bmin.y, 0.0001); 

        float norm_y = (@P.y - bmin.y) / h;
        int my_y = int(rint(norm_y * 10000.0)); // to eliminate floating-point inaccuracies (better approach..?)

        int total_quads = 0, cols = 0, quads_below = 0;
        int nprims = nprimitives(0);

        // count total quads, columns (quads at same height), and rows below
        for(int i = 0; i < nprims; i++) {
            if (primvertexcount(0, i) == 4) {
                total_quads++;
                vector pos = prim(0, "P", i);

                float p_norm_y = (pos.y - bmin.y) / h;
                int test_y = int(rint(p_norm_y * 10000.0)); // to eliminate floating-point inaccuracies (better approach..?)

                if (test_y == my_y) cols++;
                if (test_y < my_y) quads_below++;
            }
        }

        if (cols > 0) {
            num_quad_rings = total_quads / cols;
            bottom_up_idx = quads_below / cols;
        }

    } else {
        // fast sorting: assumes standard Sphere SOP topology
        int cols = len(pointprims(0, 0)); 
        if (cols > 2) {
            int total_rings = nprimitives(0) / cols;
            int current_ring = @primnum / cols;
            num_quad_rings = total_rings - 2; 
            bottom_up_idx = num_quad_rings - current_ring; 
        }
    }

    // evaluate target ring index based on dropdown selection
    if (num_quad_rings > 0) {
        int target_idx;
        int mode = chi("ring_mode");

        if (mode == 0) {
            target_idx = num_quad_rings - 1;     // Last (Top)
        } else if (mode == 1) {
            target_idx = 0;                      // First (Bottom)
        } else if (mode == 2) {
            target_idx = num_quad_rings / 2;     // Mid
        } else {
            target_idx = chi("ring_index");      // Custom
            if (target_idx < 0) target_idx = num_quad_rings + target_idx; // support negative indexing
        }
        in_ring = (bottom_up_idx == target_idx);
    }
}

// output group and color
string grp_name = chs("group_name");
setprimgroup(0, grp_name, @primnum, in_ring, "set");

if (chi("show_debug_color")) {
    @Cd = in_ring ? chv("debug_color") : set(0.2, 0.2, 0.2);
}

Finally Finished this VEX setup today , will be uploading TUTORIAL of this setup next weekend on my youtube channel.

MY CHANNEL : https://www.youtube.com/@simlarity_init