allows you to evaluate complex, user-defined mathematical expressions directly within the shader graph, effectively replacing entire trees of “Math” and “Vector Math” nodes with a single, readable formula.

simulates complex 3D surface depth on flat geometry using advanced Parallax Occlusion Mapping (POM). Unlike standard Bump or Normal mapping which only affects lighting, this node calculates actual self-occlusion and parallax shifts by ray-marching through a virtual height volume.

This node is a “Material Solver” for complex geometry. Instead of spending hours unwrapping a cliff face or a sculpted character, you can drop this node in. It analyzes the surface normal to decide which projection plane to use, blending them together where angles curve.

When texturing large surfaces like landscapes or floors, standard image textures create an obvious, repeating grid pattern that breaks immersion. The Image Tiler node uses Stochastic Hex-Tiling to eliminate these artifacts.

generates a modern Truchet tiling using curved or geometric modules that automatically connect across their borders. By dividing the surface into a grid and randomly rotating specific tile motifs (like Arcs, Triangles, or Lines), it creates visually rich, continuous pathways, mazes, and interlocking lattices. Unlike simple repetition, the random rotation creates a non-repeating “global” structure from simple “local” rules.

is an elegant coloring strategy originally developed for fractal rendering. The concept is beautifully simple yet remarkably expressive: as you iterate a function, each point traces out a path—an “orbit”—through mathematical space. Instead of simply checking whether this orbit escapes to infinity (as in traditional fractal rendering), we place geometric “traps” at strategic locations and measure how close the orbit gets to these shapes.

is a cutting-edge geometric generator, capable of creating breathtakingly complex, quasi-regular structures. Based on cutting-edge research (2024) into resonant Hamiltonian functions and weak chaos theory, it visualizes smooth 2-manifold surfaces constrained by precise symmetry groups.

is an experimental procedural generator based on Iterated Function Systems (IFS), similar to the famous “Kali Set” fractals. Unlike for example standard noise which aims for natural randomness, Magic Pattern creates highly structured, psychedelic, and kaleidoscopic intricacies.

generates a repeating star rosette with alternating filled regions and crisp geometric outlines. Based on the mathematical modeling of symmetric Islamic design (Kaplan et al., 2019), it constructs complex {k, N} star polygons by rotating a point around a circle using alternating angle steps.

is a versatile procedural generator that goes far beyond standard linear or spherical gradients. It offers 19 analytic shapes ranging from basic ramps (Linear, Quadratic, Easing) to complex radial structures (Spiral, Conical, Rings, Star).

is a geometric generator that creates tile-based structures like Grids, Checkboards, Hexagons, and Triangles. Unlike standard texture nodes which can suffer from jagged edges (aliasing) or blurring when viewed at a distance, this node uses Analytic Box Filtering.

modulates scalar values through a sequential pipeline of transforms including contrast, power curves (bias), ridge generation, posterization, and coverage-based masking. It is the essential bridge between a raw noise node and a material input, perfect for sculpting terrain heightfields, defining cloud density maps, or creating stylized artistic patterns.

the perfect companion for any Noise generator. Instead of struggling with a Color Ramp node to visualize data that goes below 0 or above 1, Noise Palette can automatically detect the input range (via Auto Range) and map it perfectly to a color scheme.

operates by evaluating the input noise against a series of ascending thresholds. Think of it as a “Quantizer” or “Band Generator.” If the noise value exceeds Threshold X, it instantly switches to Color X. This creates hard, clean edges between colors, which is perfect for creating non-blended patterns like camouflage, cell-shaded lighting, or geographic height maps.

is a “material-in-a-box.” Instead of just outputting black and white noise, it outputs a full color signal complete with lighting-independent details like dirt and grain. The Compression parameter is key—it squeezes the noise domain to create the characteristic elongated rings of cut timber.

is a procedural 3D cellular noise that generates smooth, isotropic spots by measuring the distance to the nearest randomly seeded point in space. While it shares the same underlying cellular logic as Dent Noise, Spot Noise focuses on additive layering and color blending.

a hybrid procedural pattern that sits between Worley-style feature-point noise and smoothed impulse scattering. Unlike lattice-based noises (like Perlin) that produce rolling hills, Shard Noise creates sharp, crystalline discontinuities. It uses a radially weighted, randomized impulse system with non-linear shaping (via a hyperbolic tangent function) to generate distinctive splinter-like structures and faceted geometry.

is a specialized 2D pattern generator that creates layered, anisotropic streaks of varying length, width, and curvature. By stacking multiple rotated grids of pseudo-random wavy lines, it produces dense, multi-directional networks ideal for brushed metal, microscopic wear, or damaged coating effects. Features a custom adaptive filtering engine that ensures smooth, alias-free rendering even with extremely thin lines and low sample counts.

creates spatially-coherent oscillating patterns by synthesizing collections of oriented Gabor kernels. Unlike traditional noise functions (Perlin, Simplex) that produce smooth, isotropic gradients, Phasor Noise generates controllable, oriented frequency patterns.

operates by calculating a “height field” representing the rock’s strata. The integer part of this height determines the layer, while the fractional part drives the vein gradients. This analytic approach allows for infinite resolution veins that never pixelate, with built-in controls for how much the colors bleed (Diffusion) and how sharp the layers are (Absolute).

generates stochastic patterns by summing cosine waves with randomized phases across a regular spatial lattice. These contributions are blended using a Kaiser-Bessel window function. This approach decouples spatial sampling from spectral sampling, allowing for precise, mathematically rigorous control over the texture’s frequency content (grain) and orientation (anisotropy) without the artifacts common in older noise types.

synthesizes procedurally distributed Gaussian-shaped impulses across a lattice. Each impulse contributes a localized elliptical kernel, which can be analytically rotated, scaled, and distributed. This approach allows for the creation of structured, geometric patterns (like weaves and chainmail) or highly controlled stochastic textures (like sprayed paint), all with mathematically perfect anti-aliasing.

produces a naturally isotropic 3D pattern with smooth, continuous contours reminiscent of organic cellular structures, foams, or marble veins. Built upon the mathematical “Gyroid” minimal surface function, this noise is analytic and continuous everywhere. Unlike lattice-based noises (like Perlin or Simplex), it produces no grid artifacts and features a distinct “feedback warping” mechanism that creates complex, self-intersecting organic shapes.

is a recursive domain distortion technique that generates fractal patterns by iteratively warping 3D space through implicit fold operations. Inspired by domain folding techniques (Gustavson, Ebert et al.), it progressively deforms the sampling domain itself using vector fields (sine-based, geometric, or smooth) rather than simply combining sampled frequencies. This results in coherent, flowing structures that can range from organic marble-like veins to sharp, crystalline facets.

is a procedural 3D surface imperfection generator designed to simulate tiny dents, pitting, and worn irregularities. Internally, it is a dense, inverted 3D spot noise that uses a distance-to-feature approach to carve small cavities instead of raising spots. With a smooth exponential falloff and adaptive contrast control, it produces natural micro-indentations ideal for metals, plastics, and aged surfaces, maintaining stable detail across 3D space.

is a hybrid procedural pattern generator that sits between domain-warped fBm (Fractal Brownian Motion) and cyclic trigonometric noise. Unlike traditional Perlin or Simplex noise, which rely on lattice grids or hashing, Cyclic Noise operates entirely in continuous space using sine and cosine functions.

is a dynamic, divergence-free 3D flow generator. Unlike standard noise which creates random peaks and valleys, Curl Noise produces natural, physically plausible swirling motion typical of fluid dynamics. It utilizes a quaternion-rotated fractal derivative noise (dfBm) field to compute curl vectors. It then iteratively warps the input coordinates along this stable flow.

is distinct because of its “puffy” nature. It uses an internal sigmoid contrast curve to bunch values together, creating defined “clumps” separated by transparency. It also features a unique Depth parameter that fades the noise out along the Z-axis, simulating the thinning of atmosphere at height.

is the “Swiss Army Knife” of procedural texturing. It combines four distinct noise algorithms—ranging from the original Perlin implementation to modern, high-performance variants—into a single node. Whether you need a quick terrain heightmap, a standard bump map, or a high-quality isotropic pattern without lattice artifacts, this node provides the fundamental building blocks for almost any shading task.

an advanced gradient-domain procedural texture. Unlike standard noise types that simply layer details on top of each other, Billow Noise uses the mathematical gradient (slope) of the previous layer to distort the position of the next layer. This mimics the physics of fluid advection, resulting in patterns that fold, swirl, and flow like smoke, silk, rising steam, or turbulent water.

a cellular procedural pattern derived from Voronoi (Worley) logic. Unlike standard gradient noise, it calculates the difference in density between the two “densest” feature points in a grid cell. Visually, this creates a network of creases, ridges, and pebbled shapes resembling reptile skin, cobblestones, or biological cells. It includes a built-in warping engine to distort the grid for more organic, melted, or fluid results.

performs parametric shaping operations between two values. While the standard “Math” node offers basic arithmetic, this node focuses on Thresholding and shaping.

provides a set of robust mixing methods for smoothly blending between two vectors. While a standard “Mix” node simply performs a linear average, this node offers 10 distinct mathematical curves—including nonlinear, perceptual, ratio-preserving, and spherical variants.

calculates the spatial separation or relationship between two vectors. While the standard “Distance” node only offers Euclidean length, this utility provides a comprehensive set of 5 distinct metrics: Euclidean, Manhattan, Chebyshev, Minkowski, and Cosine.

is a pure data source node. It takes no inputs and outputs a single float. It is designed to be plugged into Math, Vector Math, or Expression nodes to drive formulas with maximum precision. Using this node ensures your procedural patterns (like spirals, rotations, or phyllotaxis arrangements) are mathematically perfect.

is essential for procedurally combining masks. Because it works on Vectors, it can handle three separate masks (X, Y; Z) simultaneously. It is mathematically superior to simply multiplying or adding textures because it preserves the correct probability volume (e.g., Union avoids “over-bright” artifacts that occur when simply adding two overlapping gradients).

Rombo Tools is deeply integrated into the Cycles rendering kernel. To achieve native C++ performance and GPU acceleration (CUDA/OptiX) without the limitations of standard addons, we provide a full Custom Build of Blender. The installation process is “Portable,” meaning you do not need to run an installer wizard or have admin privileges.

This package is sold separately and it is not part of the Rombo shading tools. You can buy a standard license here : Rombo Arnold Imagers This document provides an overview of the post-processing shaders available in the Rombo Tools suites. These shaders, known as (Arnold) Imagers, are applied to the final rendered image to[…]

To download the update, log-in, then access your download page here. Introducing Rombo Sky Welcome to Rombo Tools v1.5! This major update introduces our most powerful addition yet: Rombo Sky engine – a complete volumetric sky system designed for physically-based atmospheric rendering with unprecedented flexibility and control. What sets this renderer apart is its unified[…]

Cloud Stack System Overview Rombo Sky implements an advanced Cloud Stack system that allows for the procedural generation and customization of volumetric clouds. This modular architecture enables users to create diverse cloud formations through a standardized interface that integrates seamlessly with the renderer’s volumetric ray marching system. The Cloud Stack interface consists of three floating-point[…]