This node is used to set various global attributes that control the rendering of the scene.



Called Camera (AA) Samples in the plugins.

Supersampling control over the number of rays per pixel that will be traced from the camera. The higher the number of samples, the better the anti-aliasing quality, and the longer the render times. The exact number of rays per pixel is the square of this value. For example, a Camera (AA) samples value of 3 means 3x3 = 9-pixel samples. In practice, you may consider using a value of 4 for medium quality, 8 for high quality, and (rarely) 16 for super-high quality. This control acts as a global multiplier of all the different rays, multiplying the number of diffuse and specular rays. Motion blur and depth of field quality can only be improved by increasing Camera (AA) samples.

Camera (AA) samples multiply diffuse, specular, and light samples after being squared. For example, 6 Camera (AA) samples and 6 specular samples = 62 x 62 = 1296 rays per pixel for the diffuse, and another 1296 rays per pixel for the indirect specular. Therefore when you increase the Camera (AA) samples to get better geometric anti-aliasing, you should decrease the others to compensate.


The AA_seed by default is set to the current frame number, so the noise changes at every frame, like film grain. This can be locked so that the sampling noise won't change.


If enabled, this control will clamp pixel samples to this specified maximum value. This can make it easier to anti-alias certain high-dynamic-range effects such as bright motion-blurred specular streaks (at the cost of reduced contrast). What is clamped is the resulting output value of the renderer computations of each pixel sample. Example: If the max_clamp_value is set to 2, no pixels will have an RGB value greater than 2.0, 2.0, 2.0


With this control enabled the pixel samples of the AOVs will also be clamped. AOV clamping will affect every RGB and RGBA (except the A component) AOV. Currently, there is no way to tell Arnold which AOV's to clamp and which ones to preserve.


The number of threads used for rendering. Set it to zero to autodetect and use as many threads as cores in the system. Negative values indicate how many cores not to use, so that -3, for instance, will use 29 threads on a 32 logical core machine. Negative values are useful when you want to reserve some of the CPU for non-Arnold tasks.


Adjusts the priority of the render threads.


Arnold can pin threads on Linux, so they don't jump between multiple processors. This can improve scalability in modern machines, multiple processors. It can be set to off, on, or auto. By default is set to auto, meaning that if the number of threads is more than half the number of logical cores on the machine, Arnold will pin the threads.

If client code, for instance, a custom shader, spawn their own threads manually (with pthread_create or similar), these threads will inherit the same thread affinity, which totally breaks the point of spawning threads; in these situations, they can either set options.pin_threads to off, or they can create their threads with the Arnold API AiThreadCreate() which will un-pin the created thread.


Rendering will abort as soon as an error is detected. This is the recommended setting. In general, you should not ignore important error messages, or you'll risk crashes, rendering artifacts, and undefined behavior.


If set, rendering will stop if the license is not detected when the render begins.


Switch this on to avoid taking an Arnold license from the license server. This will always render your image with a watermark.


The color to display if there is an error reading a texture or it doesn't exist.


The color to display if the pixel returned to the render is a NaN (Not a Number).


The color to display if there is a problem with the assigned shader or no shader is assigned.


A string array that associates AOVs (Arbitrary Output Variables) with corresponding output drivers and filters. The syntax for an output line is the following:

  • "[camera] AOV_name AOV_type filter driver [layer_name] [HALF]" # for a regular driver
  • "[camera] driver" # for a raw driver


  • camera: camera the AOV will be rendered from (optional).
  • AOV_name: the name of the registered AOV that will be output.
  • AOV_type: the Arnold type for the AOV (RGBA, FLOAT, etc).
  • filter: the filter node that will be applied to the AOV samples to generate pixel values.
  • driver: the driver node that the AOV will be piped to. EXR drivers can support multiple outputs.
  • layer_name: an optional layer name that will be used to output the AOV. This is useful when the same AOV is filtered with different filters, and you need both versions in the output file.
  • HALF: an optional tag to use half float in the output layer.


The string array of light path expressions (LPEs), to be used as AOVs in the outputs array. Each string should contain the name of the LPE followed by the expression.



A list of shaders can be defined that will be evaluated after the regular surface shader. With this, it's possible to add shaders to set specific AOVs without modifying the original shader tree. Shaders intended for this purpose should add a booleanmetadata named aov_shader on the node itself, as a user-interface hint. If options.atmosphere or options.background are set, these global AOV shaders will also be run for atmosphere and background contexts.


The horizontal resolution of the rendered image.


The vertical resolution of the rendered image.

region_min_x, region_min_y, region_max_x, region_max_y 

These define the crop region that will be rendered. The default values will render the full resolution, or the region (0, 0) to (xres - 1, yres - 1). You can use this attribute to crop the render region or force the render to render additional pixels (overscan)


This sets the pixel aspect ratio defined as pixel height divided by pixel width. Note that this is the inverse of the way it is defined for Nuke, OpenEXR, and other applications.



The size of the image buckets. The default size is 64x64 pixels, which is a good compromise; bigger buckets use more memory, while smaller buckets may perform redundant computations and filtering and thus render slower but give initial faster feedback.


Specifies the spatial order in which the image buckets (i.e. threads) will be processed. By default, buckets start in the center of the image and proceed outwards in a spiral pattern. 


Specifies a list of buckets to use when bucket_scanning is set to list. Each element in the array corresponds to any 2d point inside the bucket you want to render next.


Ignore all textures when rendering.


Ignore all shaders when rendering, Arnold will render with a simple n_dot_eye shader instead.


Ignore atmospheric shaders. 


Ignore all light sources.


Don't perform shadow calculations.


No objects will be subdivided. This parameter is not interactive.


Displacements will be ignored. This parameter is not interactive.


Ignore bump mapping.


This can be useful for debugging problematic scenes with motion blur. When ignore motion is enabled, Arnold will use the geometry state defined by the reference_time parameter (located in the options node as well and in the range of 0-1). 



Ignores all motion keys.


Ignore depth of field computation.


Polygon normals will not be smoothed, resulting in a faceted appearance. This parameter is not interactive.


Ignore subsurface scattering.


Ignore operators.



Nodes in this list are ignored. For example, the following would skip creation of Lambert, Standard Surface and curves shaders:

ignore_list 3 1 STRING lambert standard_surface curves



The number of allowed transparency hits. With 0 objects will be treated as opaque. The example below consists of six glass cubes that are sitting on top of each other. Arnold returns black when there is an insufficient number of rays due to the limit imposed by the transparency_depth. Increasing this value allows more rays to pass through transparent surfaces. In this case, a transparency_depth of 12 is enough to get a good result.



The maximum number of files that the texture system keeps open at any given time to avoid excessive closing and re-opening of files when caching individual texture tiles. Increasing this number may result in slightly better texture caching performance. On the other hand, if this value is higher than the maximum number of concurrently open files supported by the operating system (e.g. Linux vs Windows), some texture lookups may fail and return red. This is set by default to 0, which means that the maximum number of texture files that can be simultaneously opened is automatically computed by Arnold using a heuristic that tries to guess what the optimal number would be for each particular machine. We expect that the majority of users will be able to leave this at 0 and get the best performance.



The maximum amount of memory to be used for texture caching. Arnold uses a tile-based cache with an LRU (Least Recently Used) type algorithm, where the least recently used tiles are discarded when the texture cache is full.


Enables useful per texture statistics, with time spent on textures queries, the amount of texture data read, memory consumption, etc.


Defines a location to search for textures.


If a texture map file is not natively mipmapped (e.g. a JPEG file), enabling this option will trigger the generation of a mipmap on demand. The output will be stored in memory and put in the global texture cache. This mipmap generation increases render time, especially for scenes with many high-resolution textures. To avoid this performance slowdown, it is recommended to use texture file formats that natively support mipmapping (such as TIFF and EXR), where the mipmaps are preprocessed before the render and stored in the file. This preprocessing can be done with the maketx utility.

Disabling 'options.texture_automip' will result in unfiltered non-mipmapped textures.


If a texture map file is stored in scanline mode (e.g. a JPEG file), enabling this option will trigger the generation of tiles on demand. The output will be stored in memory and put in the global texture cache. This process increases render time, especially for scenes with many high-resolution textures. To avoid this performance slowdown, it is recommended to use texture file formats that natively support tile mode (such as TIFF and EXR). You can create tile textures with the maketx utility.


High-resolution untiled texture maps are very inefficient to render because they must be loaded entirely into memory as soon as the renderer needs to access the first texel. When this flag is disabled, any attempt at loading an untiled file will produce an error and abort the renderer.


High-resolution unmipped texture maps are very inefficient to render because the highest resolution level must be loaded into memory regardless of the distance rather than a lower resolution level. When this flag is disabled, any attempt at loading an unmipped file will produce an error and abort the renderer.


When opening or reading a tile from a texture fails, Arnold's texture system will pause and try again, up to the texture_failure_retries value before returning a failure. This is meant to address spooky disk or network failures. The default is zero, meaning that failures of open or tile reading will immediately return as a failure.


Determines the texture filter width policy. It will err on the side of softer texture look-up


texture_max_sharpen is used to improve the quality of textures so that they do not appear blurry. As texture_max_sharpen is increased, textures lookups occur from higher-res mipmap levels. The theoretical optimal value of texture_max_sharpen is to set it to AtOptions::AA_samples. The reason we do not have it set to this by default is that querying the higher-res mipmap levels also results in an increase in texture data that must be read into Arnold. This can be an issue when there are GBs of textures being read in. Instead, we allow the tradeoff for slightly blurrier textures to be used in exchange for substantial savings in texture data read. The default setting of texture_max_sharpen=1 will often appear slightly blurry. Setting it to around 1.5 will result in significantly sharper textures which in most cases are almost indistinguishable from the optimal setting. In some situations, even higher quality textures might be required and so higher values should be used. Since using a value larger than AtOptions::AA_samples is not a good idea since aliasing will occur, we clamp values larger than this to AA_samples. This can be used to your advantage if you always want the highest quality settings to be used; just set texture_max_sharpen to an extremely large value, such as 9999, so that it will always end up being clamped down to AA_samples.


The name of the camera to be used for rendering.


The camera to use when determining subdivision levels of patches during adaptive subdivision. When enabled, the user provides a specific camera that will be used as a reference for all dicing (subdivision) calculations during Adaptive Subdivision (in other words, the tessellation of the object will not vary as the main camera is moved). This can be useful to fix objectionable flickering introduced by Adaptive Tessellation with certain moves of the main camera. If you set a static dicing camera, you will still get the benefits from Adaptive Subdivision (higher polygon detail closer to the dicing camera) while getting a tessellation that does not change from frame to frame. By default, this is disabled, and should only be used when necessary, and with a carefully chosen position for the dicing camera.

Polygon plane rendered with dicing camera (Catclark subdivision with 10 iterations)



Subdivision patches outside the view or dicing camera frustum will not be subdivided. This is useful for any extended surface that is only partially visible as only the directly visible part will be subdivided. Similarly, no subdivision work will happen if a mesh is not directly visible. This can be turned on globally by setting options.subdiv_frustum_culling true and can be turned off for specific meshes with polymesh.subdiv_frustum_ignore true.



Adds a world space padding to the frustum that can be increased as needed to minimize artifacts from out-of-view objects in cast shadows, reflections, etc. Note that motion blur is not yet taken into account and moving objects might require some additional padding.


The name of the shader to be evaluated as background for rays that don't hit any geometry.


Defines the background visibility mask.


The name of the shader to be evaluated for the global atmosphere evaluation.


Global shader override which allows you to override the shader for all objects in the scene.


Connects a color manager node such as OCIO.


The operator graph is evaluated from the operator node defined here, denoted as the target operator.



When scene_units_in_meters is written to .ass files as metadata, Arnold will automatically scale the .ass data it is read in when the units differ from the current scene units. A vector of length 1.0 in the scene will be this many meters long. E.g. for centimeters scene_units_in_meters = 0.1 and scene_units_name = "cm".

Float, vector, vector2 and matrix parameters tagged with units_autoscale metadata (with a value of length or inverse_length) will be subject to the automatic scaling. 


Specify the size of one unit in the scene relative to one real-world meter. The unit's name is for informational purposes only but can be set to e.g. "cm" when the units in meters is 0.1. 


Sets indirect specular blurring to reduce caustic noise. Setting to zero gives the most accurate but also noisy renders, while higher values blur caustics to reduce noise.


Sets a distance offset for shadow rays to prevent a light becomes an occluder itself.


Raising this value can speed up rendering by allowing Arnold to ignore tracing a shadow ray for light samples whose light contribution is below a certain value. The point of low_light_threshold is to save casting shadow rays when Arnold knows that the error from not casting that ray is below a certain amount. This makes sense because below a certain threshold there will be no perceptible difference between shadowed and unshadowed areas.

Roughly, what is taken into account to discard a shadow ray is its maximum possible incoming irradiance, which is linearly related to the light's intensity and decreases with distance. The specific number will vary depending on your exposure and light intensity values, but the default value is reasonable for the default exposure/light intensity values. This will typically help more in scenes with lots of lights with a finite area of influence, like a cityscape for example. It will help much less with a single strong source of light.

You should never be able to see the boundary when this optimization kicks in. If you can see it, you need to make the threshold lower. The aim is to prune shadow rays that don't contribute to the final image

In the example below, increasing the low_light_threshold to 0.1 shows a good speedup in render time (in this case, more than twice as fast) with little noticeable difference in the image.

A slightly higher threshold can offer significant rendering speed increases without noticeably darkening the image (rollover image).


However, increasing the low_light_threshold value too much can have an adverse effect on the lighting:

The Utility shader's nlights color mode can be used to see how many lights are influencing a shading point when adjusting the low_light_threshold. 

low_light_threshold: 0 to 1. Red = all lights, blue = low values, black = no lights.


It doesn't apply the atmosphere shader in the background.


If enabled, autobump is visible in SSS. Enabling this option will take into account the effect that displacement_autobump has on the ray-traced BSSRDF's result. This helps capture the high-frequency details of the surface more accurately when using autobump.

Beware that enabling this option will triple shader evaluations with SSS, resulting in much longer render times.


A global override for the maximum polymesh.subdiv_iterations.


Russian roulette control for curves (experimental). Increasing curves_rr_start_depth from 0 to 1 and setting curves_rr_aggressive to false will cause curve shapes to be sampled in a manner that is similar to non-curve surfaces, which may bring the rendering quality per AA more in line with other surface types at the expense of increased render time.


Russian roulette control for curves (experimental). Increasing curves_rr_start_depth from 0 to 1 and setting curves_rr_aggressive to false will cause curve shapes to be sampled in a manner that is similar to non-curve surfaces, which may bring the rendering quality per AA more in line with other surface types at the expense of increased render time.  


When disabling motion blur with ignore_motion_blur, the time specified by reference_time will be used instead of the shutter open time. This time is mapped on [0,1] with 0 being shutter open and 1 the shutter closed.



The active frame when this scene was exported (default is 0). 


The frame rate in units of frames per second when this scene was exported (default is 24). 


Allows additional include search paths to be provided to OSL when compiling shaders. This option is a single string that can contain multiple search paths separated by a colon (:) or a semi-colon (;). 


Defines a location to search for procedural nodes that load ass files (or obj or ply files).



Defines a location to search for plugins such as shaders, procedural plugins that create new node types, and volume plugins. 

For example, if you load ass files from a different plugin, you may need to set the plugin_searchpath to load plugin-specific shaders (such as mtoa_shaders).



Enables automatic instancing of .ass procedurals.



Enables parallel initialization of all scene nodes.



Enables projected solid angle quad light sampler.



Enables projected solid angle point light sampler.


This value controls the number of lighting samples (direct and indirect) that will be taken to estimate lighting within a radius of the point being shaded to compute sub-surface scattering. Higher values produce a cleaner solution but will take longer to render.

Some additional noise in indirect specular and diffuse GI originating from an object with SSS is expected, in particular, if diffuse samples is set lower than the SSS samples setting. To combat this type of noise you can try using higher Camera (AA) settings and lower specular, diffuse, and SSS sampling rates or increase the diffuse/specular samples. Increasing the SSS samples will only make the subsurface effect have less noise in-camera, specular reflection, and transmission rays.

In the images below you can see that there is noise in the darker areas of the eye socket. Increasing the diffuse samples will reduce this type of noise.


Controls the number of sample rays that get fired to compute indirect lighting of the volume. Like the other sampling rate controls (Camera (AA), light samples, diffuse samples, etc.), the number of actual samples is squared, so a setting of 3 fires 3x3=9 rays. Setting it to 0 turns off the indirect lighting of the volume. Note that indirect volume lighting is tied to the 'Volume' ray depth render option, and therefore there must be at least 1 volume bounce for indirect lighting to be computed.


Defines the maximum ray diffuse depth bounces. Zero diffuse is equal to disabling diffuse illumination. Increasing the depth will add more bounced light to the scene, which can be especially noticeable in interiors. You may notice subtle differences when increasing the diffuse bounces incrementally. For example, the top of the cube has no light on it with the diffuse set to 1, whereas it is visible with the diffuse set to 2.

Below is an example showing the dramatic difference that diffuse ray depth can have in an interior scene. Note the effect of the bounced light on the floor behind the door when rendering with ray depth 2 compared to ray depth 1 and 0.

We can see a difference in the appearance (and render time) when increasing the ray depth in the production scenes below: 

Diffuse ray depth: 1 (default). Roll over image to view 3.

The current Arnold code will only take one random sample after a split has happened in the ray tree, causing the regions behind transmission/specular reflections and diffuse to have much fewer shadow samples than those that are viewed directly by the camera. Splitting occurs after the first bounce.

Diagram showing how diffuse rays are propagated in an Arnold render.

You can see the effect that increasing the diffuse ray depth has on the number of rays per pixel and how that impacts render time by checking the render log. 

Rendering using the 'raycount' AOV shows the total number of rays that are created/traced to compute a certain pixel (diffuse, specular and shadow rays are shown). 

Images rendered using the 'builtin' raycount AOV


Defines the maximum number of times a ray can be specularly reflected. Scenes with many specular surfaces may require higher values to look correct. A minimum value of 1 is necessary to get any specular reflections. 


The maximum number of times a ray can be refracted. Scenes with many refractive surfaces may require higher values to look correct. 

Glass surface with double-sided thickness.


Specifies the total maximum recursion depth of any ray in the scene (diffuse + transmission + specular <= Total).


This parameter sets the number of multiple scattering bounces within a volume (defaults to 0). This is useful when rendering volumes such as clouds for which multiple scattering has a large influence on their appearance.



Called Diffuse Samples in the plugins.

Controls the number of rays fired when computing the reflected indirect-radiance integrated over the hemisphere. The exact number of hemispherical rays is the square of this value. Increase this number to reduce the indirect diffuse noise. Remember that the diffuse sampling is done for each Camera (AA) sample, so high values for both Camera (AA) samples and diffuse samples will tend to result in slow renders.

When diffuse samples are more than zero, camera rays intersecting with diffuse surfaces fire indirect diffuse rays. The rays are fired in random directions within a hemispherical spread. Noise is introduced when there are insufficient rays to resolve the range of values from the environment.

Increasing the number of diffuse samples will increase the number of diffuse rays fired from a point: 

Indirect Diffuse Ray sampling & Indirect Diffuse Noise

The table below shows the effect of increasing the number of diffuse samples (GI_diffuse_samples) to resolve indirect diffuse noise:

Diffuse samples (GI_diffuse_samples): 1 2 4 6. Render time: 131 156 271 427

This shows the performance impact when increasing the number of diffuse samples (GI_diffuse_samples). Because indirect diffuse rays are so prevalent, this can get expensive. In this example, the performance hit from 1 to 6 samples was over 320%.  

Indirect diffuse noise

This is one of the most common causes of noise and can have a number of different sources. It manifests as granularity in the scene, usually in shadowed areas. 

There are a couple of different methods to determine indirect diffuse noise. If you've rendered AOV's you can check the indirect diffuse AOV; if noise is present in this AOV only, you can be quite certain this ray type is responsible. You can check if an area of noise is created by indirect diffuse noise by turning diffuse samples to zero; this will effectively turn off indirect diffuse. If this ray type is responsible, then the noise will disappear. If the image darkens with the indirect diffuse gone, but the noise is still present, indirect diffuse rays are not responsible for the noise.

In the example below a directional light is pointing into an enclosed space. With diffuse samples set to 0, no light can bounce off of the surfaces, and therefore there is no indirect light in the scene. Increasing the diffuse samples to 1 allows diffuse rays to bounce around the scene. However, it produces a noisy result, especially in the corners of the scene. Increasing the diffuse samples to 3 gives an improved result. It is good practice to use this value sparingly. Increase it incrementally and see if you notice any difference in the quality of the indirect diffuse component.

Remember that the diffuse sampling is done for each Camera (AA) sample, so high values for both Camera (AA) samples and diffuse samples will tend to result in slow renders.

Diffuse Surfaces Through Reflections

In scenes where you have both directly visible diffuse (bath) and diffuse visible through reflections/refractions (chrome reflection), increasing the diffuse samples will only help to improve the directly visible diffuse noise. Whereas increasing the Camera (AA) samples will improve everything uniformly (the entire image).

Diffuse samples only affect directly visible diffuse surfaces and nothing else


Controls the number of rays fired when computing the reflected indirect-radiance integrated over the hemisphere weighted by a specular BRDF. The exact number of rays is the square of this value. Increase this number to reduce the indirect specular noise (soft/blurry reflections). Remember that the specular sampling is done for each Camera (AA) sample, so high values for both Camera (AA) samples and specular samples will tend to result in slow renders.

Diagram showing how specular reflection rays are propagated in an Arnold render


In the example below the mirrored surface has a high specular_weight and specular_roughness values. In the image on the left, you can see that there are not enough GI_specular_samples and therefore there is noise in the mirror. Increasing the GI_specular_samples gives a better result.

If you reduce the number of GI_specular_samples to zero and the specular_ray_depth to zero and the noise disappears, then the noise is due to specular reflections.


Controls the number of samples used to simulate the microfacet-based transmission evaluations. Increase this value to resolve any noise in the transmission. If you switch this parameter to zero, the GI_transmission_depth to zero, and the noise disappears, you will know that the noise is due to transmission.

Diagram showing how transmission rays are propagated in an Arnold render


Specular Ray Sampling and Transmission Noise

While it is normally a straightforward matter to determine whether it is a specular reflection or transmission causing the noise, we need to confirm that specular rays are responsible for a given type of noise: If you've rendered AOV's you can check the indirect diffuse AOV; if noise is present in this AOV only, you can be quite certain this ray type is responsible. Also, you can switch the GI_specular_samples and GI_transmission_samples and specular_ray_depth types to zero in the Arnold render settings. Again, this essentially turns off specular rays. If the specular rays are responsible, the noise will disappear with this test. If the specular component disappears but the noise is still there, specular rays are not responsible.


Keeps original scene data after rendering and saving .ass file. By default some node data is discarded after conversion and compression to internal data structures, to reduce memory usage. Enabling this option disables that optimization, for applications that need to access or save this data.


Enables 2D dithered sampling.


The threshold to clamp away fireflies from indirect light samples and reduce noise. This works similarly to AA_sample_clamp but preserves specular highlights from direct lighting. Lower values result in more aggressive noise reduction, possibly at the expense of dynamic range.


This can also help with diffuse scenes when a light is very close to the ceiling/walls.


This option can be used to enable/disable the effect that the AA_samples_max and adaptive_threshold render options might have on the rendered image.




Accounts for multiple scattering between the micro facets of the surface (for both conductors and dielectrics), which is more physically-correct and reduces energy loss on reflection, especially at higher roughness settings.

Here are renders of 4 different metals (gold, copper, silver, and nickel) with roughness increasing from left to right, and multi-scatter on/off in successive rows.



Enables the "nested dielectrics" system for IOR tracking in scenes with adjacent dielectrics. Defaults to on. 




Sets the maximum amount of supersampling. It controls the per-pixel maximum sampling rate and is equivalent to the units used by AA_samples. Adaptive sampling is enabled when AA_samples_max > Camera (AA) samples and Camera (AA) samples >= 2. Scenes with a large amount of depth of field or motion blur may require higher Max. Camera (AA) values. This parameter can also help with 'buzzing' speculars and hair shading as well.

20 (default). Rollover images to view 100. Interior noise (left), motion blur noise (right).

Setting AA_samples to 1 or lower does not yet allow Arnold to calculate the measures needed for adaptive thresholding, and setting AA_samples_max to AA_samples or lower does not leave a margin for any adaptive AA samples.

Variance filter showing effect of Max. Camera (AA)


The threshold which triggers/terminates adaptive-AA. This value controls how sensitive to noise the adaptive sampling algorithm gets. Lower numbers will detect more noise. The default value (0.015) should work well for most scenes.

Variance filter showing effect of AA Adaptive Threshold



Completes the render call in multiple passes. During each of the intermediate passes, drivers that do not output to a file will be invoked after each tile has completed, which allows for display drivers to show a result whose noise progressively converges towards the result at the final Camera (AA) sample settings.

Note that this option slows down render times and increases memory usage, which is why it's only supported during interactive renders for fast preview.

Disabled (default)










Maximum mipmap resolution that will be loaded. Applied to tx files that are mipmapped EXRs.




Enables the "nested dielectrics" system for IOR tracking in scenes with adjacent dielectrics
  • No labels