Thursday, July 14th, 2016 Article by Jason Lewis

Review: Iray for 3ds Max


Iray doesn’t just come bundled with Max any more. Jason Lewis puts the new, more powerful plugin version of Nvidia’s GPU-based renderer through his real-world benchmark tests, on a range of current graphics cards.

In our first software review of 2016 – and the second part of last year’s exploration of GPU computing – we will be taking a look at Iray for 3ds Max, Nvidia’s GPU-accelerated rendering plugin. While most 3ds Max users will be familiar with Iray through the version bundled with the software, Iray for 3ds Max is part of a new line-up of separate commercial plugins, and is built for Nvidia by third-party developer Lightwork Design using its Lightworks Iray+ extensions. Other versions of the plugin are available for Maya, Revit, Rhino and Cinema 4D.

As well as looking at the software’s features, we will be putting it through a series of real-world benchmark tests using a range of GPUs: primarily Nvidia’s Quadro workstation cards, but also two of its gaming cards, and the VCA, the company’s dedicated network-attached device for GPU rendering.


Iray for 3ds Max is a member of the current breed of progressive path tracing renderers. These render in passes, each pass making the rendered image less and less noisy, making it possible to see what the finished render will look like very quickly: it’s usually possible to see the scene – or a very noisy version of it, at least – within 30 seconds or so. This allows you to iterate much more quickly to refine the look of the image; then, when the settings and scene properties are finalised, you simply allow the renderer to continue rendering passes until the noise levels have diminished to acceptable levels.

In addition to being a progressive path tracer, Iray for 3ds Max follows another recent trend: it is a hybrid CPU/GPU renderer, meaning that it will use the host system’s GPUs in addition to its CPUs, speeding up rendering calculations considerably over using the CPUs alone.

Key features

First off, let’s answer the question that everyone asks when first presented with Iray for 3ds Max: how is it different from the version of Iray that ships with the software? Unlike the version bundled with 3ds Max, which runs as an extension of mental ray, Iray for 3ds Max is an independent rendering application. It uses a completely new core architecture, and is capable of faster, higher-quality results than the older version.

Iray achieves physically correct output by tracing light paths, but being designed for ease of use, it presents the the end user with a much more simplified workflow than other path tracers. Since its main goal is photorealism, it can offer a reduced settings panel: its default settings are designed to generate photorealistic results, and scene tuning is done with materials and lights instead of render settings.


Iray for 3ds Max offers a much simpler set of render settings than most path tracers.

Many of Iray for 3ds Max’s intended users – architectural or product visualisation professionals, rather than entertainment artists – are not render junkies, and do not like having to get into the guts of their software. Accordingly, the software includes several easy-to-use native material types with presets that mimic the real-world materials commonly found in visualisation scenes. In addition to the native material types, you can also download several quite extensive material libraries from Nvidia’s website that further extend the range of surfaces that can be replicated out of the box.

One of the key features of Iray for 3ds Max is Nvidia’s new Material Definition Language (MDL). This is a standardised model for defining the various aspects of a surface and how it reacts with light in a scene. This means that materials can be shared with any other application that supports MDL, like Iray for Maya, and the final rendered output will remain consistent. According to Nvidia, you could also share a material between Iray and mental ray and again achieve consistent results.


Some of Iray for 3ds Max’s standard materials.

Another key feature of Iray for 3ds Max is its Interactive rendering mode. This is an optimised version of the final pass renderer that is meant to run in an ActiveShade window. While it isn’t as accurate as the final pass renderer, it’s very fast: it updates in near-real time, enabling you to iterate very quickly, then switch to production mode to generate your final renders.

In my experience, it works very well, but the way to get the most out of it is to have a pair of graphics cards, and at least a two-monitor setup. You can then set your secondary GPU to be the active Iray rendering card and use your primary GPU to drive 3ds Max. If you float an ActiveShade window onto your second monitor, you will be able to see your scene update while continuing to work in the main viewport. Iray’s response time when running in Interactive mode is quite good, and it doesn’t seem to affect the host application much, especially if you are running the software on a second GPU.


Iray for 3ds Max is capable of running in an ActiveShade window for fast scene previews.

Another noteworthy feature of Iray for 3ds Max is its Light Path Expressions (LPEs). These are advanced lighting layers that allow the user to adjust lighting levels in a compositing application like Nuke, Fusion or After Effects. They can be defined on a per-object or per-light basis, and are rendered in parallel. I haven’t delved into them deeply, but to judge by the demo video, they offer much more control over the look of your scene than V-Ray’s VRayLightSelect render element.

As well as its unique features, Iray for 3ds Max also offers the other functionality you would expect in a modern path tracer, including motion blur, depth of field, subsurface scattering, volumetrics and caustics.

Key limitations

Having tested Iray for 3ds Max for some time – Nvidia offers a free 90-day trial on its site, which is generous in comparison to most similar renderers – my initial impressions were quite favourable. However, no software is perfect, and Iray for 3ds Max does have its limitations.

First, while progressive path tracing renderers offer very fast initial previews of frames, they can take a long time to refine to an acceptable level of noise, especially if your scene contains a lot of reflective or refractive surfaces. This limits their use in visual effects, where many more final frames must typically be rendered than in visualisation work, with VFX studios typically preferring Reyes or Monte Carlo renderers such as RenderMan, Arnold or V-Ray. Iray for 3ds Max is one of the fastest of the progressive path tracers available today, but it still falls behind non path-tracing renderers when it comes to the speed at which it achieves final frame quality.

Second, because it has been developed as a photorealistic renderer, it is quite difficult to achieve any kind of stylisation to your renders with Iray. If you want any kind of non-photorealistic effect, you will probably have to generate it in post.

Another limitation, and one specific to the 3ds Max version, is that it does not work with most of 3ds Max’s native material and map types. For the most part, Iray’s native materials can do what Max’s native materials can do, but if you’re trying to render older scenes, you will need to recreate most, if not all, of your materials manually.

GPU rendering and graphics memory
The last point I want to address, which is common to any GPU-accelerated software, is that of memory limitations. Low-end professional graphics cards typically offer around 4GB of graphics memory, mid-end cards 6-8GB, and high-end cards 12GB. Gaming cards typically offer only half that amount: 2GB on a low-end card, 4GB in the mid range, and 6GB at the high end.

4GB may seem perfectly adequate, and for most OpenGL and DirectX applications, it is – but when it comes to GPU rendering, even 12GB is really not a lot of memory. It’s fine for small to moderately complex scenes, but once you get into complex or high-detail scenes with a lot of high-resolution textures, you can quickly eat through it. Big studios typically use 32-64GB of RAM per system in their render farms, and I have personally rendered some architectural visualisation scenes that have actively used almost 52GB of graphics RAM. Due to the nature of GPU rendering, if the scene you are trying to render exceeds the available RAM on the graphics card, the GPU will simply dump the scene and go inactive, leaving the rendering to be handled by the system’s CPUs only.

There is a trick to mitigate this, although it’s more of a Band-Aid than a complete fix. Whenever you are about to render your scene, switch your 3D application’s viewport to a simplified mode such as flat shaded, untextured, or the one I use all the time, box mode. This will free up a significant amount of GPU memory that was previously being used for the software’s G-buffer, thus increasing the amount available to the renderer.

Testing procedure

All of our benchmark tests were conducted on our faithful HP Z820 test system – now a little long in the tooth, but still a powerful performer, especially in multi-threaded applications – using a range of Nvidia’s Quadro workstation GPUs: the current-gen M6000 and M5000, and the previous-gen K5200 and K2200.

Note that the Quadro M6000 used for benchmarking was the original model with 12GB of on-board memory. Nvidia has recently released a refresh of the card with some firmware tweaks and 24GB of graphics RAM. If you’re looking to buy one of the new M6000s, I’d expect performance to remain pretty much the same, as the card’s GM200 GPU core remains unchanged, but the additional memory should enable you to render much more complex scenes without having to default to CPU-only mode.

Being CUDA-based, Iray isn’t compatible with AMD GPUs, but I’ve included CPU-only results in the benchmarks; and at the end of the results, you can read my thoughts on how it performs with Nvidia’s GeForce gaming cards.

I also ran two of the benchmark scenes on the Quadro Visual Computing Applicance (VCA), Nvidia’s dedicated network-attached storage device for GPU computing. The VCA is a rack-mounted system containing eight Quadro M6000 GPUs for a total of almost 56 Tflops of compute power. I have been told that multiple VCAs can be added to a local network and computing jobs (including Iray renders) will scale across all of them.


Nvidia’s VCA is a dedicated network-attached device for GPU computing containing eight Quadro GPUs.

Although I didn’t have direct access to a VCA (at roughly $50,000 a pop, I imagine Nvidia was wary sending them out to reviewers), I was able to log into one of Nvidia’s own VCA units remotely to do some benchmarking: while the VCA is aimed at large design and visualisation firms, smaller companies and freelancers can buy VCA time directly from Nvidia to use on its in-house units.

Benchmarking was conducted over four different runs per test scene and per GPU: the figures listed below represent the average of those four runs. You can see the poly count and lighting set-up for the scene in the benchmark graphics, along with the number of passes over which the test was run.

Benchmark results: workstation cards

Architectural interior
Our first benchmark is a demo scene provided by Nvidia: a moderately complex architectural interior.


Right off the bat, we can see that Iray for 3ds Max is meant to be run on a GPU rather than a CPU, as indicated by the long CPU-only render time. Even on a 16-core system like the Z820, enabling CPU rendering alongside the GPU only decreases render times by a minute or so.

When it comes to the individual GPUs, the Quadro M6000 takes the lead, followed by the Quadro M5000, then the Quadro K5200, and lastly the Quadro K2200. You can see how performance scales when using multiple GPUs: together, the M6000 and M5000 give significantly shorter render times than the M6000 alone.

Next, we have another demo scene provided by Nvidia: a simpler studio scene of a pair of headphones.


The result are similar to the architectural interior. The dual M6000 and M5000 come in first, then the single M6000, the M5000 and the K5200, with the K2200 last.

Ferrari garage
Next we have a much more complex interior scene, complete with a pair of high-poly Ferrari models. If you’ve read my previous reviews, you may recognise it as the scene I use for benchmarking the version of Iray that comes with 3ds Max; I have since converted it to use Iray for 3ds Max materials, lights, and render settings.


Again, the dual M6000 and M5000 take the lead, followed by the M6000, then the M5000, with the K5200 a very close third. The K2200 was unable to render this scene as it exceeded the card’s 4GB of on-board RAM.

Challenger tank
Lastly we have a studio lighting scene with a high-poly, texture-heavy Challenger 2 tank model. This scene exceeds 6 million triangles, and uses many 4K and 8K textures to really push our test graphics cards.


Once again, the dual M6000 and M5000 take first place, followed by the M6000, the M5000, and lastly the K5200. Again, the K2200 was unable to render this scene due to insufficient available RAM.

This scene is also notable in that the M6000 was the only card that was able to render the scene with 3ds Max’s viewport in shaded and textured mode. With the M5000 and K5200, the viewport had to be put into bounding box mode, freeing up GPU RAM from the G-Buffer, before either card could render the scene.

Benchmark results: games cards

Whenever I do any kind of GPU benchmarking on CG Channel, I often get asked why I only use workstation graphics cards. The short answer is that those are the cards that manufacturers are willing to provide for reviews of this type. You can read a longer discussion of the issue in this article on our reviews policy.

But I did have a chance to try out Iray for 3ds Max on a couple of Nvidia’s GeForce gaming cards – a GTX 970 and a GTX 980Ti – and I found that the GTX 970 performed similarly to the Quadro K5200 and the GTX 980Ti similarly to the Quadro M5000, with the Quadro cards having a very slight performance edge.

However, the GTX 970 has only 4GB of graphics RAM and the 980Ti only 6GB, whereas the Quadro K5200 and M5000 have 8GB. The Ferrari garage and Challenger tank scene would not render at all on the GTX 970, and the Challenger tank would only render on the 980Ti in bounding box mode with no other OpenGL or DirectX applications running.

Benchmark results: VCA

Iray for 3ds Max has functionality for remote VCA access built in, and it is quite easy to set up. After setting up your remote render in the render settings, and logging into a VCA via a simple web portal, when you hit the render button, your scene uploads to the remote VCA unit, then the VCA sends the image data back to your local PC. The render appears in the Rendered Frame Window just as if it had been rendered locally.


As you can see, the remote VCA is roughly twice as fast as a single local Quadro M6000 on the architectural interior scene, and roughly three times as fast on the system-heavy Ferrari garage scene.

The render times include the time it took to upload the scene data to the remote VCA unit. Based on the upload speed of my local internet connection, I’d estimate that 65-75% of the total is upload, meaning that VCA units on a local network should perform significantly faster.

Overall conclusions

Hardware performance
Before I discuss how Iray for 3ds Max stacks up against other renderers, let’s review how the individual graphics cards performed with it.

Among Nvidia’s Quadro workstation GPUs, the M6000 was the clear winner. Render times were typically 50-70% of those for the M5000, the next-best-performing GPU, except on the Ferrari garage scene, on which the two cards performed similarly. The interesting results are those of the older cards, with the K5200 usually coming in just a tick behind the M5000, showing that its previous-generation Kepler architecture still fares quite well with GPU compute tasks.

From a performance standpoint, the much cheaper GeForce gaming cards do quite well with Iray for 3ds Max, but their limited memory capacity makes them suitable only for rendering simple to mildly complex scenes.

Another lesson we can take away is that two (or more) really is better than one when it comes to GPU rendering. Performance in Iray for 3ds Max scales quite nicely as more GPUs are added to the host system – while the eight-GPU VCA gave the best performance of all, even when accessed remotely.

Software performance
Although I wouldn’t consider myself an expert with Iray for 3ds Max, I have spent several months putting the software through its paces, and so far, I like it. It does what Nvidia claims it does: achieve photorealistic results with a minimal amount of tweaking. It’s easy to use, produces very good results, and is quite fast for a progressive path tracer – at least, providing you have a pretty hefty GPU.

Another upside is cost. Iray for 3ds Max is available on a rental-only basis, priced at $295 for an annual subscription, making it one of the more inexpensive commercial rendering solutions available.

And while most of my testing was done in 3ds Max, I did briefly try Iray for Maya. From a performance standpoint, the two editions seem to be pretty much on a par, and the settings and scene set-up process are similar in both. If you learn how to use Iray in one, it won’t be hard to pick up the other. In addition, thanks to Nvidia’s MDL material library, the final output is pretty much the same regardless of which host application you use.

In the current war for domination among plugin renderers, I think Iray for 3ds Max can carve out a niche for itself if Nvidia markets it properly. However, it faces stiff competition from other products – notably industry veteran V-Ray and relative newcomer Corona – so it will be interesting to see where Nvidia takes the application over time.

Jason Lewis has over a decade of experience in the 3D industry. He is currently Senior Environment Artist at Obsidian Entertainment and CG Channel’s technical reviewer. Contact him at jason [at] cgchannel [dot] com

Read more about Iray for 3ds Max on Nvidia’s website


I’d like to give special thanks to the following vendors and individuals for their contributions to this article:


Sean Kilbride of Nvidia
Gail Laguna of Nvidia