Stop Your Particles From Looking Like Static: A Guide to Particle Update in Verse

So, you've built a firework. Or a lava explosion. Or a really aggressive smoke bomb. But when you press play, the particles just… sit there. Or they fall like rocks. Or they jitter in a way that looks like a glitched texture instead of a dynamic effect.

That's because you haven't told the particles how to live.

In UEFN, particles aren't just pictures; they are little digital actors that need direction every single frame. That direction comes from the Particle Update system. Think of it as the game engine's way of whispering in each particle's ear: "Hey, you're still alive? Okay, here's how you move this second. Now go."

If you don't give them instructions, they default to whatever the engine thinks is boring. Let's fix that.

What You'll Learn

• What Particle Update actually is (and why it's the heartbeat of your effects).
• How to use Drag to make things feel heavy, light, or floaty.
• How to use Curl Noise to make particles swirl like a vortex or jitter like a nervous cat.
• Why deleting unnecessary modules is just as important as adding them.

How It Works

Imagine you're playing Fortnite. Every time your character moves, the game calculates their new position, checks for collision, and updates their health. This happens roughly 60 times a second (or 120, if you're on a high-refresh-rate monitor). This is called a frame.

Particle Update is the exact same concept, but for your visual effects.

When you spawn a particle (like a spark from a hit marker), it has a "life" (how many seconds it exists). Every single frame, the engine asks: "Okay, Sparky, what do you want to do now?"

The Particle Update section is where you answer that question. It's a stack of instructions that run from top to bottom, every frame, for every single particle.

The Two Main Tools You'll Use

1. Drag (The Gravity/Resistance Knob):

   • Game Analogy: Think of this like swimming. Moving through water is harder than moving through air. Drag adds resistance to a particle's movement.
   • If you want a firework to climb slowly into the sky before exploding, you add Drag. It fights against the initial upward velocity, making the ascent feel weighty and realistic.
   • If you want smoke to drift lazily, you add Drag so it doesn't shoot off into the stratosphere.

2. Curl Noise (The Chaos Knob):

   • Game Analogy: Imagine a whirlpool or a tornado. Or think of a player trying to run through a storm while being pushed by the wind.
   • Curl Noise doesn't just pull particles down; it swirls them. It adds a random, organic vibration to the particle's path. It's what makes smoke look like smoke and not just a gray box moving up. It's what makes a firework trail look like it's dancing in the wind.

The Golden Rule: Less is More

The reference docs will tell you to delete modules like Gravity Force or Generate Location Event if you don't need them. Why? Because the computer has to do math for every module you add. If you're trying to make a subtle sparkle, you don't need heavy gravity pulling it down. You don't need complex noise making it swirl.

If you leave unnecessary modules in the stack, you're wasting the engine's time, and your effect might look weird because two forces are fighting each other (e.g., Gravity pulling down while Drag pulls up). Clean up your stack!

Let's Build It

We are going to build a Swirling Smoke Trail. Imagine a ghost flying through your island, leaving a trail of spooky, swirling mist behind it.

We will use Verse to control this, but remember: Verse is the script that tells the particle system when to spawn and what settings to use. The actual "movement" logic (Drag/Curl) is still handled by the Particle System's internal modules, which we configure via the Verse code's parameters.

Note: In UEFN, you often configure the Particle Emitter in the editor, but Verse allows you to tweak these values dynamically or spawn them with specific behaviors. For this tutorial, we'll look at how Verse interacts with the particle module stack.

Here is a simplified Verse script that demonstrates how you might structure a particle system with these updates in mind.

# We are creating a simple script that manages a particle effect.
# In a real UEFN project, you'd attach this to a Device.

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }

# This is our "Device" — the thing you place in the world.
# Think of it like a Trap or a Prop-Mover.
test_device := class(creative_device):

    # We need a reference to the VFX Spawner device we place in the editor.
    # In UEFN, use a vfx_spawner_device (found in the Creative device library)
    # and assign it here via the Details panel.
    @editable
    Emitter: vfx_spawner_device = vfx_spawner_device{}

    # We need a reference to the Trigger device that detects players.
    # Place a trigger_device on your island and assign it in the Details panel.
    @editable
    Trigger: trigger_device = trigger_device{}

    # This runs once when the game starts.
    OnBegin<override>()<suspends>: void =
        # Connect our trigger to a function.
        # When a player enters the zone, run 'OnPlayerEnter'.
        # TriggeredEvent fires when any agent (player) activates the trigger.
        Trigger.TriggeredEvent.Subscribe(OnPlayerEnter)

    # This is the event handler.
    # 'Agent' is the person who walked into the zone.
    OnPlayerEnter(Agent: ?agent): void =
        # 1. SPAWN THE PARTICLE
        # We tell the VFX Spawner to play its effect.
        # This is like pressing the "Fire" button on a weapon.
        # The emitter's Niagara asset is chosen in the editor Details panel —
        # pick your "SpookySwirl" Niagara System there before pressing Play.
        Emitter.Enable()

        # 2. CONFIGURE THE UPDATE (The Magic Part)
        # In Verse, particle update module values (Drag, Curl Noise strength,
        # etc.) are authored directly inside the Niagara System in the editor.
        # At runtime we choose *which* pre-configured vfx_spawner_device fires.
        #
        # For this tutorial we have two vfx_spawner_device objects placed on
        # the island and wired up in the Details panel:
        #   - HeavySmoke  (Niagara asset: high Drag, no Curl Noise)
        #   - SpookySwirl (Niagara asset: low Drag, high Curl Noise)
        #
        # By calling Emitter.Enable() above we are already using the
        # "SpookySwirl" device, which has these Niagara module values baked in:
        #   Drag:        0.2  (floats easily)
        #   Curl Noise:  500  (swirls violently)

        # 3. WAIT AND CLEAN UP
        # Don't let the particles pile up forever.
        # Wait 5 seconds (their lifetime), then stop the emitter.
        # We spawn a new async coroutine so Sleep is allowed here.
        spawn{ WaitAndDisable() }

    # Waits 5 seconds then disables the emitter.
    # Runs as its own coroutine so Sleep is permitted.
    WaitAndDisable()<suspends>: void =
        Sleep(5.0)

        # Disable the spawner so it stops emitting new particles.
        # Existing particles finish their own lifetime naturally.
        Emitter.Disable()```

### Walkthrough: What Just Happened?

1.  **`OnBegin`**: This is your "Game Start" moment. We set up the **Trigger** (`Trigger`) to listen for players. It's like setting up a pressure plate.
2.  **`OnPlayerEnter`**: This is the **Event**. A player walked in! Now we act.
3.  **`Emitter.Enable()`**: This is the **Loot Drop**. We're releasing the particles into the world.
4.  **Choosing the right `vfx_spawner_device`**: This is where **Particle Update** matters. By wiring up a specific device (whose Niagara asset was configured in the editor), we are choosing the *rules* for how those particles behave every frame.
    *   If we had wired a different device, it might have had **Drag** set to 1.0 (heavy, like a rock) or **Curl Noise** disabled (straight lines).
    *   The "SpookySwirl" device's Niagara asset has the **Particle Update** modules we talked about: Drag and Curl Noise configured to make it look chaotic and floating.
5.  **`Sleep(5.0)`**: We pause the coroutine for 5 seconds. This is like the **Storm Timer**. It keeps the effect running for a bit before we clean up.

## Try It Yourself

**Challenge:** Create a "Gravity Well" effect.

1.  Place a **Particle Emitter** in your island.
2.  Open its details panel.
3.  Go to the **Particle Update** section.
4.  **Delete** the "Gravity Force" module. (Why? Because we want our particles to defy gravity!)
5.  **Add** the "Drag" module.
6.  Set the **Drag** value to **5.0** (very high resistance).
7.  **Add** the "Curl Noise Force" module.
8.  Set **Noise Strength** to **1000** (extreme swirling).
9.  Play your island. Click the emitter (or trigger it with a device).

**Hint:** If the particles disappear too fast, go to the **Particle Spawn** section and increase the **Lifetime**. If they look like a solid ball instead of a swirl, increase the **Curl Noise Frequency**.

What happens when you combine high Drag with high Curl Noise? Do they look like a tornado? A lava lamp? A confused ghost? That's the power of Particle Update.

## Recap

*   **Particle Update** runs every frame, telling each particle how to move.
*   **Drag** adds resistance, making particles feel heavy or floaty (like swimming vs. running).
*   **Curl Noise** adds chaotic swirling motion (like a tornado or wind).
*   **Clean your stack:** Delete modules you don't need to save performance and avoid conflicting forces.

Now go make your island look less like a PowerPoint slide and more like a AAA game.

## References

- https://dev.epicgames.com/documentation/en-us/fortnite/2-building-the-firework-head-in-unreal-editor-for-fortnite
- https://dev.epicgames.com/documentation/en-us/uefn/building-the-firework-head-in-unreal-editor-for-fortnite
- https://dev.epicgames.com/documentation/en-us/uefn/making-the-second-firework-explosion-in-unreal-editor-for-fortnite
- https://dev.epicgames.com/documentation/en-us/fortnite/creating-fireworks-5-making-the-second-firework-explosion-in-unreal-editor-for-fortnite
- https://dev.epicgames.com/documentation/en-us/uefn/building-the-firework-trail-in-unreal-editor-for-fortnite