<includeonly>{{#invoke:Hatnote|hatnote}}</includeonly><noinclude>{{/doc}}</noinclude>

Template:Hatnote

2026-05-15T21:31:36Z

Standingpad: Standingpad moved page Template:HatNote to Template:Hatnote without leaving a redirect

Template:Note

2026-05-15T21:30:40Z

Standingpad: Redirected page to Template:Hatnote

#REDIRECT [[Template:Hatnote]]

Module:HatNote

2026-05-15T21:29:35Z

Standingpad: Created page with "-------------------------------------------------------------------------------- -- Module:Hatnote -- -- -- -- This module produces hatnote links and links to related articles. It -- -- implements the {{hatnote}} and {{format link}} meta-templates and includes -- -- helper functions for other Lua hatnote modules...."

--------------------------------------------------------------------------------
-- Module:Hatnote --
-- --
-- This module produces hatnote links and links to related articles. It --
-- implements the {{hatnote}} and {{format link}} meta-templates and includes --
-- helper functions for other Lua hatnote modules. --
--------------------------------------------------------------------------------

local libraryUtil = require('libraryUtil')
local checkType = libraryUtil.checkType
local mArguments -- lazily initialise [[Module:Arguments]]
local yesno -- lazily initialise [[Module:Yesno]]

local p = {}

--------------------------------------------------------------------------------
-- Helper functions
--------------------------------------------------------------------------------

local function getArgs(frame)
-- Fetches the arguments from the parent frame. Whitespace is trimmed and
-- blanks are removed.
mArguments = require('Module:Arguments')
return mArguments.getArgs(frame, {parentOnly = true})
end

local function removeInitialColon(s)
-- Removes the initial colon from a string, if present.
return s:match('^:?(.*)')
end

function p.defaultClasses(inline)
-- Provides the default hatnote classes as a space-separated string; useful
-- for hatnote-manipulation modules like [[Module:Hatnote group]].
return
(inline == 1 and 'hatnote-inline' or 'hatnote') .. ' ' ..
'navigation-not-searchable'
end

function p.disambiguate(page, disambiguator)
-- Formats a page title with a disambiguation parenthetical,
-- i.e. "Example" → "Example (disambiguation)".
checkType('disambiguate', 1, page, 'string')
checkType('disambiguate', 2, disambiguator, 'string', true)
disambiguator = disambiguator or 'disambiguation'
return string.format('%s (%s)', page, disambiguator)
end

function p.findNamespaceId(link, removeColon)
-- Finds the namespace id (namespace number) of a link or a pagename. This
-- function will not work if the link is enclosed in double brackets. Colons
-- are trimmed from the start of the link by default. To skip colon
-- trimming, set the removeColon parameter to false.
checkType('findNamespaceId', 1, link, 'string')
checkType('findNamespaceId', 2, removeColon, 'boolean', true)
if removeColon ~= false then
link = removeInitialColon(link)
end
local namespace = link:match('^(.-):')
if namespace then
local nsTable = mw.site.namespaces[namespace]
if nsTable then
return nsTable.id
end
end
return 0
end

function p.makeWikitextError(msg, helpLink, addTrackingCategory, title)
-- Formats an error message to be returned to wikitext. If
-- addTrackingCategory is not false after being returned from
-- [[Module:Yesno]], and if we are not on a talk page, a tracking category
-- is added.
checkType('makeWikitextError', 1, msg, 'string')
checkType('makeWikitextError', 2, helpLink, 'string', true)
yesno = require('Module:Yesno')
title = title or mw.title.getCurrentTitle()
-- Make the help link text.
local helpText
if helpLink then
helpText = ' ([[' .. helpLink .. '|help]])'
else
helpText = ''
end
-- Make the category text.
local category
if not title.isTalkPage -- Don't categorise talk pages
and title.namespace ~= 2 -- Don't categorise userspace
and yesno(addTrackingCategory) ~= false -- Allow opting out
then
category = 'Hatnote templates with errors'
category = string.format(
'[[%s:%s]]',
mw.site.namespaces[14].name,
category
)
else
category = ''
end
return string.format(
'<strong class="error">Error: %s%s.</strong>%s',
msg,
helpText,
category
)
end

local curNs = mw.title.getCurrentTitle().namespace
p.missingTargetCat =
--Default missing target category, exported for use in related modules
((curNs == 0) or (curNs == 14)) and
'Articles with hatnote templates targeting a nonexistent page' or nil

function p.quote(title)
--Wraps titles in quotation marks. If the title starts/ends with a quotation
--mark, kerns that side as with {{-'}}
local quotationMarks = {
["'"]=true, ['"']=true, ['“']=true, ["‘"]=true, ['”']=true, ["’"]=true
}
local quoteLeft, quoteRight = -- Test if start/end are quotation marks
quotationMarks[string.sub(title, 1, 1)],
quotationMarks[string.sub(title, -1, -1)]
if quoteLeft or quoteRight then
title = mw.html.create("span"):wikitext(title)
end
if quoteLeft then title:css("padding-left", "0.15em") end
if quoteRight then title:css("padding-right", "0.15em") end
return '"' .. tostring(title) .. '"'
end

--------------------------------------------------------------------------------
-- Hatnote
--
-- Produces standard hatnote text. Implements the {{hatnote}} template.
--------------------------------------------------------------------------------

local function decorateHatnote(hatnote, options)
local function getIcon(filename)
local html = ''
if type(filename) == 'string' then
local icon = mw.html.create('span')
icon
:addClass('hatnote-icon')
:addClass('metadata')
:wikitext('[[File:' .. filename .. '|14px|link=]]')
:done()
html = tostring(icon)
end
return html
end

local container = mw.html.create('div')
container
:addClass('hatnote-container')
:wikitext(getIcon(options.icon))
:wikitext(tostring(hatnote))
:done()
return container
end

function p.hatnote(frame)
local args = getArgs(frame)
local s = args[1]
if not s then
return p.makeWikitextError(
'no text specified',
'Template:Hatnote#Errors',
args.category
)
end
return p._hatnote(s, {
extraclasses = args.extraclasses,
selfref = args.selfref
})
end

function p._hatnote(s, options)
checkType('_hatnote', 1, s, 'string')
checkType('_hatnote', 2, options, 'table', true)
options = options or {}
local inline = options.inline
local hatnote = mw.html.create(inline == 1 and 'span' or 'div')
local extraclasses
if type(options.extraclasses) == 'string' then
extraclasses = options.extraclasses
end

hatnote
:attr('role', 'note')
:addClass(p.defaultClasses(inline))
:addClass(extraclasses)
:addClass(options.selfref and 'selfref' or nil)
:wikitext(s)

-- Decorate WP hatnote to SCW standard
hatnote = decorateHatnote(hatnote, options)

return mw.getCurrentFrame():extensionTag{
name = 'templatestyles', args = { src = 'Module:Hatnote/styles.css' }
} .. tostring(hatnote)
end

return p

Template:Hatnote

2026-05-15T21:28:43Z

Render Optimization

2026-05-15T21:14:59Z

Standingpad: Add details related to unbiased volumetric rendering

Main Page

2026-05-15T20:33:58Z

Standingpad: /* Welcome! */

== Welcome! ==
This wiki is focused on housing information for Minecraft animation and rendering, from fixes for common issues, to external programs, etc.

While focused on Minecraft animation and rendering, a lot of the information here can be used for other styles of 3D art.

Please note that to reduce spam, editing is currently restricted to user accounts. Please email ''contact@standingpad.org'' to request an account for editing.

== All Categories ==
{{Special:AllPages|namespace=14}}

== All Pages ==
{{Special:AllPages}}

__NOTOC__

Render Output Format

2025-09-26T21:20:10Z

Standingpad: Add information about bitrate

Render output formats refer to file formats used to store the final [[Render Output|render output]] of a scene. This can either be in an image format, or video format.

== Recommendations ==

For the vast majority of cases, it is recommended to save the render output in an image based format, as the extra complexity of video formats<ref>Tom Scott on video compression: https://youtu.be/r6Rp-uo6HmI</ref> can cause corruption issues in the middle of a render. In addition, memory issues during a render for animation can also cause individual frames to be corrupted with their output, which for single images is easier to fix with a simple re-render.

=== Image Formats ===

In terms of image formats, lossy compression is generally discouraged, as a large amount of information and quality is lost in the compression process. In cases where heavy post-processing is not needed, common formats include [[wikipedia:PNG|PNG]] and [[wikipedia:TIFF|TIFF]]. In cases where heavy post-processing is needed, [[wikipedia:OpenEXR|EXR]] is recommended, as the extra information stored in each pixel allows for much more flexibility. It should be noted however that [[Tonemapper|tonemapping]] isn't baked into EXR outputs, so tonemapping will need to be performed in any later programs used for post-processing. As EXRs store much more information compared to other formats, lossy compression algorithms such as DWAA can be used to reduce image sizes, without losing as much in quality compared to [[wikipedia:JPEG|JPEG]].

In situations where file sizes need to be reduced (such as posting on the internet), it's best to first output to a file format of a high quality (e.g. PNG, TIFF, EXR, etc.), then convert the high quality image to a lower quality image, or to a format with lossy compression and low file sizes (e.g. JPEG, [[wikipedia:WebP|WebP]], [[wikipedia:JPEG_XL|JPEG-XL]], etc.). The main benefit of this approach is being able to convert to multiple images of varying qualities from one, high quality source image, either for the purposes of experimentation or for having different qualities for different purposes (e.g. thumbnails, banners, profile pictures, etc.). In addition, for animation, having a high quality image sequence allows for more flexibility with the final video file, allowing for easily switching between different codecs (e.g. [[wikipedia:Advanced_Video_Coding|H.264]], [[wikipedia:High_Efficiency_Video_Coding|H.265/HEVC]], [[wikipedia:AV1|AV1]], etc.), adjusting bitrate, etc.

=== Video Formats ===

When choosing a video format for turning an image sequence to a video file, two formats need to be chosen:

* The [[wikipedia:Container_format|container format]] (e.g. [[wikipedia:MP4_file_format|MP4]], [[wikipedia:WebM|WebM]], [[wikipedia:Matroska|MKV]], etc.)
* The [[wikipedia:Video_codec|video codec]] (e.g. H.264, H.265, AV1, etc)

The container format contains encoded video, audio, and additional data such as subtitles. The video codec is how the actual video is encoded to disc, and is independent of the container format. For example, an MP4 file may have video encoded in H.264, while another MP4 may have video encoded in AV1. Thus, container formats rarely matter for aspects such as file sizes, embedding on the internet, encoding/decoding speeds, etc.

With video codecs, H.264 is one of the most commonly used codecs, due to wide hardware encoding/decoding support, as well as wide support with software. However, H.264 (and by extension, H.265) is under software patents, meaning on some operating systems or programs, encoding/decoding may not be available. For example, Fedora Linux (and other Linux distribution projects based in the United States) by default doesn't include hardware encoding/decoding for H.264, and must be manually opted-in by the user<ref>https://rpmfusion.org/Howto/Multimedia</ref>. In addition, the free version of DaVinci Resolve on Linux does not include encoding/decoding for H.264 and H.265, as the license is only included in the Studio version<ref>https://documents.blackmagicdesign.com/SupportNotes/DaVinci_Resolve_20_Supported_Codec_List.pdf</ref>.

In recent years, the AV1 codec has become more widely used, due to being more efficient with file sizes and not being under patents. However, hardware encoding/decoding for AV1 isn't as widely supported, being limited mainly to newer systems.

When encoding video, the [[wikipedia:Bit_rate|bitrate]] must also be considered. Bitrate defines the amount of bits used for encoding video, generally on a per second basis. This is to some degree independent of resolution; for example, 4K video that is streamed over the internet often has a much lower bitrate than 4K video from UHD Blu-rays. A higher bitrate allows for more data can be present in the encoded video, but at the cost of increased file sizes; a lower bitrate by contrast allows for smaller file sizes, but at the cost of detail in the encoded video.

Render Output Format

2025-09-25T21:32:35Z

Standingpad: Add video codecs section to render output format page

Render Output Format

2025-09-24T23:24:02Z

Standingpad: Expanded recommendations section for render output formats

Render Output Format

2025-09-23T22:15:01Z

Standingpad: Create initial Render Output Format page

Light Tree

2025-08-27T22:13:41Z

Standingpad: Fix markup for link

Light tree is a method of sampling direct light sources that takes into account their contribution to the overall scene.<ref>https://psychopath.io/post/2020_04_20_light_trees</ref> This is usually based on a combination of factors, such as estimated intensity, distance from the camera, etc. <ref>https://docs.blender.org/manual/en/4.4/render/cycles/render_settings/sampling.html#lights</ref>

In order to improve efficiency [[Render Engine#Ray Tracing|ray tracers]] do not sample every light in the scene at once, and instead randomly sample lights. While this avoids needless calculation, random sampling of direct light sources results in additional noise. To work around this, renderers will create a light tree to approximate lighting contribution before the actual render process, and adjust the probability of each light being selected based on those results, allowing more samples to be used on lights that contribute more to the scene. This works best in scenes with larges amounts of light sources.

MiEx

2025-08-10T22:14:26Z

Standingpad: Add information about MiEx resource pack structure

MiEx is a [[World Exporter|world exporter]] that runs on Windows, macOS, and Linux, and uses the USD output. It's the primary exporter for Element Animation, who work on the Minecraft Live animations.

{{Infobox
| name = MiEx
| header1 = MiEx
| label2 = Author | data2 = Bram Stout Productions
| label3 = Website | data3 = [https://bramstout.nl/en/miex/ bramstout.nl/en/miex/]
| label4 = Source code | data4 = [https://github.com/BramStoutProductions/MiEx github.com/BramStoutProductions/MiEx]
| label5 = Supported Operating Systems | data5 = Windows, macOS, and Linux
| label6 = Last stable release | data6 = [https://github.com/BramStoutProductions/MiEx/releases/tag/v1.6.2 v1.6.2 (May 11th, 2024)]
}}

Some features of MiEx include splitting portions of the export to foreground and background, [[Render Engine#Ray Tracing|ray-tracing]] optimized exports, [[Level of Detail]], cave removal, etc.<ref>https://github.com/BramStoutProductions/MiEx/wiki/02.-Features</ref>

== Resource Packs ==

By default, MiEx exports materials using [[MaterialX]], however, it also can export materials with custom resource packs written in JSON.<ref>https://github.com/BramStoutProductions/MiEx/wiki/04.-Resource-Packs#resource-packs</ref>

=== Structure ===

{| class="wikitable"
|+ MiEx Resource Pack Folders
|-
! Folder Path !! Function
|-
| <code>assets/minecraft/blockstates</code> || Contains JSON files defining how the block state affects the model used (such as with connected grass)
|-
| <code>assets/minecraft/models</code> || Contains JSON files defining models for different blocks, including custom models for different variations
|-
| <code>assets/minecraft/textures</code> || Contains textures in the same structure as a regular Minecraft resource pack, useful for using custom resource packs or additing adding additional PBR maps
|-
| <code>material/minecraft/templates</code> || Contains JSON files defining material templates used in the final export
|}

Below is an example of a MiEx resource pack and its structure.
<nowiki>
Resource Pack/
├── assets/
│ └── minecraft/
│ ├── blockstates/
│ │ └── grass_block.json
│ └── models/
│ └── block/
│ └── grass_block_connected_sides.json
├── material/
│ └── minecraft/
│ └── templates/
│ ├── json_base.json
│ └── json_emission.json
└── miex_config.json</nowiki>

Firefly

2025-07-10T22:54:11Z

Standingpad: Create firefly page

In the context of [[Render Engine#Ray Tracing|ray tracing]], fireflies are rendering artifacts that cause pixels to be extremely bright.<ref>https://docs.blender.org/manual/en/4.4/glossary/index.html#term-Fireflies</ref> Normally this is caused by reflection and/or refraction.

Render Optimization

2025-07-09T05:05:16Z

Standingpad: Clarified sentence regarding cost of removing alpha faces

[[Category:Rendering]]
Render optimizations are methods and techniques that aim to improve render times, render quality, or sometimes a combination of both. These include modifying the behavior of the [[Render Engine|engine]] or modifying the scene itself.

== Optimizing Scenes ==

In many cases, optimizing the actual scene itself can improve render times or quality. Some of these include:

* Reducing geometry, or optimizing topology (e.g. using [[Quad|quads]] instead of [[N-gon|n-gons]])
* Reducing texture sizes (e.g. using 2K textures instead of 4K)
* Adequate routes for light paths (e.g. large gaps)
* Avoiding complex materials or adjusting materials to behave differently (e.g. [[Archviz Glass|archviz glass]])
* Reducing resolution of the final render
== Optimizing Engine Behavior ==

Often times optimizing an engine's behavior can also allow for reducing render times or scene quality. Some examples include:

* Limiting light bounces, or even approximating lighting through alternate means
* Adjusting sample count for [[Render Engine#Ray_Tracing|ray tracing]] engines, often in conjunction with [[Denoiser|denoising algorithms]]
* Adjusting shadow resolution for [[Render Engine#Rasterization|rasterized]] engines

== Software/Engine Specific Recommendations ==

The following are recommendations for specific programs or render engines. Depending on the scene, these may or may not need to be adjusted.

=== Cycles (Blender) ===

Although [[Cycles]] is one of the faster path tracing engines, there's some options that can be adjusted for performance.

==== Sampling ====

Beyond adjusting the sample count, there are alternate settings in Cycles specifically related to sampling. In particular, adjusting [[Adaptive Sampling|adaptive sampling]] settings to kick in earlier on can reduce render times, at the cost of more noise.<ref>https://docs.blender.org/manual/en/4.4/render/cycles/render_settings/sampling.html#adaptive-sampling</ref> Setting the noise threshold to <math>0.03</math> instead of <math>0.01</math> may be a good compromise of quality and render times.

Another sampling related setting in Cycles is [[Light Tree|light tree]], which reduces noise in scenes with a large amount of lights<ref>https://docs.blender.org/manual/en/4.4/render/cycles/render_settings/sampling.html#lights</ref>. Note that issues may result from overlapping area lights, though this may be a bug.<ref>https://projects.blender.org/blender/blender/issues/141576</ref>

==== Light Paths ====

Adjusting light path settings can also be another source of performance and/or quality improvement. This can be in the form of adjusting light bounces, volumetric stepping, or clamping bright pixels.

By default, Cycles sets its max light bounces to <math>12</math>, which may be excessive in many cases. Lowering to <math>8</math> often creates little to no difference, while reducing render times.

Some scenes may allow for reducing max light bounces further down to <math>4</math> or even <math>3</math>. However, it should be noted that adjustments the range of <math>1</math> to <math>5</math> typically introduce larger changes to the scene than higher ranges.<ref>[https://youtu.be/8gSyEpt4-60?t=307 Blender Guru: 18 Ways to Speed Up Cycles Rendering - Reduce Light Bounces]</ref>

<tabber>
|-|Forest Scene=
<gallery mode="packed" heights="400px">
File:Adaptive Sampling Example - Noisy Image.jpg|8 light bounces|alt=Noisy image of a forest scene
File:Adaptive Sampling Example - 4 Bounces.jpg|4 light bounces|alt=Noisy image of a forest scene
File:Adaptive Sampling Example - 3 Bounces.jpg|3 light bounces|alt=ENoisy image of a forest scene
File:Adaptive Sampling Example - 2 Bounces.jpg|2 light bounces|alt=Noisy image of a forest scene
File:Adaptive Sampling Example - 1 Bounce.jpg|1 light bounce|alt=Noisy image of a forest scene
File:Adaptive Sampling Example - 0 Bounces.jpg|0 bounces (direct light only, no global illumination)|alt=Noisy image of a forest scene
</gallery>

|-|Interior Scene=
<gallery mode="packed" heights="400px">
File:Interior Bounce Test - 8 Bounces.jpg|alt=Interior scene with 8 light bounces|8 light bounces
File:Interior Bounce Test - 4 Bounces.jpg|alt=Interior scene with 4 light bounces|4 light bounces
File:Interior Bounce Test - 3 Bounces.jpg|alt=Interior scene with 3 light bounces|3 light bounces
File:Interior Bounce Test - 2 Bounces.jpg|alt=Interior scene with 2 light bounces|2 light bounces
File:Interior Bounce Test - 1 Bounce.jpg|alt=Interior scene with 1 light bounce|1 light bounce
File:Interior Bounce Test - 0 Bounces.jpg|alt=Interior scene with 0 light bounces|0 light bounces
</gallery>
</tabber>

In addition to max light bounces, there is also stepping rate and max steps. Stepping rate defines how many "steps" is performed in a volumetric object, where lower values allow for more detail, at the cost of render time, and max steps defines how many steps Cycles will perform for volumes before giving up<ref>https://docs.blender.org/manual/en/4.4/render/cycles/render_settings/volumes.html</ref>. Depending on the scene, the default value of <math>1</math> may be excessively low, and increasing the rate may allow for performance improvements. In addition, decreasing max steps may also improve render times, at the cost of detail.

Like many path tracers, Cycles includes options to clamp the brightness of pixels caused by both direct and indirect bounces. When set to <math>0</math>, no clamping is done<ref>https://docs.blender.org/manual/en/4.4/render/cycles/render_settings/light_paths.html#clamping</ref>. While clamping direct lighting is usually not necessary, clamping indirect lighting may reduce the amount of [[Firefly|fireflies]] created when rendering. However, clamping indirect can often reduce the brightness of highlights on reflective objects.

Cycles also includes options to disable caustics.<ref>https://docs.blender.org/manual/en/4.4/render/cycles/render_settings/light_paths.html#caustics</ref> However, disabling these will drastically change lighting if a scene contains many reflective objects, and should be considered a last resort in most cases.<ref>[https://youtu.be/8gSyEpt4-60?t=1331 Blender Guru: 18 Ways to Speed Up Cycles Rendering - Clamp it]</ref>

Fast GI approximation can also improve render times<ref>https://docs.blender.org/manual/en/4.4/render/cycles/render_settings/light_paths.html#fast-gi-approximation</ref>, though it can also drastically change how a scene looks.

<tabber>
|-|Forest Scene=
<gallery mode="packed" heights="400px">
File:Adaptive Sampling Example - Noisy Image.jpg|Without Fast GI|alt=Noisy image of a forest scene
File:Adaptive Sampling Example - Fast GI after 1 bounce.jpg|Fast GI approximation after 1 light bounce|alt=Noisy image of a forest scene
File:Adaptive Sampling Example - Fast GI after 2 bounces.jpg|Fast GI approximation after 2 light bounces|alt=Noisy image of a forest scene
</gallery>
|-|Interior Scene=
<gallery mode="packed" heights="400px">
File:Interior Bounce Test - 4 Bounces.jpg|alt=Noisy image of an interior scene|Without Fast GI
File:Interior Bounce Test - Fast GI after 1 bounce.jpg|alt=Noisy image of an interior scene|Fast GI approximation after 1 light bounce
File:Interior Bounce Test - Fast GI after 2 bounces.jpg|alt=Noisy image of an interior scene|Fast GI approximation after 2 light bounces
</gallery>
</tabber>

==== Shaders ====

In Cycles, certain shaders often create additional noise in a given scene. For example, a glass shader may create additional noise due to the calculation of caustics, leading some to create workarounds (such as archviz glass).

Like glass, the emission shader is often linked to increased noise.

Alpha transparency may introduce slow down when rendering as Cycles has to execute an object's shader trace a ray when hitting a transparent portion.<ref>https://docs.blender.org/manual/en/latest/render/cycles/render_settings/light_paths.html#transparency</ref> In cases where many objects with alpha transparency overlap, such as leaves or grass, it may be beneficial to remove the transparent portions. <ref>[https://youtu.be/8gSyEpt4-60?si=yKZp6k1iYtFfiVPH Blender Guru: 18 Ways to Speed Up Cycles Rendering - Remove Alpha Transparency]</ref> However, it's possible that any performance improvement is negated by the cost any additional geometry needed to remove alpha transparent faces.

Volumetric shaders may introduce additional noise and render time.<ref>[https://youtu.be/8gSyEpt4-60?t=1931 Blender Guru: 18 Ways to Speed Up Cycles Rendering - Remove Volumetrics]</ref> In cases where volumetric shaders are used for god-rays, 2D emissive plans can make a suitable substitute.

==== Lights ====

Smaller lights (and by extension smaller beam spread values for area lights) can make it harder for samples to converge in a scene, leading to additional noise.

For a long time, light portals were a suggested method of decreasing noise in interior scenes.<ref>https://docs.blender.org/manual/en/latest/render/cycles/light_settings.html#render-cycles-lights-area-portals</ref><ref>[https://youtu.be/8gSyEpt4-60?t=458 Blender Guru: 18 Ways to Speed Up Cycles Rendering - Use Portals]</ref> However, in practice, light portals do not seem to make any difference in noise quality, both with large exterior gaps and small exterior gaps, while also slightly increasing render times. For this reason, light portals '''are not recommended''' as of Blender 3.0+. Cycles Legacy (Blender 2.61 to 2.93) may see benefits from portals, but more tests are needed.

<tabber>
|-|Large Gap=
<gallery mode="packed" heights="400px" caption="4096 samples, 0.03 noise threshold">
File:Portals Test- Nishita - No Portals.jpg|alt=Heatmap of sample count in a scene without portals|Heatmap of sample count in a scene without portals
File:Portals Test- Nishita - With Portals.jpg|alt=Heatmap of sample count in a scene with portals|Heatmap of sample count in a scene with portals. Note the lack of any major difference to the heatmap without portals
</gallery>

|-|Small Gap=
<gallery mode="packed" heights="400px" caption="4096 samples, 0.03 noise threshold">
File:Portals Test- Nishita - No Portals Small Gap.jpg|alt=Heatmap of sample count in a scene without portals and small gap|Heatmap of sample count in a scene without portals
File:Portals Test- Nishita - With Portals Small Gap.jpg|alt=Heatmap of sample count in a scene with portals and small gap|Heatmap of sample count in a scene with portals. Note the lack of any major difference to the heatmap without portals
</gallery>
</tabber>

In theory, path guiding is a more viable alternative, though only CPU rendering is supported.<ref>https://docs.blender.org/manual/en/latest/render/cycles/render_settings/sampling.html#path-guiding</ref>

==== Objects ====

To reduce memory usage, using object instancing and/or duplicating objects with shared data may reduce memory usage when rendering.<ref>[https://youtu.be/8gSyEpt4-60?t=1503 Blender Guru: 18 Ways to Speed Up Cycles Rendering - Object Instancing]</ref> This mainly benefits scenes with multiple objects that look the same/similar, such as trees in a forest, where each object doesn't have many unique features.

Adaptive subdivision and/or [[Level of Detail|LOD]] may also introduce memory savings for terrain.<ref>[https://youtu.be/8gSyEpt4-60?t=1670 Blender Guru: 18 Ways to Speed Up Cycles Rendering - Adaptive Subdivision]</ref>

MiEx

2025-07-08T03:45:33Z

Standingpad: Add link to ray tracing page

MiEx

2025-07-08T03:44:24Z

Standingpad:

2025-07-07T04:48:49Z

Standingpad: Adjust gallery max height

[[Category:Rendering]]

Adaptive sampling is an optimization technique for ray tracing in which [[Render Engine|renderers]] measure noise in the scene against a pre-defined threshold during the rendering phrase, and when met for a given area of the image, stops sampling in that area. This is based on the observation that in a given scene, certain portions of the image (such as those with flat, well-lit objects) may converge faster than other portions (such as those with more complex geometry, materials, and/or lighting).<ref>https://cs184.eecs.berkeley.edu/sp21/docs/proj3-1-part-5</ref>

<gallery mode="packed" heights="600px">
File:Adaptive Sampling Example - Noisy Image.jpg|Noisy version of a render using adaptive sampling|alt=Noisy image of a forest scene
File:Adaptive Sampling Example - Heatmap Image.jpg|Heatmap demonstrating how many samples were needed to reach the noise threshold, where darker areas represent portions that needed fewer samples to reach the threshold|alt=Heatmap of samples for image of a forest scene
</gallery>

Adaptive sampling works best with a high amount of fixed samples and a noise threshold that isn't low enough to not cause sampling to stop. While in theory the noise threshold could lead to more noise, when combined with [[Denoiser|denoising algorithms]], the final image quality remains mostly equal.<ref>https://tomclabault.github.io/blog/2024/per-pixel-adaptive-sampling/</ref>