Last reviewed 31 Jul 2026

Applies to

Unity 6 URP projects Non-VRChat applications GPU and rendering performance

Difficulty Intermediate

Optimize URP Performance: 7 Measurable Changes

URP performance depends on the features enabled in the pipeline, the content rendered by the scene, and the target hardware. Capture a baseline on the target platform before changing the URP Asset or Universal Renderer.

Establish a Repeatable Baseline

Open Window > Analysis > Profiler, connect it to a Development Build on the intended target device, and capture a repeatable section of the application. Unity recommends target-platform profiling because Play Mode shares resources with the Editor and can distort CPU, GPU, and memory measurements.

Record at least:

Measurement	What it reveals
CPU and GPU frame time	Whether the current limit is CPU-side or GPU-side
Rendering statistics	Draw calls, batches, triangles, and set-pass work
Memory	Texture, render-target, mesh, and managed-memory pressure
Target resolution and quality level	The exact workload and URP Asset used during the test
Visual reference	Whether a faster configuration still meets the project's quality target

Use the same scene state and camera movement for every comparison. A faster result at a different resolution or quality level is not a valid before-and-after measurement.

1. Disable Unused Render Textures

Several URP options allocate or copy additional render textures:

• Disable Depth Texture unless a shader, post-processing effect, or renderer feature samples scene depth.
• Disable Opaque Texture unless an effect samples the camera's opaque color.
• Disable High Dynamic Range (HDR) when the project does not need HDR rendering. If HDR is required, Unity recommends 32 Bit HDR precision as the lower-cost option.
• In the Universal Renderer, set Intermediate Texture to Auto so URP creates it only when necessary.

Use Unity's Frame Debugger to confirm whether the intermediate texture or an extra copy pass disappears. If an effect breaks, restore the texture it requires rather than leaving the dependency undocumented.

2. Reduce the Number of Pixels Rendered

Pixel cost grows with render resolution, anti-aliasing samples, fullscreen passes, and overdraw.

• Test a Render Scale below 1.0 and choose an upscaling filter appropriate for the target.
• Reduce or disable Anti-aliasing (MSAA) when the visual result remains acceptable.
• Remove post-processing overrides that do not materially affect the scene.
• Reduce transparent layers, particles, and fullscreen effects when GPU time rises with resolution.

Render Scale changes the internal render-target resolution, not the device's display resolution. Compare fine geometry, UI composition, text, and motion before keeping a lower value.

3. Reduce Shadow Work

Shadow maps require additional rendering and memory. In the URP Asset:

• Reduce Shadows > Max Distance.
• Reduce Cascade Count.
• Lower the main light's Shadow Resolution.
• Lower the additional-light Shadow Atlas Resolution.
• Disable Additional Lights > Cast Shadows when those shadows are not required.
• Disable Soft Shadows, or reduce their quality.

Test the camera positions where cascade transitions and distant shadows are most visible. Baked lighting can replace some real-time lighting in scenes with static geometry.

4. Limit Additional Lights

Additional lights increase lighting calculations and can add shadow passes.

• Set Additional Lights to Disabled when the scene does not use them.
• With the Forward rendering path, test Per Vertex lighting on lower-end targets.
• Reduce the per-object light limit where that setting applies.
• Disable unused light cookies, or reduce their atlas resolution and format.

Inspect characters, moving objects, and small props before keeping per-vertex lighting; low-density meshes can show visibly different light interpolation.

5. Remove Unnecessary Render Passes and Cameras

Every camera requires culling and rendering resources. Renderer features can also insert passes into the frame.

1. Disable one Renderer Feature at a time.
2. Inspect the frame with the Frame Debugger.
3. Remove unused cameras and prevent inactive cameras from rendering.
4. Minimize decals when their extra pass is not justified.
5. If using Deferred rendering, disable Use Rendering Layers when the project does not need it.

Features such as decals, screen-space ambient occlusion, outlines, blits, and custom fullscreen passes should remain only when their visual contribution is worth the measured CPU, GPU, and memory cost.

6. Use Simpler Shaders and the SRP Batcher

Unity recommends avoiding Complex Lit when its extra lighting calculations are unnecessary. For lower-end mobile targets, Unity identifies Baked Lit for static objects and Simple Lit for dynamic objects as lower-cost options.

Enable the SRP Batcher and verify that custom shaders are compatible with it. The SRP Batcher reduces CPU setup work between compatible draw calls by keeping material data persistent in GPU memory; it does not remove the cost of complex shader instructions, transparency, or overdraw.

Also remove unused shader variants so builds do not retain variants for features the application never enables.

7. Use Platform-Specific Pipeline Assets

Different hardware tiers rarely need identical rendering settings. Assign an appropriate URP Asset to each supported Quality level and confirm which quality level each platform uses.

Platform-specific assets can vary:

• Render Scale and anti-aliasing
• HDR and render-texture requirements
• shadow distance, resolution, and cascades
• additional lights
• post-processing quality
• renderer features

Retest on every target device after changing the assigned asset. Do not assume a desktop capture predicts mobile GPU time, memory bandwidth, or thermal behavior.

High-Impact Settings Checklist

These are test candidates, not universal values:

Setting	Test
Depth Texture	Disable when no active shader or effect samples scene depth
Opaque Texture	Disable when no active shader or effect samples opaque color
HDR	Disable when HDR rendering is not required
Intermediate Texture	Set to Auto
Render Scale	Test below 1.0
MSAA	Test the lowest acceptable sample count
Shadow Max Distance	Reduce until the loss becomes visible
Cascade Count	Use the lowest acceptable count
Additional-light shadows	Disable where they are not required
Renderer Features	Remove features that do not justify their passes
SRP Batcher	Enable and verify shader compatibility

Compare the Result

After each change:

1. Create the same Development Build configuration.
2. Capture the same workload on the same device.
3. Compare CPU frame time, GPU frame time, memory, and rendering statistics.
4. Compare screenshots or video from the same camera path.
5. Record the setting, measured change, and visual tradeoff.

If the result falls within normal run-to-run variation, repeat the capture before treating it as an improvement.

Troubleshooting

Help! Disabling Depth Texture or Opaque Texture broke an effect.

The shader, post-processing override, or Renderer Feature depends on that texture. Re-enable it, identify the dependency with the Frame Debugger or shader documentation, and include its cost in the feature decision.

Help! The Profiler result changes every time I test.

Use the same device, build, resolution, quality level, scene state, and camera path. Capture multiple runs after the application has warmed up, then compare a representative range instead of one unusually fast or slow frame.

Help! Lower Render Scale makes the image too soft.

Restore the previous value or test a smaller reduction and a different supported upscaling filter. Check text, thin geometry, particle edges, and motion before approving the result.

Help! Shadows disappear too close to the camera.

Increase Shadow Max Distance to the shortest distance that covers the important view, then retest cascade count and resolution separately. Baked lighting may be a better fit for static background geometry.

Help! A custom shader is not compatible with the SRP Batcher.

Check the shader's Inspector and Unity's SRP Batcher compatibility requirements. Keep the shader outside the batcher until its constant-buffer declarations are corrected; enabling the project setting alone cannot make an incompatible shader compatible.

Official References

• Unity 6 Manual: Configure for Better Performance in URP
• Unity 6 Manual: Optimize for Better Performance in URP
• Unity 6 Manual: Universal Render Pipeline Asset Reference
• Unity 6 Manual: Unity Profiler
• Unity 6 Manual: Frame Debugger
• Unity 6 Manual: Scriptable Render Pipeline Batcher
• VRChat Creation: Getting Started

Continue Learning

• URP Guides
• Set Up and Verify URP in Unity 6
• Use URP Renderer Features in Unity 6
• Simple Occlusion Culling
• Optimizing Unity Worlds for Performance