Particle System vs VFX Graph in Unity 6: Which Should You Use?

Unity gives you two completely different tools for effects such as fire, smoke, sparks, magic and explosions. The Particle System (often called Shuriken) is the long-standing component that runs on the CPU. VFX Graph is a node-based system that runs on the GPU and can push millions of particles. Picking between them is one of the first questions in any effects work, and the answer isn’t “always use the new one”. This guide compares Particle System vs VFX Graph in Unity 6, explains when each wins, and walks through building a starter effect in both.

The Two Systems in One Minute

The Particle System is a component you add to a GameObject. You configure it through stacked modules in the Inspector: Emission, Shape, Velocity over Lifetime, Color over Lifetime, Collision and so on. Each particle is simulated on the CPU, which means it can collide with the physics world, trigger events and be read back by scripts. It works in every render pipeline and on every platform Unity supports.

VFX Graph is a package (Visual Effect Graph) for URP and HDRP. You build effects as a graph of contexts (Spawn, Initialize, Update, Output) filled with blocks and operators. Simulation runs in compute shaders on the GPU, so particle counts that would melt the CPU are no problem. The trade-off is that the CPU doesn’t know where particles are: no PhysX collisions, no per-particle callbacks, and it needs compute shader support on the target device.

Side-by-Side Comparison

Feature	Particle System	VFX Graph
Runs on	CPU	GPU (compute shaders)
Practical particle count	Thousands	Hundreds of thousands to millions
Render pipelines	Built-in, URP, HDRP	URP and HDRP only
Platforms	All, including low-end mobile and WebGL	Needs compute shaders; limited on low-end mobile, not on WebGL 2
Physics collisions	Yes, against real colliders	Only simple shapes, depth buffer or SDFs
Script access to particles	Yes (GetParticles, collision and trigger messages)	No per-particle readback; exposed properties and events only
Authoring	Inspector modules	Node graph
Custom behaviour	Limited to modules (or custom shaders)	Very flexible: operators, attributes, custom HLSL
Cost when idle	Low	Some fixed GPU and setup overhead per effect

Which One Should You Use?

Use the Particle System when:

• You target mobile, WebGL, Switch-class hardware or the Built-in Render Pipeline.
• The effect is small: muzzle flashes, hit sparks, footstep dust, pickups. Most gameplay effects are a few dozen to a few hundred particles.
• Particles must collide with real colliders, or scripts need to know about them (bullet casings that bounce, rain that triggers splashes).
• You want to get something working fast with no new package.

Use VFX Graph when:

• You need huge counts: swarms, galaxies, magic storms, dense sparks, large-scale weather.
• You’re on URP or HDRP for PC or console and the effect is a showpiece.
• You want advanced behaviours: particles sampling meshes or textures, flowing along vector fields, spawning trails from other particles, or reacting to the depth buffer.

Most projects use both: the Particle System for the many small gameplay effects, and VFX Graph for a handful of big ones. There’s no need to pick one for the whole project.

Build a Spark Burst with the Particle System

A burst of sparks on impact is the “hello world” of effects. Create it with GameObject > Effects > Particle System, then set:

1. Main module: Duration 0.5, untick Looping, Start Lifetime Random Between Two Constants 0.2–0.5, Start Speed 4–10, Start Size 0.03–0.08, Start Color a warm yellow-orange, Gravity Modifier 1, Simulation Space World, Stop Action Destroy (for spawned one-shots).
2. Emission: Rate over Time 0, then add a Burst at time 0 with count 30–50.
3. Shape: Cone with angle 25 and radius 0.05, so sparks spray outward from a point.
4. Color over Lifetime: a gradient from bright yellow to dark orange, with alpha fading to 0 at the end.
5. Size over Lifetime: a curve shrinking to 0.
6. Renderer: Render Mode Stretched Billboard with Speed Scale 0.05 so sparks become streaks. Use an additive particle material (URP: Universal Render Pipeline/Particles/Unlit with Surface Type Transparent and Blending Mode Additive).
7. Optional Collision: Type World, Bounce 0.3, Lifetime Loss 0.2, so sparks skitter off the floor.

Press Restart in the Particle Effect overlay in the Scene view to preview. Save it as a prefab. With bloom enabled on the camera’s post-processing Volume, the additive sparks glow nicely (see our bloom guide if they don’t).

Build the Same Effect in VFX Graph

Install Visual Effect Graph from the Package Manager (Unity Registry). In your URP Asset’s renderer, nothing special is required for basic effects. Then:

1. Assets > Create > Visual Effects > Visual Effect Graph, choose the Simple Burst or empty template, and open it.
2. Spawn context: remove Constant Spawn Rate and add a Single Burst block with Count 2000 (yes, 2000; this is what VFX Graph is for).
3. Initialize Particle: set Capacity to at least the burst count. Add Set Velocity Random (or Set Velocity from Direction & Speed with a cone) between (-5,2,-5) and (5,10,5), Set Lifetime Random 0.3–0.8 and Set Size Random 0.01–0.04.
4. Update Particle: add Gravity and Linear Drag. For floor bounces add Collide with Plane or Collide with Depth Buffer.
5. Output: use an Output Particle URP Lit/Unlit Quad with Blend Mode Additive, Orient Along Velocity, and add Set Color over Life plus Set Size over Life to fade and shrink.
6. Drag the graph asset into the scene to create a Visual Effect component.

To make the burst trigger on demand instead of on play, replace the Spawn context’s start with a GPU Event or wire the Spawn context’s Start input to an Event named OnHit, which you send from code. Expose properties (click + on the Blackboard, tick Exposed) for anything a script or designer should change, such as colour or count.

Triggering Effects from Code

For a Particle System prefab:

[SerializeField] ParticleSystem sparksPrefab;

void OnImpact(Vector3 point, Vector3 normal)
{
    ParticleSystem fx = Instantiate(sparksPrefab, point, Quaternion.LookRotation(normal));
    fx.Play(); // Stop Action = Destroy cleans it up
}

If impacts happen constantly, instantiating and destroying creates garbage. Keep one instance and use Emit with overridden positions, or pool the effects (our ObjectPool guide shows how):

var emitParams = new ParticleSystem.EmitParams { position = point, applyShapeToPosition = true };
sharedSparks.Emit(emitParams, 40);

For VFX Graph, one Visual Effect can serve many impacts. Set an exposed position, then send the event:

using UnityEngine.VFX;

[SerializeField] VisualEffect sparks;
static readonly int HitPos = Shader.PropertyToID("HitPosition");
static readonly int OnHit = Shader.PropertyToID("OnHit");

void OnImpact(Vector3 point)
{
    sparks.SetVector3(HitPos, point);
    sparks.SendEvent(OnHit);
}

For several impacts in the same frame, pass the position through a VFXEventAttribute (sparks.CreateVFXEventAttribute(), set position, then SendEvent(OnHit, attr)) and use Inherit Source Position in the Initialize context, so each burst starts in the right place.

Performance Tips for Both

• Overdraw is the real cost. Large, overlapping transparent particles (smoke, fog) cost far more than particle count. Use fewer, smaller particles and textures with tight alpha. The Scene view’s Overdraw draw mode shows hotspots.
• Cap Max Particles (Particle System main module) and Capacity (VFX Graph Initialize). VFX Graph allocates GPU memory for the full capacity whether you use it or not.
• Cull offscreen effects. Particle Systems with predictable motion can pause when not visible (the Culling Mode option). For VFX Graph, set accurate Bounds in the Initialize context; with bounds too small, effects vanish at screen edges; too large, they’re never culled.
• Turn off what you don’t need. Collision (World mode) and Lights modules are expensive on the Particle System. Use Planes collision or none.
• Profile. Particle System cost shows on the CPU in ParticleSystem.Update; VFX Graph cost shows on the GPU. The Unity Profiler and Frame Debugger show both.

Troubleshooting

Particles are pink

The particle material uses a shader from another render pipeline. In URP, use the Universal Render Pipeline/Particles shaders. Our pink materials guide covers bulk conversion.

Particles show as white or black squares

The material has no texture, or the texture has no alpha. Assign a soft particle texture with transparency, set Surface Type to Transparent, and import the texture with Alpha Is Transparency ticked.

VFX Graph effect doesn’t appear

Check that the platform supports compute shaders (it won’t render on WebGL 2), that Capacity isn’t 0, that Bounds contain the particles, and that the Output context uses an output matching your pipeline (URP outputs in URP). The Visual Effect component’s play controls in the Scene view help confirm it’s spawning at all.

Effect only plays once or never restarts

The Particle System has Looping off and Play On Awake on, so it played when the scene started. Call Play() when needed, or Clear() then Play() to restart a running effect. In VFX Graph, the Spawn context needs to be reset by its start event.

Particles move with the character when they should stay behind

Simulation Space is Local. Set it to World for trails, smoke and dust, so emitted particles stay where they spawned. VFX Graph contexts have the same Local/World toggle at the top right.

FAQ