Building a system isn't something that only happens at the scale of a platform or a product. It happens in a single texture, a rig, an effect, anywhere the same problem comes back more than once. Procedural thinking means recognizing that pattern early and turning it into rules instead of repeating the same manual work by hand. None of this costs aesthetics, it protects it, freeing up time for composition and feel instead of rebuilding the same mechanism again.
That kind of pattern only becomes visible by spending real time inside enough different tools, until the same shape starts showing up everywhere, in a particle graph, a texture pipeline, a piece of UI. That same familiarity is also what lightens the load on an operational team, not by managing people harder, but by understanding where the friction actually sits and removing the manual step before it ever reaches them.
That kind of thinking branches in three directions, often more than one at once:
- Reuse: a rule applied later, on something else entirely.
- Generation: a rule generating variation itself, instead of placing each piece by hand.
- Control Layer: a rule governing many parts of one delivery, at the same time.
A few structural ideas keep showing up across everything in this collection:
Object Hierarchy & Rig
Parent-child relationships held together by naming, driven by a small set of handles common in animation and beyond.
Particle Systems & Scattering
Rules governing thousands of instances at once, from environments to fluid simulation.
Node Graphs
Visual networks of connected logic, behind interaction, shaders, and geometry alike.
Control Layer
One set of parameters, centralized, governing everything built beneath it.
Node Graphs
A node graph is where the rules get written before anything moves: patience at the setup stage buys control later, letting a structure hold together under chaos instead of falling apart from it. Two very different builds, same logic underneath.
Houdini Vellum
A destruction effect built for an event: a hand-built network of forces deciding how everything breaks apart, frame by frame, without a single manual keyframe.
Unity Visual Scripting
A tile-based grid for a generic game concept, generated from two parameters, width and height. Every cell gets its own ID, so a click can toggle a wall on or off anywhere on the map.
A Tool for Terrain
This one started as a self-produced project, bringing AR into tabletop gaming. It settled on something concrete: an interactive map of a fictional city, dense enough to need real structure underneath.
Blender Script
Isolates quad-shaped buildings from a city dataset, the only geometry clean enough to extrude reliably.
Houdini Height Map
Converts the isolated data into height-mapped terrain, following the city's real elevation.
Houdini Houses on Terrain
Scatters and aligns the extruded buildings onto the generated terrain automatically.
Systems for Texture
Texture work asks the same question from a different angle: not how a structure grows, but how it's controlled once it exists.
Substance Painter Variant Console
Ghost materials, each carrying a different fill color, instanced and blended across the model's hierarchy. Change one value, and color shifts consistently across the whole object. Built for a luxury brand's rapid prototyping needs.
Substance Designer Crocodile Generator
A parametric graph generating crocodile leather as a pattern, not a fixed texture, built for a fashion brand that needed variations fast, ready to use straight in Painter.
It's the same instinct a craftsman has when they build their own tools before making anything with them. Once the rule is right, it keeps paying for itself, on whatever it touches next.
The Same Logic, in Motion
The systemic need in motion work often shows up before the brief itself is settled, when color tones and mood are still being worked out. A local brand needed a promo video for a beer launch, branding and the spot itself, animation and look handled end to end.
3ds Max Rig & Particle System
A nested null hierarchy controlling multi-axis rotation across every moving part, feeding a procedural particle system that generates the surface drops rather than placing them by hand.
Phoenix Liquid Simulation
The liquid itself: beer settling inside the bottle while a full fluid simulation spins a vortex of liquid around it, feeding into the same nested hierarchy.
Render Passes
The render split into granular layers, color, reflection, light, each isolated on its own pass so compositing can rewrite the rules on any single one later, without touching the rest.
After Effects Compositing
Nested compositions wired to dedicated control consoles: background color and reflections, reflection intensity, bloom, focus, each adjustable instantly without touching a single layer underneath.
That granularity is what makes the control layer possible in the first place: once a pass is isolated, a single console can rewrite the whole look without ever going back into the simulation underneath.
Prototyping in Blocks
The same instinct applies outside 3D entirely: reason in blocks, not single screens, and a button, a card, or a full pricing table gets built once and reused everywhere it's needed.
Figma is one of the fastest-growing tools in this space right now, and one of the friendliest: intuitive enough that thinking in components and variants becomes close to the default, not a discipline forced on top of the work.
That order pays off twice: it's what makes fast prototyping possible, and it's exactly the structure a developer needs to pick the file up and build from it directly.
Built this way, a Figma file stops being just a reference. Nested components and well-defined variants hold up on their own, without needing someone to interpret them first.
AI Doesn't Change the Rule
A different graph, same logic, chained this time inside Weavy.
It starts from a handful of reference images, a brand identity, a mood board, read by a Visual Pattern Extractor into a description of their pattern, palette, and mood. That description drives an Environment Generator, producing backgrounds at random that stay inside the same visual language every time.
A product then gets placed on top of any of them, and a final Fine Tuning stage adjusts lighting, cropping, and composition, without ever touching the generation upstream.
Even with AI doing the heavy lifting, the part worth building well is still the structure connecting each stage together, not the single image any one of them happens to produce. Built once, that structure runs again for every new product or campaign.
A Few Considerations
These tools are small, and none of them began with a formal request. Each came from recognizing a task that would return and choosing to solve it as a system rather than repeat it by hand.
The same thinking scales beyond the tool itself: define the logic once, and it can shape not only outputs, but the processes and teams behind them.
It's the same instinct a craftsman has when they build their own tools before making anything with them. Once the rule is right, it keeps paying for itself, on whatever it touches next.