Fix: Unity Camera Not Rendering or Showing Black Screen

Here is how to fix Unity camera not rendering. You hit Play and the Game view is completely black. Your scene has objects, lights, and a camera — but nothing renders. Or maybe one of your cameras renders fine while another shows nothing. Camera rendering issues in Unity can stem from a handful of specific settings, and once you know the checklist, the fix is usually a one-property change in the Inspector.

The Symptom

The Game view shows a solid black screen, a solid color that is not your skybox, or only a partial render (for example, the UI renders but the 3D scene does not). The Scene view may look perfectly fine, which makes the issue more confusing. In multi-camera setups, one camera might work while another shows black or overwrites the first camera's output.

A variation of this problem occurs when the camera works in the Unity Editor but shows a black screen in a standalone build. This is a strong indicator of a render pipeline configuration issue. Another variation is that objects disappear as the camera moves — they pop in and out of existence at certain distances or angles.

What Causes This

Camera rendering depends on several interrelated settings. The most common causes of a black screen are:

• Culling Mask not including object layers — Every Camera has a Culling Mask that determines which layers it renders. If your objects are on a layer that the camera is not set to render, they will be invisible to that camera. The default Culling Mask is "Everything," but it may have been changed.
• Clear Flags set incorrectly — The Clear Flags property controls what the camera renders behind geometry. If set to "Don't Clear" on your only camera, you may see garbage data or a black screen. If set to "Depth Only" without another camera rendering first, you get black.
• Camera depth order wrong — When using multiple cameras, the depth property controls rendering order. A camera with a higher depth renders on top. If an overlay camera has the wrong clear flags, it can overwrite the main camera's output entirely.
• Near/far clip plane misconfiguration — The near clip plane sets the closest distance the camera renders. If it is set too far (say, 10 instead of 0.3), nearby objects disappear. If the far clip plane is too short, distant objects are clipped. Setting the near clip plane to 0 can also cause z-fighting and rendering artifacts.
• Missing Render Pipeline Asset — If your project uses URP or HDRP but the pipeline asset is not assigned in Project Settings > Graphics, the camera will render black in builds even if it looks fine in the editor.
• Camera disabled or wrong tag — The camera component might be disabled, or the MainCamera tag might be on the wrong object. Some scripts use Camera.main, which returns the first active camera tagged "MainCamera."

The Fix

Step 1: Check Culling Mask and Clear Flags. Select the Camera in the Inspector. Set the Culling Mask to "Everything" to confirm objects are on layers the camera can see. Set Clear Flags to "Skybox" (if you have one) or "Solid Color." Make sure the camera component is enabled.

using UnityEngine;

public class CameraDebugger : MonoBehaviour
{
    private void Start()
    {
        Camera cam = GetComponent<Camera>();
        if (cam == null)
        {
            Debug.LogError("No Camera component on " + gameObject.name);
            return;
        }

        Debug.Log("Camera enabled: " + cam.enabled);
        Debug.Log("Culling Mask: " + cam.cullingMask);
        Debug.Log("Clear Flags: " + cam.clearFlags);
        Debug.Log("Depth: " + cam.depth);
        Debug.Log("Near Clip: " + cam.nearClipPlane);
        Debug.Log("Far Clip: " + cam.farClipPlane);

        // Quick fix: reset to safe defaults
        if (cam.cullingMask == 0)
        {
            Debug.LogWarning("Culling Mask is Nothing! Setting to Everything.");
            cam.cullingMask = ~0; // All layers
        }

        if (cam.clearFlags == CameraClearFlags.Nothing)
        {
            Debug.LogWarning("Clear Flags set to Don't Clear. Changing to Skybox.");
            cam.clearFlags = CameraClearFlags.Skybox;
        }
    }
}

Step 2: Fix clip planes and camera depth for multi-camera setups. Set the near clip plane to 0.1 or 0.3 (never 0). Set the far clip plane high enough to encompass your entire scene. For multiple cameras, assign depth values so the main camera renders first (lower depth) and overlay cameras render after (higher depth).

using UnityEngine;

public class MultiCameraSetup : MonoBehaviour
{
    [SerializeField] private Camera mainCamera;
    [SerializeField] private Camera uiCamera;
    [SerializeField] private Camera minimapCamera;

    private void Start()
    {
        // Main camera: renders the 3D scene
        mainCamera.depth = 0;
        mainCamera.clearFlags = CameraClearFlags.Skybox;
        mainCamera.cullingMask = ~0; // Everything
        mainCamera.nearClipPlane = 0.3f;
        mainCamera.farClipPlane = 1000f;

        // UI camera: renders only the UI layer on top
        uiCamera.depth = 1;
        uiCamera.clearFlags = CameraClearFlags.Depth; // Don't clear color
        uiCamera.cullingMask = 1 << LayerMask.NameToLayer("UI");

        // Minimap camera: renders to a RenderTexture
        minimapCamera.depth = -1;
        minimapCamera.clearFlags = CameraClearFlags.SolidColor;
        minimapCamera.backgroundColor = Color.black;
        minimapCamera.cullingMask = LayerMask.GetMask("Default", "Terrain");
        minimapCamera.orthographic = true;
        minimapCamera.orthographicSize = 50f;
    }
}

Step 3: Verify the render pipeline configuration. If you are using the Universal Render Pipeline (URP) or the High Definition Render Pipeline (HDRP), you must assign the pipeline asset in Project Settings. Without it, the camera has no renderer and will produce a black screen, especially in builds.

using UnityEngine;
using UnityEngine.Rendering;

public class PipelineChecker : MonoBehaviour
{
    private void Start()
    {
        // Check if a Scriptable Render Pipeline is active
        RenderPipelineAsset pipeline = GraphicsSettings.currentRenderPipeline;

        if (pipeline != null)
        {
            Debug.Log("Active Render Pipeline: " + pipeline.name);
            Debug.Log("Pipeline type: " + pipeline.GetType().Name);
        }
        else
        {
            Debug.Log("Using Built-in Render Pipeline (no SRP asset assigned).");
        }

        // In URP, also check Quality Settings for per-quality pipeline overrides
        RenderPipelineAsset qualityPipeline = QualitySettings.renderPipeline;
        if (qualityPipeline != null)
        {
            Debug.Log("Quality-level pipeline override: " + qualityPipeline.name);
        }

        // Verify the main camera exists
        if (Camera.main == null)
        {
            Debug.LogError("Camera.main is null. Ensure a camera is tagged 'MainCamera'.");
        }
    }
}

For URP specifically, go to Project Settings > Graphics and assign your UniversalRenderPipelineAsset in the Scriptable Render Pipeline Settings field. Then check Project Settings > Quality — each quality level can override the pipeline asset. Make sure every quality level either has the same URP asset assigned or is left blank to inherit from Graphics settings. Also open the URP Asset in the Inspector and verify that it has at least one Renderer assigned in the Renderer List.

If your camera suddenly stops rendering after changing scenes, make sure the new scene has a camera. Unity does not carry cameras between scenes unless you use DontDestroyOnLoad. A scene without a camera will render nothing.

Related Issues

See also: Fix: Unity TextMeshPro Text Not Showing or Rendering.

See also: Fix: Unity OnCollisionEnter Not Being Called.

Check culling mask, clear flags, clip planes, and pipeline asset.