Fix: Unity URP Render Feature Not Executing

Here is how to fix a Unity URP render feature that silently does nothing. You wrote a ScriptableRendererFeature, added logging to Execute, enabled it in the renderer data asset, pressed Play — silence. No logs, no visible effect. The feature is clearly alive (it compiles, it shows up in the Inspector) but nothing runs. URP has four separate points where a feature can be skipped, and missing any one means zero execution.

The Symptom

• ScriptableRendererFeature is in the project but its effect does not render
• Execute log statements never appear in Console
• Feature shows in Frame Debugger? Sometimes yes, sometimes no
• Works in one scene, not another
• Works in Editor, fails in build

What Causes This

Render pipeline asset mismatch. Unity has two places a URP asset can be assigned: Project Settings > Graphics > Scriptable Render Pipeline Settings (global default), and Project Settings > Quality > Rendering > Render Pipeline Asset (per quality level). The quality-level asset wins. If Graphics points at AssetA and the active Quality level points at AssetB, AssetB is what renders — and if AssetB references a different renderer, your feature is ignored.

Renderer data asset missing the feature. The URP asset references one or more renderer assets (UniversalRendererData). Each renderer has its own list of Renderer Features. If your feature is in Renderer A but the active URP asset uses Renderer B, the feature is dormant.

Feature checkbox off. Even listed, each feature has an enabled checkbox. If you added it while testing then unchecked it, Create does not run, AddRenderPasses does not run, Execute does not run.

AddRenderPasses does not enqueue. The ScriptableRendererFeature override of AddRenderPasses is called every frame per camera. If the method body does not call renderer.EnqueuePass(yourPass), nothing runs. Common mistake: early return when camera type is not Game.

Render Pass Event misconfigured. If your pass’s event is set to a stage that the current camera does not execute (e.g. AfterRenderingPostProcessing on a camera with post-processing disabled), the pass is queued but skipped.

The Fix

Step 1: Minimal working feature. Start with a known-good template and log at every stage:

using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;

public class DebugFeature : ScriptableRendererFeature
{
    class DebugPass : ScriptableRenderPass
    {
        public override void Execute(ScriptableRenderContext ctx, ref RenderingData data)
        {
            Debug.Log("DebugPass.Execute for " + data.cameraData.camera.name);
        }
    }

    DebugPass pass;

    public override void Create()
    {
        pass = new DebugPass();
        pass.renderPassEvent = RenderPassEvent.AfterRenderingOpaques;
        Debug.Log("DebugFeature.Create");
    }

    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData data)
    {
        Debug.Log("DebugFeature.AddRenderPasses for " + data.cameraData.camera.name);
        renderer.EnqueuePass(pass);
    }
}

Deploy this. Check the Console. If Create runs but AddRenderPasses does not, the feature is enabled but the renderer is not used. If AddRenderPasses runs but Execute does not, the pass event is wrong or the enqueue was skipped.

Step 2: Verify URP asset assignment. Project Settings > Graphics. Confirm the Scriptable Render Pipeline Settings field is assigned to the URP asset you expect. Then go to Project Settings > Quality. For each quality level, confirm the Render Pipeline Asset field. Set it explicitly per level or leave blank to fall back to Graphics.

For builds, check the quality level that is active in the build (usually the highest level included). If the quality-level URP asset differs from the Graphics one, the quality-level one is used.

Step 3: Confirm renderer assignment. Select the URP asset. Look at the Renderer List field. The default renderer index determines which renderer runs. Open that renderer data asset and look at Renderer Features. Your feature must be present and checked.

Step 4: Check pass event. RenderPassEvent values include BeforeRendering, AfterRenderingOpaques, AfterRenderingSkybox, AfterRenderingTransparents, AfterRenderingPostProcessing. Use BeforeRenderingPostProcessing for effects that should be post-processed, or AfterRendering for final image work.

Some events are skipped on specific camera types. Overlay cameras skip post-processing events unless the base camera enables them. If your feature must run on Overlay cameras, use BeforeRenderingOpaques or similar.

Step 5: Filter cameras explicitly. If you want the feature only on the Main Camera:

public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData data)
{
    if (data.cameraData.cameraType != CameraType.Game) return;
    if (data.cameraData.camera.CompareTag("NoFeature")) return;
    renderer.EnqueuePass(pass);
}

Explicit filters prevent the feature running on Scene View or Preview cameras unintentionally, and also prevent it running on all cameras when you meant only one.

Debugging With Frame Debugger

Window > Analysis > Frame Debugger. Click Enable. Step through the frame. If your pass is correctly enqueued and executed, you see a draw call labeled with your pass’s profiler tag. If you see no entry, Execute did not run — check enqueue. If you see an entry but no visible effect, the pass is running but not writing to the target.

Add a profiling scope for easy identification:

public override void Execute(ScriptableRenderContext ctx, ref RenderingData data)
{
    CommandBuffer cmd = CommandBufferPool.Get("DebugFeature");
    using (new ProfilingScope(cmd, new ProfilingSampler("DebugFeature")))
    {
        // render work
    }
    ctx.ExecuteCommandBuffer(cmd);
    CommandBufferPool.Release(cmd);
}

“URP has four gates between feature and pixel. Execute is the last one. If you do not see the log, you failed at gate 1, 2, or 3.”

Build-Specific Issues

In Editor, Unity often falls back to reasonable defaults. In builds, missing URP asset assignments are silent failures. Always specify the Render Pipeline Asset on every Quality level you ship, and test a built player before shipping.

For shader-related URP issues, see Unity Shader Magenta/Pink.

Check URP asset. Check renderer. Check feature checkbox. Check enqueue. In that order.