Learn about on-tile rendering in URP for tile-based GPUs.
On-tile rendering reduces GPU bandwidth usage on devices with a tile-based GPU, which can lower power consumption and improve performance.
On non-tile-based GPUs, rendering writes render targets to main GPU memory after each render pass. On tile-based GPUs, you can avoid this write operation (also known as a store) by keeping render target data in tile memory instead of repeatedly storing it to and loading it from main memory.
With on-tile rendering, the main cameraA component which creates an image of a particular viewpoint in your scene. The output is either drawn to the screen or captured as a texture. More info
See in Glossary targets (for example, intermediate textures and depth buffers) remain in the GPU’s fast tile cache throughout the entire rendering pipeline. At the end of the frame, only the color buffer is written to main memory (to the backbuffer). All other resources, such as intermediate textures and depth buffersA memory store that holds the z-value depth of each pixel in an image, where the z-value is the depth for each rendered pixel from the projection plane. More info
See in Glossary, are never stored to main memory, which reduces GPU bandwidth usage.
To use on-tile rendering, your project must use the Universal Render Pipeline.
On-tile rendering is supported on all platforms except WebGLA JavaScript API that renders 2D and 3D graphics in a web browser. The Unity Web build option allows Unity to publish content as JavaScript programs which use HTML5 technologies and the WebGL rendering API to run Unity content in a web browser. More info
See in Glossary.
To keep render target data in tile memory, the device must have a tile-based GPU and use a graphics API that supports native render passes. On other devices, on-tile rendering still renders correctly, but the data doesn’t stay on tile, so your project doesn’t get the reduced GPU bandwidth.
For XR-specific information, refer to Tile-based rendering in XR.
On-tile rendering works in Play mode when targeting supported platforms.
Note: You can enable on-tile rendering on desktop PCs with non-tile-based GPUs for testing during development, but it doesn’t reduce GPU bandwidth.
On-tile rendering breaks when a feature accesses the main camera targets in a way that forces Unity to store them to main memory, for example, by sampling them as textures instead of reading them as framebuffer input. This increases GPU bandwidth usage, so on-tile validation prevents it.
Avoid the following features:
Tip: Before you enable on-tile rendering, use the Render Graph Viewer to check your current render passes and identify potential issues.
To enable on-tile rendering in your project:
When you enable on-tile rendering, the main camera targets use the backbuffer’s UV orientation and Unity displays warnings on any components with unsupported features.
Note: If your custom renderer features or scriptable render passes are compatible with on-tile rendering, they work automatically with the on-tile renderer.
Tile-Only Mode adds extra validation to ensure rendering stays on-tile. This validation is enabled by default and shares the render graph system’s Enable Validity Checks setting. It throws an exception when a render pass is incompatible with on-tile rendering.
Disable validation only when you profile performance in a development buildA development build includes debug symbols and enables the Profiler. More info
See in Glossary. Unity automatically strips it from release builds, so it doesn’t affect runtime performance.
To disable validation:
Warning: If you disable validation, rendering can silently fall off-tile without displaying errors, which increases GPU bandwidth usage and can cause performance regressions.
Use the Render Graph Viewer to inspect the actual graph on your target device.