Fix: Unity URP or HDRP Rendering Errors After Upgrade

Here is how to fix Unity scriptable render pipeline errors. You upgraded your Unity project to the Universal Render Pipeline (URP) or High Definition Render Pipeline (HDRP), and now everything is pink. Or shadows are gone. Or the camera renders black. Or post-processing effects disappeared. Switching render pipelines in Unity is one of the most disruptive changes you can make to a project, and the upgrade path has many steps that are easy to miss. This guide covers each failure mode and its fix.

Setting Up the Render Pipeline Asset

The render pipeline asset is the central configuration object that tells Unity which rendering path to use. If this asset is missing or misconfigured, rendering will either fall back to the Built-in pipeline (making your SRP materials appear pink) or fail entirely.

There are two places where the pipeline asset must be assigned, and missing either one causes problems:

1. Graphics Settings: Go to Edit → Project Settings → Graphics. The Scriptable Render Pipeline Settings field must reference your URP or HDRP asset. If this is null, Unity uses the Built-in pipeline.

2. Quality Settings: Go to Edit → Project Settings → Quality. Each quality level has its own Render Pipeline Asset field. If any quality level has a null or different pipeline asset, switching to that quality level at runtime will break rendering.

// Common mistake: checking the pipeline at runtime
// This will be null if the asset is not assigned in Quality settings
var pipeline = QualitySettings.renderPipeline;
if (pipeline == null)
{
    Debug.LogError("No render pipeline asset assigned for current quality level!");
    Debug.LogError($"Current quality level: {QualitySettings.names[QualitySettings.GetQualityLevel()]}");
}

A subtle variant: you might have the pipeline asset assigned in Graphics settings but not in Quality settings. Unity uses the Quality settings value when it is not null, and falls back to the Graphics settings value. If any quality level has an explicit null override, that quality level reverts to Built-in rendering.

Material Conversion: The Pink Material Fix

Pink/magenta materials are the most visible symptom of a render pipeline mismatch. They mean the shader assigned to a material is not compatible with the active pipeline. The Built-in Standard shader does not work with URP, and URP’s Universal Render Pipeline/Lit shader does not work with the Built-in pipeline.

Unity provides a batch conversion tool. For URP:

Edit → Rendering → Materials → Convert Built-in to URP

For HDRP:

Edit → Rendering → Materials → Convert Built-in to HDRP

This tool attempts to remap shader properties from the old shader to the new equivalent. It handles the Standard shader well, converting metallic/smoothness values, normal maps, and emission. But it has limitations:

Custom shaders are not converted. Any shader you or an Asset Store package wrote for the Built-in pipeline will remain pink. These need to be rewritten in Shader Graph or manually ported to the URP/HDRP shader API.

Particle shaders often do not convert cleanly. The particle rendering path changed significantly in URP. Check every particle system after conversion.

Terrain shaders are replaced automatically, but terrain layer settings (diffuse textures, normal maps, metallic values) may need manual adjustment after conversion.

// Script to find all materials using incompatible shaders
// Run this after pipeline conversion to catch anything missed
using UnityEditor;
using UnityEngine;

public class FindBrokenMaterials
{
    [MenuItem("Tools/Find Pink Materials")]
    static void Find()
    {
        string[] guids = AssetDatabase.FindAssets("t:Material");
        foreach (string guid in guids)
        {
            string path = AssetDatabase.GUIDToAssetPath(guid);
            Material mat = AssetDatabase.LoadAssetAtPath<Material>(path);
            if (mat != null && mat.shader != null)
            {
                string shaderName = mat.shader.name;
                if (shaderName == "Hidden/InternalErrorShader" ||
                    shaderName.StartsWith("Standard"))
                {
                    Debug.LogWarning($"Broken material: {path} (shader: {shaderName})");
                }
            }
        }
    }
}

Shader Graph Compatibility

If you are using Shader Graph, your graphs need to target the correct pipeline. A Shader Graph created for the Built-in pipeline will not compile in a URP project, and vice versa.

When you open a Shader Graph in the wrong pipeline, it may show errors about missing nodes or unsupported features. The fix depends on complexity:

Simple graphs: Recreate them in the target pipeline. Change the graph’s Active Targets in the Graph Settings panel to include URP or HDRP.

Complex graphs: Open Graph Settings (the gear icon in the Shader Graph editor), go to the Active Targets section, and add your target pipeline. Some nodes may not be available in all pipelines—the editor will highlight incompatible nodes in red.

Shader Graph supports multi-pipeline targeting. You can have a single graph that compiles for both URP and HDRP by adding both as Active Targets. Pipeline-specific nodes will only compile for their respective pipeline.

URP Renderer Features and Camera Stacking

After the initial material conversion, the next most common issue is missing visual features. Post-processing, shadows, reflections, or depth effects that worked in the Built-in pipeline may be absent in URP because they require explicit configuration.

Post-processing: URP uses Volume components instead of the old Post-Processing Stack. Create a Global Volume game object, add a Volume Profile, and add overrides for Bloom, Color Adjustments, Tonemapping, etc. Enable Post Processing on your camera.

Shadows: Shadow distance and cascades are configured in the URP Asset, not in Quality Settings. Select your URP Asset in the Project window and adjust Shadows → Max Distance and Cascade Count.

Camera stacking: URP changed how multiple cameras work. Instead of depth-ordering cameras, URP uses an explicit Camera Stack. Set your main camera type to Base and overlay cameras to Overlay, then add overlays to the base camera’s stack list.

// Set up camera stacking in code
using UnityEngine.Rendering.Universal;

var baseCameraData = mainCamera.GetUniversalAdditionalCameraData();
baseCameraData.renderType = CameraRenderType.Base;

var overlayCameraData = uiCamera.GetUniversalAdditionalCameraData();
overlayCameraData.renderType = CameraRenderType.Overlay;

// Add the overlay camera to the base camera's stack
baseCameraData.cameraStack.Add(uiCamera);

HDRP Volume Profiles and Frame Settings

HDRP uses a Volume system extensively for everything from post-processing to fog, sky, and exposure. If your HDRP scene looks washed out, too dark, or has no sky, you are likely missing Volume overrides.

Every HDRP scene needs at minimum a Global Volume with:

Visual Environment: Sets the sky type (HDRI, Procedural, Physically Based) and fog type.

HDRI Sky (or your chosen sky type): Configures the sky appearance and ambient lighting.

Exposure: Controls how the camera adapts to brightness. Without this, scenes can appear extremely bright or dark.

Tonemapping: Maps HDR color values to display range. Without it, highlights will clip harshly.

HDRP also has Frame Settings on each camera that control which rendering features are enabled. If a feature works in the Scene view but not in the Game view, check the Game camera’s Frame Settings. Common issues include SSAO, screen-space reflections, and volumetric fog being disabled per-camera.

“Switching render pipelines is not just a settings change—it is a project-wide migration. Budget at least a full day for a small project, a full week for a large one. Convert materials, verify every scene, test on target hardware, and fix visual differences one by one.”

Related Issues

If your materials show pink but you are not switching pipelines, see Fix: Unity Shader Pink/Magenta Material. For shadow-specific issues like flickering or Z-fighting, check Fix: Unity Shadow Flickering and Z-Fighting. For capturing rendering bugs from player devices, read Bug Reporting Tools for Unity Developers.

The pipeline asset must be assigned in both Graphics settings and Quality settings. Convert all materials with the batch tool, then manually fix particles, terrain, and custom shaders. Check every scene in Play mode after conversion.