Fix: Unity SpriteRenderer Not Visible or Not Rendering

Here is how to fix Unity sprite renderer not visible. Your sprite is in the scene, the SpriteRenderer component has a sprite assigned, and the GameObject is active — but nothing appears on screen. The Scene view might show a faint outline or nothing at all, and the Game view is completely blank where your sprite should be. This is a deceptively common problem in Unity 2D development, and it is almost never a bug in Unity itself. The sprite is there; the rendering pipeline just has a reason not to draw it.

The Symptom

You drag a sprite into the scene or create a GameObject with a SpriteRenderer component. You assign a sprite texture. In the Scene view, you can see the sprite gizmo or selection outline, but the actual sprite image does not appear. In the Game view, the sprite is completely invisible.

Alternatively, the sprite appeared correctly at first, but after rearranging your scene, adding new sprites, or adjusting camera settings, it vanished. You have not deleted it and the GameObject is still active in the Hierarchy. The SpriteRenderer component is enabled. But the sprite simply does not render.

In some cases, the sprite flickers in and out of visibility depending on the camera position, or it shows in the Scene view but not the Game view (or vice versa). All of these variations point to the same underlying causes.

What Causes This

There are six common causes, often overlapping in the same project:

1. Sorting layer or order in layer conflict. If your sprite is on a sorting layer that renders behind another opaque sprite or tilemap that covers the same screen area, your sprite is drawn first and then completely overwritten. This is the number one cause. Unity draws lower sorting layers first and lower order values first within the same layer. A background sprite with Order in Layer = 10 will cover a character sprite with Order in Layer = 5 on the same layer.

2. Z position outside camera clipping range. Even in 2D, the Transform's Z position matters. Unity's default orthographic camera has a near clipping plane at 0.3 and far clipping plane at 1000. If your sprite's Z position is behind the camera (e.g., Z = -0.5 when the camera is at Z = -10) or beyond the far plane, the camera culls it entirely. The sprite exists in the world but the camera refuses to render it.

3. Color alpha set to 0. The SpriteRenderer has a Color property with RGBA values. If the alpha (A) channel is set to 0, the sprite is fully transparent. This happens more often than you would expect — animation curves that affect color, scripts that fade sprites out and forget to fade them back in, or accidentally dragging the alpha slider in the Inspector.

4. Camera culling mask excludes the sprite's layer. Unity cameras have a Culling Mask that determines which layers they render. If your sprite's GameObject is on a layer that is not included in the camera's culling mask, the camera ignores it entirely. This is different from sorting layers — this is the GameObject's layer in the Inspector header, not the SpriteRenderer's sorting layer.

5. Wrong material or shader. The default material for SpriteRenderer is Sprites-Default, which uses a shader designed for 2D sprites with transparency. If you accidentally assigned a 3D material (like Standard or URP Lit), the sprite may render as a solid color, render black, or not render at all because the shader expects mesh UVs and lighting data that sprites do not provide.

6. Sprite not assigned or wrong texture import settings. If the Sprite field on the SpriteRenderer is None, nothing renders. Additionally, if your texture's import settings have Texture Type set to something other than Sprite (2D and UI), Unity will not generate the sprite data needed for rendering.

The Fix

Step 1: Fix sorting layer and order in layer. Select your invisible sprite's SpriteRenderer and check the Sorting Layer and Order in Layer fields. Then check all other sprites in the scene that might overlap it. The sprite you want on top needs a higher sorting layer or a higher order in layer value.

using UnityEngine;

public class SortingDebugger : MonoBehaviour
{
    void Start()
    {
        // Log sorting info for every SpriteRenderer in the scene
        var renderers = FindObjectsByType<SpriteRenderer>(FindObjectsSortMode.None);
        foreach (var sr in renderers)
        {
            Debug.Log($"{sr.gameObject.name}: Layer={sr.sortingLayerName}, " +
                     $"Order={sr.sortingOrder}, Z={sr.transform.position.z}, " +
                     $"Color={sr.color}, Enabled={sr.enabled}");
        }
    }
}

// Fixing sorting in code:
public class SpriteSortingFix : MonoBehaviour
{
    void Awake()
    {
        var sr = GetComponent<SpriteRenderer>();

        // Set sorting layer (must exist in Tags and Layers settings)
        sr.sortingLayerName = "Characters";

        // Set order within the sorting layer
        sr.sortingOrder = 10;
    }
}

You can manage sorting layers in Edit > Project Settings > Tags and Layers. A typical 2D game might use: Background (bottom), Midground, Characters, Foreground, UI (top). Layers listed lower in the settings render on top.

Step 2: Verify Z position and camera clipping planes. Select your sprite and check the Z value in the Transform component. For 2D games, sprites should generally be at Z = 0 or within a small range. Then select your camera and check the Clipping Planes values.

using UnityEngine;

public class CameraClipChecker : MonoBehaviour
{
    void Start()
    {
        Camera cam = Camera.main;
        if (cam == null)
        {
            Debug.LogError("No main camera found! Tag a camera as MainCamera.");
            return;
        }

        Debug.Log($"Camera Z: {cam.transform.position.z}");
        Debug.Log($"Near clip: {cam.nearClipPlane}, Far clip: {cam.farClipPlane}");

        // Check all sprites against camera clipping range
        float camZ = cam.transform.position.z;
        var renderers = FindObjectsByType<SpriteRenderer>(FindObjectsSortMode.None);
        foreach (var sr in renderers)
        {
            float distance = Mathf.Abs(sr.transform.position.z - camZ);
            if (distance < cam.nearClipPlane || distance > cam.farClipPlane)
            {
                Debug.LogWarning($"CULLED: {sr.gameObject.name} at Z={sr.transform.position.z} " +
                                $"(distance {distance} outside clip range)");
            }
        }
    }
}

For a standard 2D setup, the camera sits at Z = -10 and sprites sit at Z = 0. The distance is 10 units, comfortably within the default clip range. Problems arise when sprites get pushed to extreme Z values through physics, animation, or parent transforms.

Step 3: Check color alpha, GameObject layer, and material.

using UnityEngine;

public class SpriteVisibilityFix : MonoBehaviour
{
    void Start()
    {
        var sr = GetComponent<SpriteRenderer>();
        if (sr == null)
        {
            Debug.LogError("No SpriteRenderer on this GameObject!");
            return;
        }

        // Check 1: Is a sprite assigned?
        if (sr.sprite == null)
        {
            Debug.LogError("No sprite assigned to SpriteRenderer!");
            return;
        }

        // Check 2: Is alpha zero?
        if (sr.color.a < 0.01f)
        {
            Debug.LogWarning("Sprite alpha is near zero! Resetting to 1.");
            sr.color = new Color(sr.color.r, sr.color.g, sr.color.b, 1f);
        }

        // Check 3: Is the camera culling this layer?
        Camera cam = Camera.main;
        if (cam != null)
        {
            int objLayer = gameObject.layer;
            if ((cam.cullingMask & (1 << objLayer)) == 0)
            {
                Debug.LogWarning($"Camera culling mask excludes layer {objLayer} " +
                                $"({LayerMask.LayerToName(objLayer)}). Sprite will not render.");
            }
        }

        // Check 4: Is the material correct?
        if (sr.sharedMaterial != null)
        {
            Debug.Log($"Material: {sr.sharedMaterial.name}, " +
                     $"Shader: {sr.sharedMaterial.shader.name}");
        }
    }
}

For the material issue specifically, the SpriteRenderer should use the Sprites/Default shader (built-in pipeline) or Universal Render Pipeline/2D/Sprite-Lit-Default (URP). If you are using URP and your sprites render as pink, you need to convert your materials to URP-compatible shaders via Edit > Rendering > Materials > Convert Built-in Materials.

A quick way to reset everything to visible defaults: select the SpriteRenderer, set Sorting Layer to Default, Order in Layer to 0, Color to white (RGBA 1,1,1,1), and Material to Sprites-Default. If the sprite appears, one of your customized settings was the problem. Reapply them one at a time to find the culprit.

Related Issues

If your sprites render but your physics-driven objects do not move, see AddForce not working on Rigidbody for common Rigidbody configuration mistakes. If sprites render in the editor but vanish in builds, check Build Missing Scenes or Resources — texture import settings and asset inclusion can change between editor and player builds.

If you can select it in the Hierarchy but cannot see it, check the alpha first.