🌌 Lesson 9.2: The VFX Graph — GPU Particles

Installing the VFX Graph

The Visual Effect Graph is a separate package. Open Window ▸ Package Manager, switch the source dropdown to Unity Registry, find Visual Effect Graph, and click Install. On a URP project it's usually already pulled in as a dependency, but installing it explicitly guarantees the version matches your pipeline.

Then create your first graph: Assets ▸ Create ▸ Visual Effects ▸ Visual Effect Graph. This makes a .vfx asset. To use it in a scene, add a Visual Effect component to a GameObject (GameObject ▸ Visual Effects ▸ Visual Effect) and drag your .vfx asset into its Asset Template field. Double-click the asset to open the graph editor.

GPU vs. CPU Particles

Shuriken updates each particle on the CPU, one after another, every frame. Your CPU is a handful of very fast cores — brilliant for game logic, but it can only chew through so many particles before the frame rate drops. A few thousand is its comfortable ceiling.

The VFX Graph runs the simulation as a compute shader on the GPU, which has thousands of small cores all updating particles in parallel. Because position, velocity, and age live in GPU buffers and never round-trip to the CPU, the graph can simulate and draw hundreds of thousands to millions of particles at interactive frame rates.

Here's the divide at a glance:

Figure 1: The two particle systems solve different problems — Shuriken for gameplay-connected effects, VFX Graph for massive, GPU-driven spectacle.

Anatomy of a VFX Graph

Open a .vfx asset and you land in a dark node canvas. Unlike Shuriken's flat Inspector stack, the VFX Graph is a flow of contexts connected top to bottom by fat wires: particles are born at the top and flow downward through stages until they're drawn. Down one side sits the Blackboard, a panel of exposed properties you can wire into any node.

The Four Contexts

A context is a stage in a particle's life. Data flows down the wires from one to the next, and each context answers a different question:

• Spawn (green) — how many particles are born, and when? Holds blocks like Constant Spawn Rate or Single Burst. This is the VFX Graph equivalent of Shuriken's Emission module.
• Initialize Particle (blue) — what values does each particle get at birth? Set Lifetime, Set Velocity, Set Position, Set Color. Runs once per particle, the moment it spawns. It also declares the system's Capacity — the max particles allocated on the GPU.
• Update Particle (blue) — what changes every frame while it's alive? Gravity, Turbulence, Force, Collision, drag. Runs every frame for every living particle — this is where the GPU's parallelism pays off.
• Output Particle (red) — how is each particle drawn? Output Particle Quad (camera-facing billboards), Mesh, or Line. Holds the texture, blend mode, and Size-over-Life. This is the final stage; it renders to the screen.

Blocks: The Verbs

Inside each context sits a stack of blocks — the individual operations. A block is a small unit of behaviour: Set Velocity from Direction & Speed, Add Position (Sphere), Gravity, Turbulence. You add a block by right-clicking inside a context ▸ Create Block, or with the spacebar menu, and blocks run top to bottom within their context.

Blocks have input ports on the left. You can type a constant value directly, or drag a wire from an operator node (Add, Multiply, Random, Noise, Age over Lifetime) or from a Blackboard property. That wiring is what makes the graph expressive: a Set Color block can be fed a gradient sampled by the particle's age, so color animates without a dedicated module.

💡 Order matters inside a context. Blocks execute top to bottom, so a Set Position that runs before Add Position (Sphere) gives a different result than the reverse. If an effect looks wrong, check block order before you touch the values.

The Blackboard

The Blackboard is the panel of named properties (see the left side of Figure 2). You create a property there — SpawnRate, Lifetime, BaseColor — then drag it onto the canvas and wire it into any block port. Two big wins:

• Reuse — one BaseColor can feed the Initialize color, a trail tint, and the output all at once. Change it in one place, everything updates.
• Exposure — tick a property as Exposed and it appears on the Visual Effect component in the Inspector, per-instance. Now the same graph can be a red torch on one GameObject and a blue torch on another, with no duplicate assets.

Exposed properties are also settable from C# through the VisualEffect component, so gameplay can drive an effect at runtime:

using UnityEngine;
using UnityEngine.VFX;

public class VortexController : MonoBehaviour
{
    [SerializeField] VisualEffect vfx;

    // Cache property IDs once — cheaper and typo-proof at the call site.
    static readonly int SpawnRateID = Shader.PropertyToID("SpawnRate");
    static readonly int BaseColorID = Shader.PropertyToID("BaseColor");

    void Start()
    {
        vfx.SetFloat(SpawnRateID, 5000f);
        vfx.SetVector4(BaseColorID, new Color(0.2f, 0.6f, 1f, 1f));
    }

    // Fire a one-shot burst event defined in the Spawn context.
    public void Erupt()
    {
        vfx.SendEvent("OnErupt");
    }
}

Notice the pattern from earlier lessons: cache the property as an ID with Shader.PropertyToID once, then reuse it — the exact same idea as Animator.StringToHash for animator parameters.

VFX Graph or Shuriken?

Both ship in the same project and you'll use both. Choose by the job:

• Reach for the VFX Graph when you need huge counts (blizzards, sandstorms, galaxies, magic vortexes), GPU features like flipbooks and mesh output at scale, or complex node-driven behaviour — and your target hardware supports compute shaders.
• Reach for Shuriken when the effect is small, needs to interact tightly with gameplay (particle collisions that call your code, sub-emitters spawning pickups), must run on low-end/older mobile GPUs, or when a quick Inspector tweak beats opening a graph.

Hands-on Challenge

Summary

🚀 What's Next?

Particles add motion; the mood of a scene comes from its grade — the bloom on a bright spark, the warm tint of a sunset, the vignette that pulls your eye to the center. In Lesson 9.3: Post-Processing with URP Volumes we layer cinematic image effects over the whole camera using the Volume framework.