Reduce GPU bandwidth with on-tile rendering
Learn about on-tile rendering in URP for tile-based GPUs.
Read time 3 minutesLast updated 23 days ago
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 camera 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 buffers, are never stored to main memory, which reduces GPU bandwidth usage.
Requirements
To use on-tile rendering, your project must use the Universal Render Pipeline.
Supported platforms
On-tile rendering is supported on all platforms except WebGL.
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.
Unsupported features
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:
- Depth and opaque textures
- Temporal anti-aliasing (TAA)
- Multisample anti-aliasing (MSAA)
- Built-in post-processing
- HDR rendering
- Upscaling (except on Android XR)
- Dynamic resolution (except on Android XR)
- IMGUI rendering
- Subrectangle viewports
- Camera stacking
- Deferred rendering path
Enable on-tile rendering
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:
- Open your URP Renderer in the window.Inspector
?
- In the Rendering section, enable Tile-Only Mode.
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.
Disable on-tile validation
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 build. Unity automatically strips it from release builds, so it doesn't affect runtime performance.
To disable validation:
- Go to Edit > > Graphics.Project Settings
?
- Under Render Graph, disable Enable Validity Checks.
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.