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.
