Documentation

WithoutPostProcessing captures at BeforeRenderingTransparents. Any 3D object that hasn't rendered yet at that point is entirely absent from the captured texture.

Workaround: use WithPostProcessing on a Screen Space Overlay canvas — it captures after all geometry has finished rendering.

Unity draws Screen Space Camera canvases on top of World Space canvases regardless of scene hierarchy. Additionally, the two canvas modes capture at different stages, so neither blur can see the other's panel content.

There is no workaround for this combination. Change the Screen Space Camera canvas to Screen Space Overlay instead — Overlay always renders after World Space geometry, so layering and blur capture both work correctly.

Screen-space blur has no concept of depth — each pass blurs neighboring pixels in the captured texture regardless of what the camera considers in front of or behind the panel. An opaque object standing between the camera and a world-space panel (a BlurObject, or a BlurImage on a World Space / Screen Space Camera canvas) can bleed its color into the blur near the panel's edges, even at pixels the object doesn't actually occlude — most noticeable with bright or highly saturated objects. This is inherent to screen-space blur convolution in general, not specific to any one algorithm here.

Workaround: keep strongly emissive or brightly lit objects a little further from panel edges, or lower the blur radius/iterations on that profile if the bleed is noticeable.

When two BlurImage panels are rendered by the same camera, both capture at BeforeRenderingTransparents — the same moment in the same frame. The front panel's blur runs before the back panel has been composited into the color buffer, so it samples the raw scene rather than the already-blurred backdrop.

Screen Space Overlay: no workaround. All Overlay canvases render through the same implicit camera and share the same capture point.

Workaround — separate canvases on separate cameras via Camera Stack: place each panel on its own Screen Space Camera canvas, each assigned to a different camera. Stack the cameras so the popup camera renders after the backdrop camera. The popup's BlurImage then captures a color buffer that already contains the backdrop blur.

1. Keep your Main Camera with Culling Mask set to Everything.
2. Add a second camera. Set Render Type to Overlay and Culling Mask to UI only. Match projection, FOV, and clipping planes to the Main Camera.
3. Make the new camera a child of the Main Camera and zero its local position and rotation.
4. In the Main Camera's Camera Stack, add the new camera as the last entry.
5. Set the backdrop canvas to Screen Space Camera, Render Camera = Main Camera.
6. Set the popup canvas to Screen Space Camera, Render Camera = Stack Camera.

Both canvases must use Screen Space Camera mode — placing both panels on the same canvas or the same camera will not work even with a Camera Stack. Use a separate BlurProfile per panel to control each independently.

Overlay + WithPostProcessing captures after all geometry — opaque, transparent, world-space, and 3D objects — and includes post-processing effects. It is the most reliable option when you need the blur to include all scene content.

• Confirm the Blur Renderer Feature is added and enabled on the active URP Renderer asset.

• Ensure a BlurProfile is assigned to the BlurImage component.

• If using WithPostProcessing, confirm the Canvas is set to Screen Space Overlay.

• Reduce downsample — high values produce a low-resolution RT that becomes visible at low blur strength or when intensity is below 1.

• Increase iterations or blurOffset to widen the blur and soften the pixelation.

• Check updateMode on the profile — Throttled with throttleFps = 0 intentionally freezes the blur after the first frame.

• Confirm at least one BlurImage referencing the profile is enabled and visible — profiles with no active consumers stop running automatically.

• The distortion UV is sampling outside the blur RT's scissor region. The scissor automatically expands to cover the distortion range — confirm bumpStrength is not larger than the panel's screen-space margin allows.

• Move the panel away from screen edges, or reduce bumpStrength.

• Switch to Dual Kawase (lowest cost per quality).

• Increase downsample to 4 and reduce iterations to 2.

• See Performance Tips below for profiling-level optimisations.

• Open it manually via Tools → UIBlurPro → Setup Wizard.

• If no renderers appear, create a URP Universal Renderer asset first: Assets → Create → Rendering → URP Universal Renderer.

• This package's Materials are created purely at runtime, so no .mat asset in your project directly references these shaders — Unity's build pipeline strips any shader nothing references, which would otherwise remove them from the build even though everything works fine in the Editor.

• The bundled Runtime/Resources/ folder contains one dummy Material per shader specifically to prevent this — anything inside a Resources folder is always included in a build. Don't delete or move these Materials out of Resources/.

• If you still see this after confirming the Resources/ folder is intact, do a full clean Player build (delete Library/ShaderCache or the whole Library folder) so shaders recompile from scratch.

• The Scene view camera is separate from the Game camera and may capture at a different resolution or with different post-processing. Always treat Game view as the reference.

• If the Scene view blur looks distorted, this is expected — the scissor rect is computed from the Game camera's viewport, not the Scene camera's.

If multiple panels need identical blur parameters, assign them the same BlurProfile. The pass chain runs once and all panels sample the same result — zero additional GPU cost per extra panel.

Set updateMode to Throttled for panels over a mostly-still background. Skipped frames reuse the last blurred result at zero added cost.

Set throttleFps to 0 to freeze the blur after its first frame — ideal for pause menus, modals, and any background that does not move while the panel is open.

Each distinct CaptureMode branch (WithoutPostProcessing / WithPostProcessing) is a separate pass chain with its own render textures. Mixing capture modes on the same profile doubles the GPU and memory cost for that profile.

Each active profile is an independent pass chain. Consolidate panels that share parameters into fewer profiles rather than giving every panel its own profile.

A profile's pass chain stops running automatically when all its BlurImage consumers are disabled or invisible. Disable the component (not just the GameObject's alpha) when a panel is fully hidden to eliminate its cost entirely.