For those who don’t know the tool: MoonRay is DreamWorks Animation’s in-house Monte Carlo path tracer, open-sourced in 2023 under Apache 2.0. It drives DreamWorks’ film rendering pipeline and supports hybrid CPU/GPU (XPU) modes. MoonRay integrates with DCCs via its Hydra delegate (hdMoonRay) for tools such as Houdini and Katana. The project includes the Arras framework for distributed rendering and collaboration across clusters.

Light Path Visualiser Enters the Scene

The new light path visualiser in moonray_gui is the most visible change in version 2.34.0.1. It lets artists trace how rays travel through a scene, showing how light interacts with surfaces, volumes, and materials. The visualisation is colour-coded by ray type and can reveal sampling or shading inconsistencies that are otherwise invisible. It also serves as a diagnostic tool for debugging light source or material behaviour.

Platform Updates: macOS Tahoe Joins, Linux Builds Simplified

MoonRay can now build natively on macOS Tahoe, with Sonoma and Sequoia still supported. The renderer also benefits from dependency updates and inculde fixes, easing compilation on a broader range of Linux distributions. The release aligns with both VFX Reference Platform 2024 and 2025, ensuring compatibility with current production libraries and compilers.

New Features Across the Pipeline

Version 2.34.0.1 expands flexibility for lighting and shading setups. Per-lobe lightsets are now available in both vector and XPU modes, allowing finer control of multi-lobe BSDFs. Image maps gain bindable “scale” and “offset” attributes, and SceneVariables documentation for image sizing has been clarified. Performance-wise, MoonRay now shares CPU and memory affinity data between processes using shared memory, improving parallel job efficiency. Timing measurements have switched to a more efficient RDTSC-based method for NUMA [non-uniform memory access] systems, offering more stable profiling results. Artists can also now select lights and cameras for object-space transformations directly in map shaders, simplifying custom shading graph workflows.

Fixes: From Subsurface Scatter to Fisheye Crashes

A long list of bug fixes makes this release notably production-friendly. Key repairs include:

• Fixed a mesh tessellation issue in tiled renders with the FisheyeCamera.
• Resolved DwaTwoSidedMaterial artefacts caused by previous lobe lightset work.
• Corrected crashes when exceeding BSDF lobe limits or loading oversized MeshLights, which now trigger warnings instead.
• Addressed a memory usage spike in vector and XPU modes.
• Fixed missing lightset assignments in vector subsurface scattering and adjusted over-bright subsurface shading on creases.
• Corrected normal direction errors in scalar mode and improved TransformSpaceMap behaviour.
• Fixed adaptive light sampling, volume bounce contributions, and a crash in OpenImageIO 2.4.8 statistics when no images were opened.

Under the Hood: Clean-Up and Refactoring

DreamWorks also restructured several internal libraries. The noise library moved from moonshine/lib/common to moonray/lib/common, simplifying dependencies. The integrator logic for Cryptomatte was reduced in complexity, and redundant intersection path types were removed. Code clean-up continues across lib/rendering/shading, improving maintainability without changing behaviour.

Availability

MoonRay 2.34.0.1 is available now as open-source via the official repository. It can be compiled for Linux and macOS (Tahoe, Sonoma, and Sequoia). GPU rendering requires NVIDIA CUDA/OptiX or Apple Silicon.

Caution Before Production

As with any open-source renderer update, production users should validate the build and test scene compatibility before deployment in live pipelines.

The post Rays Behaving Badly No More: MoonRay 2.34.0.1 Fixes the Path first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

DreamWorks Animation quietly dropped MoonRay 2.15.0.1 on June 12, 2025 under Apache‑2.0—firming its open-source renderer credentials openmoonray.org. Termed a “major release” by originators, it unpacks a batch of studio-grade upgrades from regression tooling to renderer controls.

Developer Regression Suite—400 Visual Checks

MoonRay now includes roughly 400 automated mini-scenes and canonical image generation via its Render Acceptance Test Suite (RATS). Each config tests discrete renderer facets—cameras, lights, shading—to guard against visual regressions. Developers and TDs gain explicit, image-backed verification—critical when chasing stability in complex CG pipelines.

NUMA Support—Performance Predictability

NUMA (Non-Uniform Memory Access) affinity controls now keep CPU and memory usage on optimal sockets. This mitigates cross-node memory latency on multi-socket systems, granting predictable behaviour under heavy workloads. For render farms or high-core headless setups, it’s a substantial performance safeguard.

rdla_gui—Interactive Render Control

MoonRay adds rdla_gui, a GUI frontend for RDL API objects. It writes delta .rdla files that feed into moonray_gui, allowing on-the-fly adjustments to materials, lights and shading parameters without restarting renders. That’s real-time control for developers and compositors who hate stopping renders for trivial tweaks.

Per‑BSDF Lobe Lightsets—Material-Level Illumination

Artists now control lightsets at a per-BSDF-lobe level. In other words, separate diffuse, specular and SSS components can each respond to different subsets of scene lights—a leap forward in shading precision .

Fisheye Camera FOV Control—Native Ultra-Wide

The FisheyeCamera object now has a built-in field-of-view attribute, enabling wide-projection setups for VR and environment capture without script hacks.

TwoSidedMap—True Double-Sided Texturing

TwoSidedMap allows distinct material mappings on either face of a surface. No geometry duplication or shader gymnastics necessary—the cleanest way yet to shade foil, leaves or fabric backfaces.

---

MoonRay 2.15’s updates cover across-the-board pipeline needs—QA automation, CPU binding, parameter control, advanced shading, projection flexibility and texturing precision. That meshes with its continuous-feature-driven growth since open-source release in March 2023. Used in recent DreamWorks films like Kung Fu Panda 4 and The Wild Robot, MoonRay now offers increased focus on production resilience. Whether you’re lighting a hero, rigging motion blur, compositing in finishing or running distributed renders via Arras, these additions plug neatly into existing post‑production toolsets.

---

Production Note: This update’s core innovations—from regression testing to NUMA tuning—warrant validation in a controlled sandpit. Each system behaves differently under load; always test on non-client sequences before pushing to final.

---

In sum, MoonRay 2.15 upgrades map neatly onto pipeline pain points—testability, stability, artistic precision. For render engineers and production teams, this means fewer surprises and easier iteration. Just: test it thoroughly before hitting the final frame.

FYI: NUMA.

What is NUMA?
NUMA, or Non-Uniform Memory Access, is a computer memory design used in multiprocessor systems where memory access times vary depending on the memory location relative to the processor. It emerged as a solution to the growing performance bottlenecks in symmetric multiprocessing (SMP) systems, where all processors share the same memory bus. As core counts and memory bandwidth demands increased, traditional shared-memory architectures began to suffer from contention and latency issues. NUMA alleviates this by organizing memory into multiple nodes, each directly attached to a specific CPU socket. While any CPU can still access all memory, it’s faster to access memory on its own node than memory on a remote node.

How is NUMA used?
In production environments—especially rendering farms, simulation clusters, and large-scale compositing nodes—NUMA becomes critical for predictability and performance. NUMA-aware operating systems and applications can assign threads and memory allocations in a way that minimizes cross-node communication. For instance, a rendering process can be “pinned” to a CPU socket and its corresponding memory, avoiding costly memory hops. NUMA-aware scheduling is particularly useful in software like MoonRay, where CPU-bound workloads must remain tightly synchronized across cores. Without NUMA tuning, multi-socket systems can suffer from inconsistent frame render times, cache thrashing, and increased memory latency.

Who invented NUMA, and why?
The concept of NUMA traces back to academic and industrial research in the late 1980s and early 1990s. One of the earliest commercial implementations came from companies like Sequent, SGI, and later IBM and HP, which incorporated NUMA into high-end Unix servers. The goal was to scale up memory bandwidth and CPU concurrency without hitting the wall of a shared memory bus. Modern x86-64 CPUs from Intel and AMD now implement NUMA by default in multi-socket or chiplet-based designs. NUMA isn’t a niche architecture anymore—it’s the baseline for high-performance computing, especially in rendering, simulation, and real-time graphics workloads that rely on thread-level parallelism and predictable memory access.

The post MoonRay 2.15: Developer Joy with NUMA, GUI Control & Fisheye Finesse first appeared on DIGITAL PRODUCTION and was written by Bela Beier.

DreamWorks Animation has released version 1.7 of MoonRay, its open-source Monte Carlo ray tracing renderer. This update introduces several enhancements aimed at improving rendering workflows for digital production professionals.

New Features in MoonRay 1.7

MoonRay 1.7 introduces a new light type called PortalLight. While the official documentation lists its control attributes, portal lights in other renderers are typically used to improve global illumination in indoor scenes by guiding sampling in specific areas. This addition is expected to enhance lighting fidelity in complex scenes.

The update also adds support for the min_shadow_distance parameter, providing artists with more control over shadow rendering, particularly in scenarios requiring fine-tuned shadow detail.

In XPU mode, which leverages both CPU and GPU resources, MoonRay now accelerates both regular rays and occlusion rays for NVIDIA GPUs. This enhancement aims to improve rendering performance, especially in scenes with complex lighting and shading.

Additionally, hdMoonRay, the Hydra render delegate for MoonRay, now includes support for Cryptomatte. Cryptomatte is an industry-standard ID matte generation system that simplifies the process of creating masks for compositing. This integration is expected to streamline compositing workflows for artists using MoonRay.

A new shared memory framebuffer interface has been introduced, facilitating the transfer of framebuffer data between processes. This feature is designed to improve efficiency in rendering pipelines that require inter-process communication.

Open Moonray

Integration and Availability

MoonRay 1.7 is available for download under an open-source Apache 2.0 license. The software can be compiled from source on Linux and macOS, with build instructions provided in the online documentation. XPU mode requires an NVIDIA GPU that supports CUDA and OptiX on Linux, and an Apple Silicon processor on macOS. For more detailed information and to access the source code, visit the MoonRay GitHub repository.

The post MoonRay 1.7: DreamWorks’ Renderer Gets a Shiny Update first appeared on DIGITAL PRODUCTION and was written by Bela Beier.