Engine

Find articles

Filter tutorials, troubleshooting and shared fundamentals.

285 articles

VFX textures: masks, noise, flipbooks and colorBeginner

VFX textures: masks, noise, flipbooks and color

Understand VFX color maps, masks, noise and flipbooks, including RGB versus alpha, UVs, color space, resolution and compression.

Diagnose stalls during asynchronous scene transitionsIntermediate

Diagnose stalls during asynchronous scene transitions

Diagnose stalls during asynchronous scene transitions. Async loading can still incur activation, object lifecycle, asset cleanup, and GC work on the main thread

Measure and reduce allocations from LINQ and lambdasIntermediate

Measure and reduce allocations from LINQ and lambdas

Measure and reduce allocations from LINQ and lambdas. LINQ iterators, result collections, sorting, delegates, and captures can add allocations or CPU work. Not

Measure and consolidate many Update callbacksIntermediate

Measure and consolidate many Update callbacks

Measure and consolidate many Update callbacks. Large numbers of MonoBehaviour callbacks add native-to-managed overhead and repeated work. Profile first to decid

Reuse cells in large ScrollRect listsIntermediate

Reuse cells in large ScrollRect lists

Reuse cells in large ScrollRect lists. Creating every ScrollRect cell increases memory, layout, and update work; layout cost is not necessarily exponential.

Reduce uGUI GraphicRaycaster CPU costIntermediate

Reduce uGUI GraphicRaycaster CPU cost

Reduce uGUI GraphicRaycaster CPU cost. Many UI raycast candidates can increase CPU cost. Inspect candidates, raycasters, input-module behavior, and blocking set

Cancellation and object lifetime with async/await and UniTaskIntermediate

Cancellation and object lifetime with async/await and UniTask

Cancellation and object lifetime with async/await and UniTask. Accessing a destroyed object after await can fail. Cancellation is cooperative: the awaited opera

Check URP pass timing and input buffersAdvanced

Check URP pass timing and input buffers

Check URP pass timing and input buffers. A missing renderer feature can involve renderer selection, camera type, layer/queue/pass filters, input availability, a

Object pooling: lifecycle and memory considerationsIntermediate

Object pooling: lifecycle and memory considerations

Object pooling: lifecycle and memory considerations. Repeated creation/destruction costs initialization, native work, and managed allocations. Pooling reduces t

Edit and save prefab assets from Editor toolsIntermediate

Edit and save prefab assets from Editor tools

Edit and save prefab assets from Editor tools. Editing a prefab asset differs from recording an instance override. Confusing the targets can lose changes.

Diagnose blurry UI with URP render scaleIntermediate

Diagnose blurry UI with URP render scale

Diagnose blurry UI with URP render scale. UI drawn into a downscaled camera target becomes blurry when that target is enlarged. UI resolution depends on its ren

Check URP decal distortion, projection, and visibilityIntermediate

Check URP decal distortion, projection, and visibility

Check URP decal distortion, projection, and visibility. A decal projector affects compatible surfaces in its volume. Excess depth, projection angle, or unsuppor

Check model and shadow artifacts during LOD cross-fadesIntermediate

Check model and shadow artifacts during LOD cross-fades

Check model and shadow artifacts during LOD cross-fades. LOD cross-fading requires support in both LOD Group and the shader. Check the installed URP/Shader Grap

URP Transparent Shadows: Shader Graph FixesIntermediate

URP Transparent Shadows: Shader Graph Fixes

Fix transparent shadow issues in Unity URP Shader Graph: separate receiving from casting, check Lit and renderer settings, and choose a shadow proxy.

Adjust shadow bias for acne and detached shadowsIntermediate

Adjust shadow bias for acne and detached shadows

Adjust shadow bias for acne and detached shadows. Shadow acne involves self-shadow depth error; jagged outlines often involve shadow texel density. Increasing b

Check missing or flickering lights in URP Forward+Intermediate

Check missing or flickering lights in URP Forward+

Check missing or flickering lights in URP Forward+. Forward+ still has platform-dependent visible-light limits. A universal 32-lights-per-tile limit is not an a

Persist ScriptableObject edits in Editor toolsIntermediate

Persist ScriptableObject edits in Editor tools

Persist ScriptableObject edits in Editor tools. Editor changes to ScriptableObject assets need suitable undo/dirty/save handling. Runtime changes in a build do

Reconstruct normals after vertex displacementAdvanced

Reconstruct normals after vertex displacement

Reconstruct normals after vertex displacement. Moving vertices does not automatically deform their normals or tangents. Reconstruct them in a consistent space u

Check MSAA in URP camera stacksIntermediate

Check MSAA in URP camera stacks

Check MSAA in URP camera stacks. Overlay cameras share stack targets. It is not a general rule that MSAA always resolves after the Base camera and disables it f

Check Custom Function and SRP Batcher compatibilityAdvanced

Check Custom Function and SRP Batcher compatibility

Check Custom Function and SRP Batcher compatibility. Shader Graph generates its material constant buffer. Redeclaring UnityPerMaterial or duplicating graph prop

Investigate VFX Graph memory use and OOMAdvanced

Investigate VFX Graph memory use and OOM

Investigate VFX Graph memory use and OOM. VFX memory depends on capacity, stored attributes, auxiliary buffers, sorting, and concurrent instances. Attribute siz

Restore values and release resources in PlayableBehaviourAdvanced

Restore values and release resources in PlayableBehaviour

Restore values and release resources in PlayableBehaviour. A custom playable can leave its last value behind when evaluation stops. Residual state is distinct f

Diagnose dark or overbright RenderTexture previewsIntermediate

Diagnose dark or overbright RenderTexture previews

Diagnose dark or overbright RenderTexture previews. Separate texture format/sRGB conversion from exposure, tonemapping, and display shader differences. RawImage

URP particle transparency and material settingsIntermediate

URP particle transparency and material settings

URP particle transparency and material settings. Check shader compatibility, surface type, blending, and sorting separately. Depth writes are usually off for tr

Diagnose first-play particle spikes in TimelineAdvanced

Diagnose first-play particle spikes in Timeline

Diagnose first-play particle spikes in Timeline. First-play spikes may involve GPU program preparation, asset loading/creation, particle pre-simulation, or play

Check URP depth texture generation and conversionIntermediate

Check URP depth texture generation and conversion

Check URP depth texture generation and conversion. Depth effects need the correct generation setting, camera override, sampling time, and depth-writing objects.

Check URP decals that fail to project onto a targetIntermediate

Check URP decals that fail to project onto a target

Check URP decals that fail to project onto a target. Check the decal feature, projector volume, compatible receiver shader, and rendering technique. A Receive D

Particle scaling modes and parent transformsBeginner

Particle scaling modes and parent transforms

Particle scaling modes and parent transforms. Scaling Mode determines how transform scale affects particles; it differs from Simulation Space.

Check transparent Particle System sortingIntermediate

Check transparent Particle System sorting

Check transparent Particle System sorting. Typical transparents test depth without writing it and blend back to front. Renderer-level sorting cannot fully resol

Check bounds when VFX Graph disappears with camera motionAdvanced

Check bounds when VFX Graph disappears with camera motion

Check bounds when VFX Graph disappears with camera motion. If VFX bounds do not enclose the effect, visible particles can be culled when the bounds leave the fr

Check VFX Graph events that do not spawn particlesIntermediate

Check VFX Graph events that do not spawn particles

Check VFX Graph events that do not spawn particles. Event names, graph wiring, spawn behavior, capacity, and bounds determine whether particles appear. Events d

Diagnose HLSL compilation errors in Custom Function nodesAdvanced

Diagnose HLSL compilation errors in Custom Function nodes

Diagnose HLSL compilation errors in Custom Function nodes. Custom Function File and String modes use different function-definition conventions. Check precision

Diagnose dark transparent edges in RenderTexture UIIntermediate

Diagnose dark transparent edges in RenderTexture UI

Diagnose dark transparent edges in RenderTexture UI. Dark fringes occur when premultiplied colors are displayed with straight-alpha blending, multiplying alpha

Check shaders that fail in one eye with single-pass instancingAdvanced

Check shaders that fail in one eye with single-pass instancing

Check shaders that fail in one eye with single-pass instancing. One-eye artifacts can arise from missing stereo information or incorrect screen-texture sampling

SRP Batcher Not Compatible: Unity URP Fix ChecklistAdvanced

SRP Batcher Not Compatible: Unity URP Fix Checklist

Fix Unity URP SRP Batcher incompatibility by checking UnityPerMaterial, shader passes and MaterialPropertyBlock, then verify the affected draw.

Measure post-processing cost on mobile and QuestAdvanced

Measure post-processing cost on mobile and Quest

Measure post-processing cost on mobile and Quest. Bloom and depth of field can add intermediate/fullscreen work, but not every effect, such as vignette, creates

Pass particle and mesh vertex colors to shadersIntermediate

Pass particle and mesh vertex colors to shaders

Pass particle and mesh vertex colors to shaders. Particle color and source-mesh vertex color are distinct data. Match the Color stream with shader input and mul

Reduce Particle System noise CPU costAdvanced

Reduce Particle System noise CPU cost

Reduce Particle System noise CPU cost. Noise adds simulation work depending on particle count, quality, and octaves. Separate simulation cost from rendering cos

Soft particles: fade intersections using consistent depthsIntermediate

Soft particles: fade intersections using consistent depths

Soft particles: fade intersections using consistent depths. Soft particles fade from the gap between scene and particle depth in the same linear space. Raw scre

Check RenderTexture color conversion, HDR, and output pathsAdvanced

Check RenderTexture color conversion, HDR, and output paths

Check RenderTexture color conversion, HDR, and output paths. Separate texture format/sRGB conversion from exposure, tonemapping, and display shader differences.

Diagnose missing objects in custom URP passesAdvanced

Diagnose missing objects in custom URP passes

Diagnose missing objects in custom URP passes. A missing renderer feature can involve renderer selection, camera type, layer/queue/pass filters, input availabil

Tune peripheral quality with fixed foveation on QuestAdvanced

Tune peripheral quality with fixed foveation on Quest

Tune peripheral quality with fixed foveation on Quest. FFR reduces peripheral shading density and can expose artifacts at aggressive levels. Its fixed center is

Check player build errors from UnityEditor referencesBeginner

Check player build errors from UnityEditor references

Check player build errors from UnityEditor references. Gizmos belongs to UnityEngine, unlike UnityEditor.Handles. Editor Scene and Game views can display gizmos

Check screen-space camera UI and 3D orderingBeginner

Check screen-space camera UI and 3D ordering

Check screen-space camera UI and 3D ordering. Canvas hierarchy, renderer sorting, and depth tests are separate mechanisms. CanvasGroup has no Sorting Order, and

Update VFX Graph properties from C#Beginner

Update VFX Graph properties from C#

Update VFX Graph properties from C#. Check exposure, exact property name, type, graph connections, and competing writers. Do not assume Shader Graph display/ref

Manage URP Rendering Debugger availability in buildsBeginner

Manage URP Rendering Debugger availability in builds

Manage URP Rendering Debugger availability in builds. Rendering Debugger is a diagnostic feature for the editor and development builds. Do not assume its UI nec

Check post-processing volume blending and transitionsIntermediate

Check post-processing volume blending and transitions

Check post-processing volume blending and transitions. Local volume blending depends on collider distance, blend distance, weight/priority, overrides, and camer

Check textures assigned to VFX GraphAdvanced

Check textures assigned to VFX Graph

Check textures assigned to VFX Graph. Check exposed texture dimension/type, wiring, UVs, and data color space. Converting every input to Texture2D is not a vali

Shader Graph vertex animation and SRP BatcherAdvanced

Shader Graph vertex animation and SRP Batcher

Shader Graph vertex animation and SRP Batcher. The SRP Batcher reduces CPU work preparing draws. It does not automatically reduce draw count. Vertex animation,

Define RenderTexture ownership and release resourcesIntermediate

Define RenderTexture ownership and release resources

Define RenderTexture ownership and release resources. Check ownership, references, allocation frequency, and cleanup. Destroy is not categorically unable to fre

Check per-eye sampling in XR post-processingAdvanced

Check per-eye sampling in XR post-processing

Check per-eye sampling in XR post-processing. SPI/Multiview can use per-eye texture arrays. Use pipeline-compatible inputs rather than copying Built-in screen m

Distinguish skinned-mesh emission from particle attachmentIntermediate

Distinguish skinned-mesh emission from particle attachment

Distinguish skinned-mesh emission from particle attachment. Particle System can emit directly from a Skinned Mesh Renderer shape. Manually baking a mesh every f

Check Game-view gizmos and runtime debug renderingBeginner

Check Game-view gizmos and runtime debug rendering

Check Game-view gizmos and runtime debug rendering. Gizmos belongs to UnityEngine, unlike UnityEditor.Handles. Editor Scene and Game views can display gizmos, b

Apply fog to transparent URP particlesIntermediate

Apply fog to transparent URP particles

Apply fog to transparent URP particles. For mismatched fog, check shader fog support and blending mode. Background scene depth is not automatically the particle

Multiple materials, submeshes, and the SRP BatcherAdvanced

Multiple materials, submeshes, and the SRP Batcher

Multiple materials, submeshes, and the SRP Batcher. The SRP Batcher reduces CPU work preparing draws. It does not automatically reduce draw count. Vertex animat

Diagnose position and pose drift in Timeline loopsIntermediate

Diagnose position and pose drift in Timeline loops

Diagnose position and pose drift in Timeline loops. Separate root motion, track offsets, clip loop continuity, and competing transform writers. Enabling Apply R

Diagnose audio and visual timing in TimelineAdvanced

Diagnose audio and visual timing in Timeline

Diagnose audio and visual timing in Timeline. Timeline and audio clock differences can affect synchronization during pauses or time-scale changes. DSP Clock doe

Set post-playback state in Timeline activation tracksBeginner

Set post-playback state in Timeline activation tracks

Set post-playback state in Timeline activation tracks. Activation Track uses its Post-playback state to define activation after stopping. Changing director Wrap

Prevent reimport loops in AssetPostprocessorAdvanced

Prevent reimport loops in AssetPostprocessor

Prevent reimport loops in AssetPostprocessor. Repeated reimport requests inside import callbacks can restart refresh loops. Changes must converge rather than co

Release EditorWindow resources across close and reloadIntermediate

Release EditorWindow resources across close and reload

Release EditorWindow resources across close and reload. Editor-created textures/materials have native resources. Clearing a reference does not replace their des

Fix UnityEditor reference errors after adding asmdefsIntermediate

Fix UnityEditor reference errors after adding asmdefs

Fix UnityEditor reference errors after adding asmdefs. Assembly boundaries need explicit Editor separation and the correct dependency direction. An Editor folde

Check transparent VFX sorting and renderer orderAdvanced

Check transparent VFX sorting and renderer order

Check transparent VFX sorting and renderer order. Transparent particle order depends on output sorting and blending. VFX Graph does not universally disable sort

Check supported GPU collision inputs in VFX GraphAdvanced

Check supported GPU collision inputs in VFX Graph

Check supported GPU collision inputs in VFX Graph. GPU VFX collision does not automatically share every CPU physics collider. Check the selected collision block

Spawn child VFX systems through GPU eventsAdvanced

Spawn child VFX systems through GPU events

Spawn child VFX systems through GPU events. Particle System Sub Emitters and VFX Graph GPU-event child systems are different workflows. VFX needs the appropriat

Check custom interpolator types, spaces, and interpolationAdvanced

Check custom interpolator types, spaces, and interpolation

Check custom interpolator types, spaces, and interpolation. A custom interpolator carries interpolated vertex values to fragments. Space mismatches and varying

Check triplanar coordinates, scale, and blendingIntermediate

Check triplanar coordinates, scale, and blending

Check triplanar coordinates, scale, and blending. Triplanar blends three projections using the normal. Increasing Blend sharpens the dominant projection; values

Check view and normal spaces for Fresnel in VRAdvanced

Check view and normal spaces for Fresnel in VR

Check view and normal spaces for Fresnel in VR. Some left/right rim differences are normal parallax. The standard Fresnel node is not inherently VR-incompatible

Check mixed-light shadow overlap and leakageIntermediate

Check mixed-light shadow overlap and leakage

Check mixed-light shadow overlap and leakage. Check baked data, light modes, receivers, and mixed-lighting shader logic. There is no general requirement to add

Check device support for VFX strip outputsAdvanced

Check device support for VFX strip outputs

Check device support for VFX strip outputs. Separate API/package/device support from strip capacity and attributes. A specific GPU synchronization defect requir

Check URP stencil passes, shared targets, and orderingIntermediate

Check URP stencil passes, shared targets, and ordering

Check URP stencil passes, shared targets, and ordering. Stencil failures can involve pass support, ordering, references/masks, or target sharing. URP does not u

Check repeated Timeline signal dispatchAdvanced

Check repeated Timeline signal dispatch

Check repeated Timeline signal dispatch. Duplicate signals can come from multiple emitters, receivers/directors, loops, seeks, or retroactive settings. Low FPS

Sorting FudgeBeginner

Sorting Fudge

Sorting Fudge biases a particle renderer against other systems. Smaller values tend to draw it in front.

Fixed Foveated Rendering (FFR)Advanced

Fixed Foveated Rendering (FFR)

FFR shades a fixed central region more densely than peripheral regions.

Depth TextureIntermediate

Depth Texture

A depth texture exposes camera-view depth per pixel.

Q&A: pink URP materials and shader errorsBeginner

Q&A: pink URP materials and shader errors

Q&A: pink URP materials and shader errors. Magenta indicates an unusable shader. Pipeline mismatch, compile errors, unsupported APIs, and missing variants are p

Q&A: disappearing VFX and boundsIntermediate

Q&A: disappearing VFX and bounds

Q&A: disappearing VFX and bounds. If VFX bounds do not enclose the effect, visible particles can be culled when the bounds leave the frustum. The culling volume

Q&A: release RenderTextures and prevent leaksAdvanced

Q&A: release RenderTextures and prevent leaks

Q&A: release RenderTextures and prevent leaks. Check ownership, references, allocation frequency, and cleanup. Destroy is not categorically unable to free GPU r

Control Particle System playback and seeking in TimelineBeginner

Control Particle System playback and seeking in Timeline

Control Particle System playback and seeking in Timeline. Activation tracks toggle active state. Timeline-controlled particle simulation requires a control trac

Render QueueBeginner

Render Queue

Render Queue. Render Queue assigns shader/material rendering groups and ordering. The pipeline then sorts within groups such as Geometry or Transparent.

GPU InstancingIntermediate

GPU Instancing

GPU instancing draws compatible objects sharing geometry/material with per-instance transforms and attributes.

Variable Rate Shading (VRS)Advanced

Variable Rate Shading (VRS)

Variable Rate Shading (VRS). Variable rate shading changes shading frequency across regions and can reduce GPU work by evaluating some areas more coarsely.

Custom Function (Custom Function Node)Intermediate

Custom Function (Custom Function Node)

Custom Function calls HLSL from Shader Graph. String mode takes a body, while File mode references a function with matching ports and precision.

Prewarm (particle pre-simulation)Beginner

Prewarm (particle pre-simulation)

Prewarm advances a looping particle system to an established state before presentation.

Frustum CullingBeginner

Frustum Culling

Frustum Culling. Frustum culling excludes renderers outside the camera view, generally using their bounds.

MipmapBeginner

Mipmap

Mipmap. Mipmaps are progressively smaller images used during texture minification to reduce aliasing and sampling cost.

Scriptable Renderer FeatureAdvanced

Scriptable Renderer Feature

Scriptable Renderer Feature. A Scriptable Renderer Feature extends a URP renderer with custom rendering work, enabled on its Renderer Data.

HLSL (High-Level Shader Language)Advanced

HLSL (High-Level Shader Language)

HLSL describes GPU programs such as shaders; Unity translates/compiles it for target platforms.

BillboardBeginner

Billboard

Billboards orient a plane toward the camera or another chosen direction, useful for particles and distant objects.

Deferred ShadingAdvanced

Deferred Shading

Deferred shading records surface properties in a G-buffer before evaluating lighting.

Forward+ RenderingAdvanced

Forward+ Rendering

Forward+ selects relevant lights per screen region or cluster before forward shading.

Render PipelineBeginner

Render Pipeline

A rendering pipeline organizes culling, shadows, draws, and post-processing. Built-in, URP, and HDRP have different APIs and features.

Z-Test (Depth Test / ZTest)Intermediate

Z-Test (Depth Test / ZTest)

ZTest compares fragment depth with stored depth using a selected comparison function.

Stencil BufferAdvanced

Stencil Buffer

Stencil Buffer. A stencil buffer stores per-pixel integer values for masking through writes and comparisons.

Overdraw (overdraw / duplicate drawing)Intermediate

Overdraw (overdraw / duplicate drawing)

Overdraw (overdraw / duplicate drawing). Overdraw repeatedly processes overlapping surfaces at the same pixels, particularly costly for transparency.

Anisotropic FilteringBeginner

Anisotropic Filtering

Anisotropic filtering improves texture sampling on oblique surfaces, such as roads or floors.

Color SpaceIntermediate

Color Space

Color Space. Color space describes how values represent brightness. A linear workflow decodes color textures for lighting calculations.

LOD (Level of Detail)Beginner

LOD (Level of Detail)

LOD selects geometry detail according to visibility size or another policy; Unity LOD Group uses relative screen size.

Occlusion CullingIntermediate

Occlusion Culling

Occlusion culling skips hidden renderers; Unity baked occlusion uses suitable occluder/occludee configuration.

Post ProcessingBeginner

Post Processing

Post-processing applies effects such as bloom and grading to rendered images using a supported volume/camera setup.

Render TextureIntermediate

Render Texture

A render texture is a GPU rendering target used by cameras and intermediate passes.

Draw CallBeginner

Draw Call

A draw call asks the GPU to render geometry; materials, submeshes, and passes can increase counts.

Batched Draw CallIntermediate

Batched Draw Call

Batching processes compatible objects with shared rendering work.

Simulation SpaceBeginner

Simulation Space

Simulation Space. Simulation space controls the coordinate system of particle state; local particles follow the system transform, while world particles retain w

Vector FieldAdvanced

Vector Field

A vector field assigns directions or velocities across space and can drive particle motion.

Particle LifetimeBeginner

Particle Lifetime

Particle lifetime sets lifespan; age/lifetime drive changes and expiration.

Emission RateBeginner

Emission Rate

Emission rate controls spawning per time or distance; distinguish the corresponding modes.

BurstsBeginner

Bursts

Bursts spawn groups at selected times with supported count, repetition, and probability controls.

GPU ParticleAdvanced

GPU Particle

GPU particles update state such as positions, velocities, and lifetimes on the GPU.

Point CacheAdvanced

Point Cache

A point cache stores sampled points and attributes for uses such as VFX particle placement.

Sub EmittersIntermediate

Sub Emitters

A sub-emitter spawns child effects from parent-particle events.

Particle CollisionIntermediate

Particle Collision

Particle collision detects contact and can bounce, stop, or kill particles.

Noise FieldIntermediate

Noise Field

A noise field evaluates spatial/temporal noise to influence particle motion.

Render ModeBeginner

Render Mode

Render mode selects particle geometry such as billboards, stretched billboards, or meshes.

Ribbon RendererIntermediate

Ribbon Renderer

A ribbon renders a strip joining a sequence of points.

TrailBeginner

Trail

Trails connect position history using systems such as TrailRenderer or particle trails.

Inherit VelocityBeginner

Inherit Velocity

Inherit Velocity transfers emitter motion to particles; inspect supported initial/current modes.

Soft ParticlesIntermediate

Soft Particles

Soft Particles. Soft particles fade intersections using the gap between particle and scene depth.

Vertex ShaderIntermediate

Vertex Shader

A vertex shader computes positions and attributes per vertex, including transforms and deformation.

Fragment ShaderIntermediate

Fragment Shader

A fragment shader evaluates rasterized fragments for color, lighting, and related outputs.

Fresnel EffectBeginner

Fresnel Effect

Fresnel describes angle-dependent reflectance. The graph node provides an approximate angular weight useful for rims.

Normal Map (Normal Map / Normal Map)Beginner

Normal Map (Normal Map / Normal Map)

Normal maps encode surface-normal detail without adding geometry.

UV CoordinatesBeginner

UV Coordinates

UV Coordinates. UVs are two-dimensional texture coordinates obtained from mesh data or calculations.

PBR (Physically Based Rendering)Beginner

PBR (Physically Based Rendering)

PBR models light/material interaction using physically motivated parameters such as metallic and roughness.

Alpha Clipping (Alpha Clipping / Cutout)Beginner

Alpha Clipping (Alpha Clipping / Cutout)

Alpha clipping keeps or discards fragments according to a threshold, useful for cutout foliage.

Vertex ColorBeginner

Vertex Color

Vertex color stores color or mask values per vertex.

Triplanar ProjectionAdvanced

Triplanar Projection

Triplanar Projection. Triplanar mapping blends three axis projections weighted by surface normals.

Shader VariantAdvanced

Shader Variant

Shader variants are programs for keyword combinations, trading feature selection against build/runtime preparation cost.

Single Pass InstancedAdvanced

Single Pass Instanced

Single-pass instanced stereo shares some work while shaders handle per-eye information.

Multi-Pass RenderingIntermediate

Multi-Pass Rendering

XR multipass renders each eye separately; distinguish it from shaders with multiple general rendering passes.

VRAM (Video RAM / video memory)Beginner

VRAM (Video RAM / video memory)

Graphics memory holds textures, meshes, targets, and other GPU resources.

FillrateIntermediate

Fillrate

Fillrate concerns pixel/fragment throughput, limited by shading, blending, bandwidth, resolution, and hardware.

Draw Call BatchingIntermediate

Draw Call Batching

Draw-call batching groups compatible rendering work through approaches with different restrictions.

ProfilerBeginner

Profiler

The profiler measures runtime work and memory using CPU timelines, GPU modules, and other views.

Frame Rate (Frame rate / FPS)Beginner

Frame Rate (Frame rate / FPS)

Frame rate counts frames per second; 60 FPS corresponds to roughly 16.7 ms per frame. Inspect slow frames too.

BottleneckBeginner

Bottleneck

A bottleneck is the stage limiting progress; compare CPU, GPU, I/O, and other work to choose a target.

LOD GroupBeginner

LOD Group

LOD Group switches renderers according to relative screen size.

Shader CompilationAdvanced

Shader Compilation

Shader compilation translates source for target APIs; keyword and rendering paths affect program counts.

Static BatchingBeginner

Static Batching

Static batching combines static geometry to reduce rendering overhead.

Dynamic BatchingIntermediate

Dynamic Batching

Dynamic batching combines suitable small meshes using CPU work, subject to vertex-attribute and shader restrictions.

Command BufferAdvanced

Command Buffer

A command buffer records GPU work such as rendering and copies.

Frame BufferIntermediate

Frame Buffer

A framebuffer groups rendering attachments such as color/depth for screen or intermediate targets.

Shadow MapIntermediate

Shadow Map

A shadow map stores light-view depth for comparison with receiver depth to estimate visibility.

Shadow CascadesAdvanced

Shadow Cascades

Shadow cascades divide directional shadows by camera distance to allocate precision near the viewer.

Shadow MaskAdvanced

Shadow Mask

A shadowmask stores baked occlusion for mixed lights.

LightmapBeginner

Lightmap

A lightmap stores precomputed illumination for mainly static surfaces.

Light ProbeIntermediate

Light Probe

Light probes store baked lighting at spatial samples for interpolation onto moving objects.

Reflection ProbeIntermediate

Reflection Probe

A reflection probe captures surrounding cubemap data for material reflections using supported baked/realtime modes.

SkyboxBeginner

Skybox

A skybox renders the scene background and can supply environment lighting/reflection inputs.

HDR (High Dynamic Range)Beginner

HDR (High Dynamic Range)

HDR rendering preserves values outside the usual 0–1 range using suitable formats.

Bloom (Bloom / leaking light)Beginner

Bloom (Bloom / leaking light)

Bloom extracts/spreads bright contributions and composites a glow.

ACES tone mappingAdvanced

ACES tone mapping

ACES is a color-management system; Unity offers an ACES-inspired tonemapping transform.

TonemappingIntermediate

Tonemapping

Tonemapping maps broad scene intensities into an output range with an appropriate transform and exposure.

VignetteBeginner

Vignette

Vignette adjusts image edges, commonly darkening them.

Chromatic AberrationBeginner

Chromatic Aberration

Chromatic aberration simulates color fringing from wavelength-dependent lens refraction.

Depth of Field (DoF)Intermediate

Depth of Field (DoF)

Depth of field blurs out-of-focus areas using controls available in the selected mode.

Screen-space Reflections (SSR)Advanced

Screen-space Reflections (SSR)

Screen-space Reflections (SSR). Screen-space reflections approximate reflections from visible color/depth data.

Temporal Anti-Aliasing (TAA)Advanced

Temporal Anti-Aliasing (TAA)

TAA combines current/history samples, commonly using motion vectors and jitter in supported implementations.

Render ScaleBeginner

Render Scale

Render scale multiplies target dimensions; 0.5 halves each dimension and gives about one-quarter as many pixels.

Dynamic ResolutionAdvanced

Dynamic Resolution

Dynamic resolution changes rendering resolution at runtime.

Compute ShaderAdvanced

Compute Shader

A compute shader runs parallel GPU work through dispatched thread groups, independent of ordinary draw passes.

Structured BufferAdvanced

Structured Buffer

StructuredBuffer exposes structured elements to shaders; supported RW forms allow writes.

Custom InterpolatorAdvanced

Custom Interpolator

Custom Interpolator. A custom interpolator transfers vertex-calculated values to graph fragment processing.

Detail MapBeginner

Detail Map

Detail maps add fine color/normal information through compatible material features.

Emission (self-luminescence / emission)Beginner

Emission (self-luminescence / emission)

Emission adds a material self-emissive contribution and can feed bloom or supported GI.

Occlusion Map (Occclusion Map / AO Map)Intermediate

Occlusion Map (Occclusion Map / AO Map)

An occlusion map masks occlusion, typically reducing supported indirect-light contributions.

Tessellation (polygon subdivision)Advanced

Tessellation (polygon subdivision)

Tessellation (polygon subdivision). Tessellation subdivides geometry through supported GPU stages.

Geometry ShaderAdvanced

Geometry Shader

A geometry shader can emit primitives from input primitives.

Backface Culling (Cull Back)Beginner

Backface Culling (Cull Back)

Backface culling excludes triangles facing away from the view.

Blend Mode (Blend Mode / Alpha Blend)Beginner

Blend Mode (Blend Mode / Alpha Blend)

Blend mode specifies how source and destination colors combine, including alpha and additive formulations.

GPU Driven RenderingAdvanced

GPU Driven Rendering

GPU-driven rendering moves some preparation/culling work to the GPU.

Ray Tracing (DXR)Advanced

Ray Tracing (DXR)

Ray tracing computes effects such as reflections/shadows using ray–geometry intersections.

Shader GraphBeginner

Shader Graph

Shader Graph builds shader calculations from nodes for a selected pipeline/target.

Instanced Drawing (GPU Instancing)Intermediate

Instanced Drawing (GPU Instancing)

Instanced drawing renders common geometry with multiple transforms/attributes.

Deferred LightingAdvanced

Deferred Lighting

Deferred lighting names techniques that separate surface and later lighting work; distinguish it from a specific deferred-shading implementation.

Forward RenderingBeginner

Forward Rendering

Forward rendering evaluates lighting while shading objects.

Tile-Based Deferred RenderingAdvanced

Tile-Based Deferred Rendering

Tile-based deferred techniques organize deferred work by screen tiles and can select relevant lights per tile.

Clustered RenderingAdvanced

Clustered Rendering

Clustered rendering partitions view space in XY and depth to select relevant lights.

GPU SkinningIntermediate

GPU Skinning

GPU skinning computes bone-driven deformation through a supported GPU rendering path.

CPU SkinningIntermediate

CPU Skinning

CPU skinning computes bone-driven vertex deformation on the CPU.

Root MotionBeginner

Root Motion

Root motion applies animation-derived root translation/rotation to an object.

Blend TreeBeginner

Blend Tree

A blend tree mixes motions according to animator parameters and configured thresholds/blend type.

Animator ControllerBeginner

Animator Controller

An animator controller organizes states, transitions, parameters, and layers.

Timeline Control PlayableIntermediate

Timeline Control Playable

A Timeline control playable manages supported systems such as particles/directors on its source object.

Addressables (Addressable Asset System)Intermediate

Addressables (Addressable Asset System)

Addressables (Addressable Asset System). Addressables locates/loads resources through catalogs and manages referenced operations/handles.

Asset BundleAdvanced

Asset Bundle

An asset bundle packages built Unity assets for runtime delivery/loading with platform and dependency management.

Sprite AtlasBeginner

Sprite Atlas

A sprite atlas packs multiple sprite images into shared textures.

Mipmap Bias (Mipmap Bias / MipMapBias)Intermediate

Mipmap Bias (Mipmap Bias / MipMapBias)

Mipmap bias adjusts selected levels; negative values generally favor detail, positive values coarser levels.

Texture StreamingAdvanced

Texture Streaming

Texture streaming manages mip residency according to demand and memory budgets.

Occlusion QueryAdvanced

Occlusion Query

An occlusion query asks the GPU about visibility to guide later work.

Early-Z (Early Z Culling)Advanced

Early-Z (Early Z Culling)

Early-Z can reject occluded fragments before expensive shading.

Stencil TestAdvanced

Stencil Test

Stencil Test. A stencil test compares stored values with references/masks and can update values through configured operations.

LUT (Look-Up Table)Intermediate

LUT (Look-Up Table)

A LUT maps input values to outputs; grading LUTs encode color transforms.

White BalanceBeginner

White Balance

White balance compensates illumination color casts using supported temperature/tint controls.

Shadow DistanceBeginner

Shadow Distance

Shadow distance limits realtime shadow range, configured on the active asset/path.

Contact ShadowsAdvanced

Contact Shadows

Contact shadows approximate fine shadowing near contact regions.

Micro ShadowingAdvanced

Micro Shadowing

Micro shadowing approximates fine-scale surface masking from suitable material information.

Ray Traced ShadowsAdvanced

Ray Traced Shadows

Ray-traced shadows use ray intersections to evaluate occlusion.

Dithering (Dithering / Dither / Dither)Intermediate

Dithering (Dithering / Dither / Dither)

Dithering distributes values into patterns to reduce visible quantization or transitions.

Flow MapIntermediate

Flow Map

A flow map encodes directions used to animate texture coordinates or other flow effects.

Diagnose light leakage through thin URP wallsIntermediate

Diagnose light leakage through thin URP walls

Diagnose light leakage through thin URP walls. Light leaks can involve bias, resolution, one-sided geometry, shadow casters, or baked GI. One bias value does no

Investigate long shader builds and variant countsAdvanced

Investigate long shader builds and variant counts

Investigate long shader builds and variant counts. Keyword combinations increase shader variants. Long compilation is not automatically a freeze or infinite loo

Check particle renderer order and internal sortingIntermediate

Check particle renderer order and internal sorting

Check particle renderer order and internal sorting. Typical transparents test depth without writing it and blend back to front. Renderer-level sorting cannot fu

Reduce uGUI canvas rebuild and layout costIntermediate

Reduce uGUI canvas rebuild and layout cost

Reduce uGUI canvas rebuild and layout cost. UI changes can dirty individual graphics and trigger canvas batch rebuilds. Not every change necessarily regenerates

Check Android ASTC support, fallback, and memoryAdvanced

Check Android ASTC support, fallback, and memory

Check Android ASTC support, fallback, and memory. Unsupported ASTC can fall back to uncompressed textures and increase memory usage. Unsupported compression doe

Investigate asmdef dependencies and repeated compilationAdvanced

Investigate asmdef dependencies and repeated compilation

Investigate asmdef dependencies and repeated compilation. Separate a slow compilation, a reference error, and compilation repeatedly restarting. Circular asmdef

Release Addressables handles and instances correctlyAdvanced

Release Addressables handles and instances correctly

Release Addressables handles and instances correctly. Addressables uses reference counts. Unbalanced loads/releases retain resources, but reaching zero does not

Tune fixed foveation when Quest peripheral quality degradesAdvanced

Tune fixed foveation when Quest peripheral quality degrades

Tune fixed foveation when Quest peripheral quality degrades. FFR reduces peripheral shading density and can expose artifacts at aggressive levels. Its fixed cen

Check CCD, geometry, and movement for fast rigidbodiesIntermediate

Check CCD, geometry, and movement for fast rigidbodies

Check CCD, geometry, and movement for fast rigidbodies. Discrete detection can miss thin obstacles between physics steps. Direct transform movement and collider

Check initial poses and camera jumps at Timeline startIntermediate

Check initial poses and camera jumps at Timeline start

Check initial poses and camera jumps at Timeline start. T-poses can involve bindings, unevaluated starting poses, avatars, or animation culling. Cinemachine fol

Check Scene Color refraction and transparent capture timingIntermediate

Check Scene Color refraction and transparent capture timing

Check Scene Color refraction and transparent capture timing. URP Scene Color samples the opaque texture captured before transparents. Moving a transparent objec

Check missing TMP glyphs and dynamic atlas capacityIntermediate

Check missing TMP glyphs and dynamic atlas capacity

Check missing TMP glyphs and dynamic atlas capacity. Distinguish missing source-font glyphs from a full dynamic atlas. Adding an automatic atlas-clearing event

Check NavMeshAgent jitter and competing movement systemsIntermediate

Check NavMeshAgent jitter and competing movement systems

Check NavMeshAgent jitter and competing movement systems. Agents, dynamic rigidbodies, and root motion can compete for one transform. Navigation geometry and Ph

Separate I/O, decompression, and creation stalls in AddressablesIntermediate

Separate I/O, decompression, and creation stalls in Addressables

Separate I/O, decompression, and creation stalls in Addressables. LZMA uses whole-stream decompression while LZ4 permits chunk-based reads. Async APIs can still

Investigate WebGL out-of-memory errors and retained assetsIntermediate

Investigate WebGL out-of-memory errors and retained assets

Investigate WebGL out-of-memory errors and retained assets. Separate Wasm heap pressure, asset expansion, GPU memory, and browser limits. An old fixed WebGL Mem

Identify closure and delegate allocationsIntermediate

Identify closure and delegate allocations

Identify closure and delegate allocations. A lambda capturing an outer local can allocate captured-state storage and a delegate. Distinguish this from noncaptur

Smooth procedural edges with ddx, ddy, and fwidthIntermediate

Smooth procedural edges with ddx, ddy, and fwidth

Smooth procedural edges with ddx, ddy, and fwidth. Hard thresholds or fixed UV smoothing widths can mismatch pixel size. Derivatives estimate local screen-space

Reduce UI overdraw coverage and GPU timeIntermediate

Reduce UI overdraw coverage and GPU time

Reduce UI overdraw coverage and GPU time. Layered UI can increase GPU work, but zero-alpha graphics are not always drawn; transparent-mesh culling and CanvasGro

Check mobile VFX Graph support and fallback effectsIntermediate

Check mobile VFX Graph support and fallback effects

Check mobile VFX Graph support and fallback effects. VFX Graph requires supported compute/graphics features and package-specific APIs. supportsComputeShaders or

Intermediate

Garbage Collection and Frame Spikes

Learn how to distinguish GC allocations from collection work and investigate frame spikes in Unity.

Intermediate

Height Fog

Understand height-dependent fog and why configuration differs between Unity render pipelines.

Intermediate

Thermal Throttling

Investigate thermal throttling with sustained device measurements and workload adjustments.