To download it, log-in, then access your download page here. Others can buy v2.0 here.
Welcome to Rombo Shaders (RTOA) v2.0!
This release marks a massive improvement to Rombo Tools shading and node package. We have moved far beyond shading nodes and engineered a complete, native C++ procedural ecosystem. Designed for high-end look development and production environments, v2.0 introduces over 50 new compiled nodes (for a total of 112 nodes!) divided into distinct pipelines: Advanced Noises, Geometric Patterns, Core Math Utilities, and Color Correction.
We have eliminated the overhead, instability, and aliasing artifacts associated with traditional procedural workflows. From custom-compiled math expressions to sub-pixel filtering, v2.0 provides Technical Directors and Artists with an industrial-strength toolkit previously unavailable in standard Arnold.
The v2.0 Flagships
Rendering technologies leading the v2.0 release.
Micro Flakes
The end of flickering. Standard approaches to metallic car paint or snow rely on high-frequency noise that causes flickering during animation. Micro Flakes solves this using a Binomial probability distribution to mathematically resolve analytical micro-facets that are smaller than a single pixel. The result is 100% stable, flicker-free glints that react dynamically to scene lighting and gracefully blur into smooth specular highlights at distance.
Microflakes Docs →
Image Parallax
True Parallax Occlusion Mapping (POM). Simulates complex 3D surface depth on flat geometry by ray-marching through a virtual height volume. It calculates actual self-occlusion (shadowing) and intersection depth without the geometry cost of displacement. Crucially, it features a Smart Structure-Preserving Filter that intelligently suppresses high-frequency surface noise while preserving deep macro-structural edges, preventing the artifacting that plagues standard POM implementations.
Parallax Docs →
Math Parser
A compiler inside Arnold. The crown jewel of the v2.0 utility suite transforms your shader graph into a programmable engine. Instead of chaining dozens of unreadable Math and Vector nodes, you can evaluate complex, user-defined mathematical expressions (like: sin(x) * y + dot(N, z)) in a single text field. Unlike heavy scripting solutions, the Math Parser features a built-in compiler that translates your string into optimized bytecode before the render starts. This bytecode is executed by a lightweight, custom Virtual Machine running natively in C++ within the Arnold core. The result is pure, multi-threaded CPU performance with zero interpretation overhead, zero dynamic memory allocation during rendering, and full access to Arnold's shader globals.
Math Parser Docs →
The Procedural Ecosystem
Noise Nodes
The procedural backbone. A curated collection of classical, spectral, and physically-inspired noise functions, each tuned for production use in look development.
- Spectral & Physical: LRPN, Phasor, Gabor, Curl.
- Cellular & Worley: Alligator, Shard, Spots, SVoronoi.
- Classic & Fractal: Classic, Musgrave, Billow, Cyclic.
- Utilities: Noise Palette, Colorizer, Tweaker.
Pattern Nodes
Structured geometry. Deterministic 2D and 3D textures. Unlike noise nodes, patterns are repeatable and geometry-aware, making them ideal for architectural surfaces and stylized looks.
- Symmetry & Math: Symmetrized (Hamiltonian chaos), Magic (IFS Fractals).
- Tiling & Paths: Truchet, Islamic, Filtered (Analytic Grids).
- Shape Generation: Gradient, Trap, Knit.
Math Nodes
The wiring layer. Lightweight, friendly utility nodes designed to connect, transform and manipulate signals between shaders.
- Math Parser: String expressions compiler and evaluator.
- Vector Logic: Binary, Boolean, Distance, Interpolate, Step.
- Data Generation: Constants, Hash, Float, Rescale.
Color Correction Nodes
The grading pipeline. Handle all color manipulation tasks that sit between texture generation and final shading. Compact, focused, and designed to chain cleanly.
- Space & Tone: CC Color (RGB/HSV/HLS), CC Tonemap (ACES).
- Masking & Selection: CC Picker, CC Keyer, CC Range.
- Adjustments: CC Balance.
Improved Sky System
This release brings new upgrades to the Rombo Sky ecosystem, turning it into a fully composable atmospheric engine.
3D Quasars
Cosmic phenomena. The Quasar add-in has been completely rebuilt. Previously a 2D view-space overlay, it is now mapped directly onto the 3D sky dome. It moves correctly with your camera, fades naturally into the atmosphere like a true gaseous nebula, and supports stacking multiple instances to compose complex night skies.
Atmospheric Contrails
Add life to the sky. The new romboSkyAddinTrails module lets you render highly realistic airplane condensation trails. It simulates the high-altitude ice crystals produced by aircraft exhaust, adding scale, directionality, and a lived-in feel to your atmospheric renders.
Panoramic Renders
Bake to 8K in seconds. You can now remap the sky from pixel space to a latitude/longitude (equirectangular) panorama to export your own custom HDRIs. Because Rombo Sky features a "Deterministic" mode, you can disable the Stochastic sampler flag and render flawless 8K panoramas in under 5 seconds using just 1x1 AA and 2:1 image output ratio (manually hide scene geometry eventually).
Better support for DCCs
We improved UIs and various DCC application shader nodes categorizations, default values, and default range values, resulting in better and easier menus to consult to get the right shader node for the right task. Maya, Cinema4D, and Houdini have all received a significant boost to their user interfaces, featuring optimized attribute editor layouts and more intuitive categorization.
By streamlining the Arnold Node Graph metadata, we've reduced clutter in complex shading networks, ensuring that highly-used parameters are easily reachable while advanced technical overrides remain accessible but non-obstructive. Whether you are managing nested procedurals in Houdini or fine-tuning lookdev in C4D, the unified parameter mapping now ensures a 1:1 visual parity across all supported platforms.
A Note on Performance
Because we originally architected this procedural core for strict GPU environments (CUDA/OptiX), the C++ backend had to be ruthlessly optimized. We built it with zero dynamic memory allocation during the render loop, flat data structures, and branchless code. When you take this strict "GPU-first" code and run it on a multi-threaded CPU engine like Arnold, it absolutely flies. It maximizes cache coherency and prevents memory bottlenecks, allowing Arnold to chew through incredibly heavy mathematics (like the Math Parser or Parallax ray-marching) without the usual render-time penalties.
Ready to Render: Demo Scenes
To ensure a zero-step learning curve, v2.0 ships with a comprehensive library of production-ready Demo Scenes for many of our supported DCCs (Maya, Cinema 4D, Houdini). You don't need to read the manual to get started. Simply open a demo scene to instantly see how to construct complex materials, chain Math Parser logic, deploy MicroFlakes and setup Parallax shaders effectively. These scenes are designed to be broken apart, studied, and dropped directly into your current projects.
Download Scenes →
Industrial-Grade Docs
Powerful tools are useless if you don't know how to wield them. We threw out the standard "slider description" playbook and built a completely new documentation platform from scratch. Every node is documented with Visual Quadrant comparisons to show exactly what parameters do, Technical Deep Dives explaining the underlying mathematics (like Mikkelsen Tiling or Hamiltonian Chaos), and copy-pasteable Quick Recipes to instantly generate complex materials. It is designed to be a technical whitepaper for engineers and an instant cheat sheet for artists.
Full Docs →