Fix: Unity VFX Graph Particles Not Spawning at Runtime

Here is how to fix Unity VFX graph particles not spawning. You have built an incredible particle effect in the VFX Graph editor—explosions, magic spells, ambient dust—and it looks perfect in the preview window. But when you enter Play mode or build the game, nothing appears. No particles, no errors, just empty space where your effect should be. VFX Graph has several gotchas that cause silent failures at runtime, and this guide walks through every one of them.

How VFX Graph Differs from Particle System

VFX Graph is Unity’s GPU-based particle system. Unlike the legacy Particle System (Shuriken) which simulates on the CPU, VFX Graph runs entirely on the GPU using compute shaders. This means it can handle millions of particles but comes with platform restrictions and a different component model.

The key difference for debugging: the VFX Graph editor preview is independent of scene rendering. Particles you see in the graph editor are simulated locally in that window. For particles to appear in the Game view or a build, you need a properly configured Visual Effect component on a GameObject in the scene.

Solution 1: Check the Visual Effect Component

The first thing to verify is that your scene has a GameObject with a Visual Effect component that references your VFX Graph asset, and that the component is enabled and set to play.

using UnityEngine;
using UnityEngine.VFX;

public class VFXValidator : MonoBehaviour
{
    void Start()
    {
        VisualEffect vfx = GetComponent<VisualEffect>();

        if (vfx == null)
        {
            Debug.LogError("No Visual Effect component found on this GameObject.");
            return;
        }

        if (vfx.visualEffectAsset == null)
        {
            Debug.LogError("Visual Effect component has no VFX asset assigned.");
            return;
        }

        if (!vfx.enabled)
        {
            Debug.LogWarning("Visual Effect component is disabled. Enabling it now.");
            vfx.enabled = true;
        }

        // Check if the effect is actually alive (has active particles)
        Debug.Log($"VFX '{vfx.visualEffectAsset.name}' alive count: {vfx.aliveParticleCount}");
    }
}

Common mistakes: the VFX asset field is left empty (None), the component is disabled via the checkbox, or the entire GameObject is inactive. Also check that Play on Awake is enabled in the Visual Effect component if you want the effect to start automatically.

Solution 2: Verify the Spawn Context

Inside the VFX Graph, particles are created by the Spawn context. If the Spawn context is missing, disconnected, or has a spawn rate of zero, no particles will be created even though the rest of the graph is valid.

using UnityEngine;
using UnityEngine.VFX;

public class VFXSpawnDebugger : MonoBehaviour
{
    [SerializeField] private VisualEffect vfx;

    void Update()
    {
        if (vfx == null) return;

        // Log particle counts each frame to diagnose spawn issues
        int alive = vfx.aliveParticleCount;

        if (alive == 0 && vfx.HasAnySystemAwake())
        {
            Debug.LogWarning("VFX system is awake but no particles are alive. " +
                "Check Spawn context rate and Initialize capacity.");
        }
    }

    [ContextMenu("Force Play VFX")]
    public void ForcePlay()
    {
        vfx.Stop();
        vfx.Reinit();
        vfx.Play();
        Debug.Log("VFX reinitialized and playing.");
    }
}

Open your VFX Graph asset and verify: the Spawn context exists and is connected to an Initialize context. The spawn rate or burst count is greater than zero. The Initialize context’s capacity is not set to zero. If using burst spawning via events, ensure the event name matches what your code sends.

Solution 3: Check Compute Shader Support

VFX Graph requires compute shader support on the GPU. Most desktop and console GPUs support this, but many mobile GPUs do not. If you deploy to a device without compute support, VFX Graph effects will silently fail.

using UnityEngine;
using UnityEngine.VFX;

public class VFXPlatformCheck : MonoBehaviour
{
    [SerializeField] private VisualEffect gpuVFX;
    [SerializeField] private ParticleSystem cpuFallback;

    void Awake()
    {
        if (!SystemInfo.supportsComputeShaders)
        {
            Debug.LogWarning("Compute shaders not supported. Falling back to Particle System.");

            // Disable GPU-based VFX Graph effect
            if (gpuVFX != null) gpuVFX.enabled = false;

            // Enable CPU-based fallback particle system
            if (cpuFallback != null)
            {
                cpuFallback.gameObject.SetActive(true);
                cpuFallback.Play();
            }
        }
        else
        {
            Debug.Log($"Compute shaders supported. Max compute work group size: " +
                $"{SystemInfo.maxComputeWorkGroupSize}");

            if (cpuFallback != null) cpuFallback.gameObject.SetActive(false);
        }
    }
}

Always provide a fallback for platforms without compute shader support. Use SystemInfo.supportsComputeShaders at startup to decide whether to use VFX Graph or the legacy Particle System.

Solution 4: Trigger VFX Effects from Code

For effects that should not play automatically—explosions, hit effects, ability visuals—you need to trigger them from code. Disable Play on Awake and use the Visual Effect API to start playback at the right moment.

using UnityEngine;
using UnityEngine.VFX;

public class VFXController : MonoBehaviour
{
    [SerializeField] private VisualEffect explosionVFX;

    public void TriggerExplosion(Vector3 position, float radius)
    {
        // Move the effect to the target position
        explosionVFX.transform.position = position;

        // Set exposed properties before playing
        explosionVFX.SetFloat("ExplosionRadius", radius);
        explosionVFX.SetVector3("ExplosionCenter", position);

        // Reinit clears any leftover particles from previous plays
        explosionVFX.Reinit();

        // Play the effect
        explosionVFX.Play();
    }

    public void TriggerEventBased(string eventName)
    {
        // Send a named event to the VFX Graph
        // The graph must have a corresponding Event context with this name
        VFXEventAttribute attr = explosionVFX.CreateVFXEventAttribute();
        attr.SetFloat("Intensity", 2.5f);
        explosionVFX.SendEvent(eventName, attr);
    }
}

Key points: call Reinit() before Play() if reusing the same effect to clear old particles. Set exposed properties before calling Play(). For event-driven graphs, use SendEvent() with the exact event name defined in the graph’s Event context node.

Solution 5: Render Pipeline Compatibility

VFX Graph requires either the Universal Render Pipeline (URP) or the High Definition Render Pipeline (HDRP). It does not work with the Built-in Render Pipeline. If your project uses the Built-in pipeline, VFX Graph effects will not render.

Check your render pipeline by going to Project Settings → Graphics and looking at the Scriptable Render Pipeline Settings field. If it is empty, you are using the Built-in pipeline and must switch to URP or HDRP to use VFX Graph, or use the legacy Particle System instead.

Also verify that the VFX Graph shaders match your pipeline. A VFX Graph created in an HDRP project will not render correctly if you switch the project to URP without updating the output contexts in the graph.

“VFX Graph fails silently because it runs on the GPU. There are no exceptions or error messages when compute shaders are unsupported or when the spawn context is misconfigured. Always check aliveParticleCount to verify that particles are actually being created.”

Related Issues

If your VFX Graph particles spawn but render as pink squares, see Fix: Unity VFX Graph Pink Particle Output. For performance issues with too many particles, check Fix: Unity VFX Graph Performance Optimization. To collect bug reports that include GPU capabilities and render pipeline info, read Bug Reporting Tools for Unity Developers.

VFX Graph needs compute shader support, a compatible render pipeline (URP or HDRP), and a properly configured Spawn context. Check all three before debugging anything else. Always provide a legacy Particle System fallback for platforms without compute support.