Niagara Basics in UE5: Building a Defeat Effect from a Template

You have logic that defeats enemies, but they just vanish quietly. Even a quick burst of sparks makes the moment of "I got them" far more visible.

Niagara is UE5's mechanism for sparks, smoke, and the like. The screen shows many settings, but following three questions at first, "how many to spawn", "how to send them flying", and "how to remove them", is enough for a small effect.

In other engines : this is Unity's VFX Graph and Godot's GPUParticles3D . VFX Graph is closer in thinking than Unity's Particle System.

This article modifies a template into sparks that burst once, fade, and disappear . Finally we call it from Blueprint and leave sparks where a Cube disappeared.

What You'll Learn

• What System, Emitter, and Module are each responsible for
• Where to change particle count, color, speed, and lifetime
• Spawning an effect from Blueprint that stays in place
• Changing the same effect's color, and how attachment to motion works

Thinking from the particle reveals Niagara's structure

Each individual flying spark is a Particle . Particles carry information such as position, velocity, color, and lifetime. Smoke works the same way: layer many small smoke images and it reads as one large cloud.

So who spawns those particles? An Emitter takes charge of how particles spawn and move. A Module inside an Emitter is a piece of logic such as "spawn 30" or "give an initial velocity".

A System gathers Emitters. One explosion, for instance, can be built from a spark Emitter that flies briefly and a smoke Emitter that lingers. From Blueprint you specify one System and play it.

Splitting sparks and smoke makes each one's motion and lifetime easier to tune. It is not a rule that "different colors mean different Emitters". Here we start from a System with just one spark Emitter .

Read the stack by "when it runs"

Niagara's editor stacks modules vertically. That list is the stack . What to notice first is the name of the group each module sits in.

Group	What happens there	Our example
Emitter Update	Runs the source's logic every frame	Decides when and how many particles spawn
Particle Spawn	Runs once per particle when it is born	Decides lifetime, initial color, and speed
Particle Update	Updates every living particle each frame	Moves it with gravity and fades it out

Every frame means each time the game updates the screen. Writing color in Particle Spawn sets "the color at birth"; changing color in Particle Update makes "the color change while alive".

Within a group, processing generally runs top to bottom. Place "apply gravity" above "move using that force", for instance. Rather than reading the whole stack as one top-to-bottom pass, read it together with which particle it runs on, and when .

There are also Emitter Spawn, which sets up the source initially, and Renderer, which specifies how particles are drawn. We use a template, so you do not rebuild every entry.

Open a template and change the particle count

First use Simple Sprite Burst , which already spawns particles. A Sprite is a way of drawing that pastes an image on a small plane. For sparks, you fly small light images facing the camera as particles.

1. Right-click in the Content Browser and choose "FX" → "Niagara System".
2. Proceed to creating a System from an Emitter, add "Simple Sprite Burst" from the template list, and create it.
3. Name it NS_Explosion and double-click to open it.
4. Select the Emitter in "System Overview" and find the stack and the details panel showing the selected module's settings. Versions label it "Details" or "Selection".

The creation dialog's entry names and layout vary by UE5 version. We use a normal Emitter where you can edit "Emitter Update", "Particle Spawn", and "Particle Update". The simplified Lightweight Emitter has a different settings screen, so check the kind if a similarly named option appears.

Select Spawn Burst Instantaneous in "Emitter Update" and set "Spawn Count" to 30 and "Spawn Time" to 0 . That specifies "spawn 30 together at the start". Return the preview to the beginning, play it, and confirm the particles spawn as a group.

Spawn Rate , by contrast, decides "how many per second". It suits ongoing effects like campfires and smoke. If your Emitter has a Spawn Rate, delete it and keep only the Burst.

The Burst also lives in Emitter Update. It checks each frame whether the specified time arrived and spawns only when it does. It does not mean "being in Update spawns 30 every frame". But if the Emitter loops the Burst fires again, so we stop the repetition next.

Make sparks that burst once, fade, and disappear

From here we tune spawning, flying, and removing in order. After changing a value, return the preview to the start and play it, comparing against the previous state.

1. Stop the repetition

Set "Emitter Update"'s Emitter State as follows.

Setting	Value	Why this setting
Life Cycle Mode	Self	This Emitter decides how it ends
Loop Behavior	Once	Plays once
Loop Duration Mode	Fixed	Fixes the length of one pass
Loop Duration	1.0	Makes the source's single pass one second
Inactive Response	Complete	Waits for already spawned particles to expire before ending

With Life Cycle Mode left at System, the Emitter's loop settings can be hidden. Switch to Self before configuring.

The source's playback time and a single particle's lifetime are different. Changing Loop Duration does not directly specify how many seconds a particle lasts. Particle lifetime is set in Initialize Particle next.

2. Decide the color and size at birth

Open Initialize Particle in "Particle Spawn". As the name says, it decides the initial values of a newborn particle.

Entry	Setting
Lifetime Mode	Random
Lifetime min / max	0.4 / 0.8 seconds
Color	Orange, for example R=1, G=0.5, B=0.1, A=1
Sprite Size Mode	Random Uniform
Sprite Size min / max	8 / 16

Random picks a value from the range per particle. A lifetime of 0.4 to 0.8 seconds mixes particles that vanish quickly with ones that linger. The Uniform in Random Uniform means one particle's width and height match, not that all particles are the same size.

Color's A (Alpha) is the value used for transparency. Set it to 1 for now; we shrink it with lifetime later.

3. Scatter upward and let gravity pull them down

Align the position and velocity settings in "Particle Spawn" to the following. If a needed module is missing, add it by searching from the "+" on the right of the group. Check existing modules first so you do not stack duplicate settings.

1. Set Shape Location 's shape to "Sphere" with radius 5 . That scatters spawn positions within a small sphere.
2. Open Add Velocity and set "Velocity Mode" to "Linear".
3. Choose "Random Range Vector" from Velocity's input menu with minimum (-300, -300, 100) and maximum (300, 300, 500) .

Velocity represents which direction and how fast something moves. UE's standard unit is cm per second, with X and Y horizontal and Z vertical. These settings scatter sideways while flying upward at first. Unlike a spherical explosion flying evenly in every direction, these sparks spurt slightly upward.

Next set "Particle Update"'s Gravity Force to (0, 0, -400) . If it is missing, add it from that group's "+". Keep Solve Forces and Velocity and place it below Gravity Force. It uses the gravity setting to actually update particle velocity and position. If an ordering warning appears, use "Fix Issue" to correct the dependency and check the order.

If the template includes another Add Velocity or force module, disable what you are not using before comparing. Note that gravity alone does not produce floor collisions. We build a "fly and fade" effect here without floor bouncing.

4. Fade with lifetime

Lifetime alone removes particles, but staying at full opacity until the last instant looks like an abrupt cut. Use Scale Color in "Particle Update" to shrink Alpha gradually. Add it if it is missing.

Here we specify the value change with keys , points placed on a curve. Place points at the start and end and connect them, and the Alpha between is computed automatically.

1. Set Scale RGB to (1, 1, 1) or disable the RGB change, to keep the initial orange.
2. Set Scale Alpha's input to "Float from Curve" and make a downward curve. Use two keys, "Time = 0, Value = 1" and "Time = 1, Value = 0", with key interpolation "Linear" to connect them with a straight line.
3. Confirm the value the curve reads is Particles.NormalizedAge .
4. Keep Particle State and turn on "Kill Particles When Lifetime Has Elapsed", which removes particles that reached the end of life.

Normalized Age expresses how far through its lifetime a particle is, from 0 to 1. Birth is 0, half of the lifetime is 0.5, and the end is 1. The curve's horizontal axis is not seconds. Particles with 0.4-second and 0.8-second lifetimes each fade across their own life.

Orange particles bursting once and fading out means success. The preview's own looping is separate from the Emitter's Loop Behavior, so if it seems to repeat, also check the preview's loop.

Color travels from Niagara to the material

When you set a color and nothing changes, look at the side drawing the particles. A Sprite Renderer uses particle positions and sizes to draw planes with an image. The material used there decides how it glows and how transparent areas appear.

The color set in Niagara goes into Particles.Color and reaches the material through the Renderer. If the material is built to use Particle Color , Initialize Particle's orange and Scale Color's fade appear in the visuals.

We keep the template's Sprite Renderer and material. If you swap them and color stops changing, check in order: "is something overriding the color inside Niagara", "is the Renderer's Color Binding Particles.Color", and "does the material use Particle Color".

Additive , which layers light, suits sparks. Smoke needs a translucent look that occludes what is behind it. Finish the particle motion first and move to material basics when polishing looks, keeping what you learn separated.

Hands-On: leave sparks where a Cube disappeared

Once NS_Explosion is saved, call it from the game side. We first confirm with a Cube that disappears two seconds after Play starts , so you can test without attack or HP systems.

Prepare the Cube and the playback trigger

1. Create a Blueprint with Actor as its parent and name it BP_VFXTarget .
2. Add a Static Mesh component and assign the engine's standard Cube to "Static Mesh". Leave its relative location at (0, 0, 0) .
3. Place the Blueprint in the level at a height where the Cube is not buried. On a flat floor, set the Actor's Z to about 100 and place it where the player can see it.
4. In this Blueprint's Event Graph, wire Event BeginPlay → Delay with white exec and set Duration to 2.0 .

Delay holds the following logic for the specified seconds. The whole game does not stop for two seconds. The next diagram continues from that Delay's Completed .

Pass the location, play, then destroy the Cube

Add Spawn System at Location . Location is the world position where the effect spawns . Here we pass the location of the Actor holding the Cube.

Get Actor Location fetches a specified Actor's position. Target is "which Actor" and Self is "this Blueprint itself". Return Value is the fetched position, a Vector grouping X, Y, and Z.

There are three connections.

1. Delay's "Completed" → Spawn System at Location 's white exec input.
2. Get Actor Location (Target: Self) 's "Return Value" → Spawn's "Location". That is a yellow Vector wire.
3. Spawn's white exec output → Destroy Actor (Target: Self) 's exec input.

Configure the Spawn node as follows. Expand the node's advanced pins for anything not visible.

Input	Value
System Template	NS_Explosion
Rotation	0, 0, 0
Scale	1, 1, 1
Auto Activate	On: starts playing once spawned
Auto Destroy	On: cleans up once the System finishes playing
Pooling Method	None
Pre Cull Check	Off: we skip pre-spawn culling checks while verifying

The order is spawn the effect at that position before destroying the Cube . Spawn System at Location spawns without attaching to the enemy, so destroying the Cube right after leaves the particles playing in place.

Auto Destroy is not a setting that "forcibly removes it after 0.8 seconds". It waits for the System to finish playing and cleans up the spawned Niagara component. Do not equate the moment particles become invisible with that cleanup time.

Play and confirm

Compile, save BP_VFXTarget, and Play; the Cube appears first. After two seconds the Cube disappears and orange particles fly from that position, fading out shortly, which is success. To check again, end Play and restart.

When it does not work	Where to check
The Cube does not disappear	Whether BP_VFXTarget is in the level, whether exec runs from BeginPlay to Destroy Actor
The Cube disappears but no particles	Whether System Template is NS_Explosion, whether Auto Activate is on, whether it shows in the Niagara preview
Sparks fire repeatedly	Whether a Spawn Rate remains, whether Emitter State is Self / Once
Particles linger past their lifetime	Whether Particle State's kill-at-lifetime setting is enabled
Particles vanish abruptly without fading	Scale Color's Alpha curve and the color handoff to the material

Once it works, change Spawn Count from 30 to 60 . Then set it back and change only the maximum size from 16 to 30 . Increasing the count and enlarging some particles change the same sparks' impression differently. Changing one at a time shows which setting did what.

To hook it into the moment an enemy dies, replace BeginPlay and Delay with the same Spawn then Destroy logic called from the True branch where HP reaches 0 . See the health and damage article for the HP check. With the effect part built, you only swap what triggers it.

Spawn in place, or attach to something moving

For defeats and impacts, you want the effect to remain where it happened. Our Spawn System at Location fits.

Light from a sword tip or exhaust from a moving car has a source that moves. There, Spawn System Attached takes the component to attach to, such as the sword's Mesh, in "Attach to Component". To attach to a specific part of a character, you can also specify a socket name in Attach Point Name.

But the source moving with something and already spawned particles moving with it are different . The Emitter property Local Space decides the latter.

• Off : particles move in world space. As the car drives on, the exhaust it emitted stays behind.
• On : particle positions are treated relative to the source. As the character moves, an aura around them moves too.

Choosing Attached does not make all spawned particles follow. Separating "what the source attaches to" from "which space particles move in" gets you closer to the effect you want.

Change the same effect's color with a User Parameter

The orange sparks work. When you also want blue sparks, duplicating the whole System multiplies the places to edit particle count later.

A User Parameter is a settings entry for passing values into Niagara from outside. Deciding "receive the color here" lets one System serve several colors. Let's test with placed instances rather than adding Blueprints.

1. Open NS_Explosion and add a Linear Color TintColor from the "+" in "User Parameters". It is referred to as User.TintColor .
2. Set its default to the same orange as before: R=1, G=0.5, B=0.1, A=1 .
3. In Initialize Particle's Color input menu, search for User.TintColor and choose it as the input, from entries such as "Link Inputs". That uses the externally passed color instead of a fixed one.
4. Drag two NS_Explosion into the level at separate positions.
5. Select only one and override TintColor in the Details panel's "User Parameters" with blue R=0.1, G=0.4, B=1, A=1 .
6. Play and confirm one spawns orange and the other blue. It plays once, so restart Play if you miss it.

Linear Color is the color type holding R, G, B, and Alpha together. Step 3's Link Inputs ties "use this settings entry's value". Adding a parameter alone does not change particle color; linking it to Color is what completes it.

We read Color in Particle Spawn, so color is decided when a particle is born. Changing a User Parameter mid-playback does not retroactively update already spawned particles' initial color.

Changing values from the level like this is also described in Epic's official User Parameters documentation.

Bonus: Good to Know Up Front

• Check appearance and cost separately : layering many large translucent particles can be heavy even at low counts. Tune count, size, and overlap first and check cost with things like the stat commands.
• CPU and GPU are where particle motion is computed : shape the effect with the template's settings first. Consider GPU execution once handling large counts, but check available features and Bounds handling too. Switching alone does not make every effect lighter.
• Bounds is the estimated volume the effect occupies : UE uses it and similar data to decide whether drawing is needed. When an effect vanishes entirely depending on camera facing, confirm Bounds covers the particle spread. When it vanishes at distance, also check distance-based culling settings.
• Match the moment with sound and animation : to play a defeat sound at the same position, see the audio attenuation article; to fire it at a sword swing, see the Anim Notify article.

Your first effect can be a small burst of sparks. Once particles spawn, change one of count, speed, or fade. Looking for the timing that fits your game's "it hit" and "it died" ties the settings' meaning to what you see.

Summary

• Three layers: System (the whole), Emitter (one kind of particle), Module (one behavior)
• Particle count, color, speed, and lifetime each change in their own Module
• How you spawn changes depending on whether it stays in place or follows something
• A User Parameter changes the same effect's color per placement

The question before building is "does this effect stay in place, or move with something?" That decides how you spawn it.

To connect it to the moment of impact, go to hit feel.

Reference: Epic's sparks effect walkthrough, Emitter Update reference, Particle Update reference, Spawn System at Location