Claude Skill

unreal-niagara

Create and control VFX in Unreal Engine 5 with Niagara: systems and emitters, modules and the spawn/update stages, exposed User parameters, and spawning or driving effects from Blueprints or C++. Use when building particle effects, NS_/NE_ assets, spawning a Niagara system at run

LLM Mart · 0 points · 4 views 0 listing impressions 0 install-command copies
Download gamedev-skills-awesome-gamedev-agent-skills-skills_unreal_unreal-niagara-4cce500.zip · 2 KB

Install

skills CLI npx skills add https://github.com/gamedev-skills/awesome-gamedev-agent-skills/tree/main/skills/unreal/unreal-niagara
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install gamedev-skills-awesome-gamedev-agent-skills@llmmart
Git git clone https://github.com/gamedev-skills/awesome-gamedev-agent-skills.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole gamedev-skills/awesome-gamedev-agent-skills collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

Unreal Niagara VFX

Build and control real-time visual effects in UE5 with Niagara: understand the System/Emitter/Module hierarchy, expose parameters you can drive from gameplay, and spawn effects at runtime. Targets UE 5.8. (Niagara replaces the legacy Cascade system.)

When to use

  • Use when creating a Niagara System (NS_) and Emitters (NE_), wiring modules in the spawn/update stages, exposing User parameters to gameplay, or spawning/driving an effect (impact, muzzle flash, fire, magic) from Blueprint or C++.
  • Use when the project has Niagara NS_/NE_ assets or references UNiagaraComponent.

When not to use: material/shader authoring (the look of a surface, not particles) is a separate topic; shader-programming covers cross-engine shader concepts. Audio for the effect → audio-design.

Core workflow

  1. Understand the hierarchy. A Niagara System (NS_) is the effect you place/spawn; it contains one or more Emitters (NE_, often emitter templates). Each emitter runs in stages: Emitter Spawn/Update, Particle Spawn/Update, optional Event Handler, and Render.
  2. Build behaviour from Modules, which execute top-to-bottom in each stage (Spawn Rate, Add Velocity, Gravity Force, Color over Life, etc.). Order matters — a later module reads the values earlier ones wrote.
  3. Know the parameter namespaces: System, Emitter, Particle, and User. Only User-namespace parameters are exposed to and settable from Blueprint/C++; the others are internal to the simulation.
  4. Spawn at runtime with UNiagaraFunctionLibrary::SpawnSystemAtLocation (world position) or SpawnSystemAttached (follows a component/socket), which return a UNiagaraComponent.
  5. Drive the effect by setting its User parameters on the returned component (color, spawn rate, a target position) and Activate/Deactivate it.
  6. Verify in the Niagara editor preview and in-level; check bounds (especially GPU emitters), and confirm the effect culls/destroys correctly.

Patterns

1. Spawn a one-shot effect at a world location (C++)

#include "NiagaraFunctionLibrary.h"
#include "NiagaraComponent.h"

// ImpactSystem is a UPROPERTY(EditAnywhere) TObjectPtr<UNiagaraSystem>.
void AProjectile::SpawnImpact(const FVector& Location, const FRotator& Rotation)
{
    UNiagaraComponent* FX = UNiagaraFunctionLibrary::SpawnSystemAtLocation(
        GetWorld(), ImpactSystem, Location, Rotation);
    // FX auto-destroys when finished for a one-shot (system marked non-looping).
}

2. Spawn attached to a socket (muzzle flash that follows the gun)

UNiagaraComponent* Muzzle = UNiagaraFunctionLibrary::SpawnSystemAttached(
    MuzzleSystem, WeaponMesh, FName("MuzzleSocket"),
    FVector::ZeroVector, FRotator::ZeroRotator,
    EAttachLocation::SnapToTarget, /*bAutoDestroy*/ true);

3. Drive an exposed User parameter at runtime

// Only User-namespace parameters can be set from gameplay. Names match the User parameter.
if (UNiagaraComponent* Fire = UNiagaraFunctionLibrary::SpawnSystemAttached(
        FireSystem, RootComponent, NAME_None, FVector::ZeroVector, FRotator::ZeroRotator,
        EAttachLocation::KeepRelativeOffset, /*bAutoDestroy*/ false))
{
    Fire->SetVariableFloat(FName("SpawnRate"), 250.f);                 // User.SpawnRate
    Fire->SetVariableLinearColor(FName("FireColor"), FLinearColor::Red);
}

4. Blueprint equivalent (node flow)

Spawn System at Location (System = NS_Impact, Location, Rotation)  -> returns Niagara Component
On the returned component:
  Set Niagara Variable (Float)  Name="SpawnRate"  Value=250
  Set Niagara Variable (LinearColor)  Name="FireColor"  Value=Red

Pitfalls

  • Trying to set a System/Emitter/Particle parameter from gameplay — it won't take. Expose it in the User namespace; only User parameters are settable via the component.
  • Using Cascade tutorials — Cascade is deprecated and no longer developed. Niagara is the current system; the emitter/module workflow differs. For existing Cascade assets, the Cascade To Niagara Converter plugin gives a starting point to port from.
  • Crash on the spawned component — SpawnSystemAtLocation/SpawnSystemAttached can return nullptr (no system asset, or the effect was culled before spawning by its scalability settings). Null-check the result before setting parameters. Both functions are marked unsafe during actor construction, so spawn from BeginPlay or later, not the Construction Script.
  • Effect disappears or doesn't cull right — fixed/incorrect bounds, especially for GPU Compute emitters which need explicit Fixed Bounds. Set bounds on the emitter/system.
  • Looping effect never stops — spawned with bAutoDestroy = false and never Deactivate()d; manage the returned component's lifetime, or mark the system non-looping for one-shots.
  • GPU sim can't drive gameplay — GPU particle data isn't readily read back to the CPU; collision/events that gameplay must react to should use CPU emitters (or Niagara → gameplay via the data interface), not GPU.
  • Module order bugs — a Force/Velocity module placed before the one that initializes the value reads zero. Mind the top-to-bottom stack order.

References

  • Primary docs: "Overview of Niagara Effects" (https://dev.epicgames.com/documentation/en-us/unreal-engine/overview-of-niagara-effects-for-unreal-engine) and the UNiagaraFunctionLibrary / UNiagaraComponent API. Add the Niagara module to *.Build.cs for C++ access.

Related skills

  • shader-programming — material/shader concepts for particle materials.
  • unreal-cpp-gameplay — spawning effects from gameplay code and module setup.
  • unreal-blueprints — triggering effects from visual scripts.
Files (awesome-gamedev-agent-skills)
  • SKILL.md 6.2 KB
    ---
    name: unreal-niagara
    description: >
      Create and control VFX in Unreal Engine 5 with Niagara: systems and emitters, modules and
      the spawn/update stages, exposed User parameters, and spawning or driving effects from
      Blueprints or C++. Use when building particle effects, NS_/NE_ assets, spawning a Niagara
      system at runtime, setting User parameters, or when the user mentions Niagara, VFX, or a
      particle system in Unreal.
    ---
    
    # Unreal Niagara VFX
    
    Build and control real-time visual effects in UE5 with Niagara: understand the
    System/Emitter/Module hierarchy, expose parameters you can drive from gameplay, and spawn
    effects at runtime. Targets **UE 5.8**. (Niagara replaces the legacy Cascade system.)
    
    ## When to use
    
    - Use when creating a Niagara System (`NS_`) and Emitters (`NE_`), wiring modules in the
      spawn/update stages, exposing **User** parameters to gameplay, or spawning/driving an effect
      (impact, muzzle flash, fire, magic) from Blueprint or C++.
    - Use when the project has Niagara `NS_`/`NE_` assets or references `UNiagaraComponent`.
    
    **When *not* to use:** material/shader authoring (the look of a surface, not particles) is a
    separate topic; `shader-programming` covers cross-engine shader concepts. Audio for the effect
    → `audio-design`.
    
    ## Core workflow
    
    1. **Understand the hierarchy.** A **Niagara System** (`NS_`) is the effect you place/spawn; it
       contains one or more **Emitters** (`NE_`, often emitter *templates*). Each emitter runs in
       stages: **Emitter Spawn/Update**, **Particle Spawn/Update**, optional **Event Handler**, and
       **Render**.
    2. **Build behaviour from Modules**, which execute top-to-bottom in each stage (Spawn Rate,
       Add Velocity, Gravity Force, Color over Life, etc.). Order matters — a later module reads the
       values earlier ones wrote.
    3. **Know the parameter namespaces:** `System`, `Emitter`, `Particle`, and **`User`**. Only
       **User-namespace** parameters are exposed to and settable from Blueprint/C++; the others are
       internal to the simulation.
    4. **Spawn at runtime** with `UNiagaraFunctionLibrary::SpawnSystemAtLocation` (world position)
       or `SpawnSystemAttached` (follows a component/socket), which return a `UNiagaraComponent`.
    5. **Drive the effect** by setting its User parameters on the returned component (color, spawn
       rate, a target position) and `Activate`/`Deactivate` it.
    6. **Verify** in the Niagara editor preview and in-level; check bounds (especially GPU
       emitters), and confirm the effect culls/destroys correctly.
    
    ## Patterns
    
    ### 1. Spawn a one-shot effect at a world location (C++)
    
    ```cpp
    #include "NiagaraFunctionLibrary.h"
    #include "NiagaraComponent.h"
    
    // ImpactSystem is a UPROPERTY(EditAnywhere) TObjectPtr<UNiagaraSystem>.
    void AProjectile::SpawnImpact(const FVector& Location, const FRotator& Rotation)
    {
        UNiagaraComponent* FX = UNiagaraFunctionLibrary::SpawnSystemAtLocation(
            GetWorld(), ImpactSystem, Location, Rotation);
        // FX auto-destroys when finished for a one-shot (system marked non-looping).
    }
    ```
    
    ### 2. Spawn attached to a socket (muzzle flash that follows the gun)
    
    ```cpp
    UNiagaraComponent* Muzzle = UNiagaraFunctionLibrary::SpawnSystemAttached(
        MuzzleSystem, WeaponMesh, FName("MuzzleSocket"),
        FVector::ZeroVector, FRotator::ZeroRotator,
        EAttachLocation::SnapToTarget, /*bAutoDestroy*/ true);
    ```
    
    ### 3. Drive an exposed User parameter at runtime
    
    ```cpp
    // Only User-namespace parameters can be set from gameplay. Names match the User parameter.
    if (UNiagaraComponent* Fire = UNiagaraFunctionLibrary::SpawnSystemAttached(
            FireSystem, RootComponent, NAME_None, FVector::ZeroVector, FRotator::ZeroRotator,
            EAttachLocation::KeepRelativeOffset, /*bAutoDestroy*/ false))
    {
        Fire->SetVariableFloat(FName("SpawnRate"), 250.f);                 // User.SpawnRate
        Fire->SetVariableLinearColor(FName("FireColor"), FLinearColor::Red);
    }
    ```
    
    ### 4. Blueprint equivalent (node flow)
    
    ```text
    Spawn System at Location (System = NS_Impact, Location, Rotation)  -> returns Niagara Component
    On the returned component:
      Set Niagara Variable (Float)  Name="SpawnRate"  Value=250
      Set Niagara Variable (LinearColor)  Name="FireColor"  Value=Red
    ```
    
    ## Pitfalls
    
    - **Trying to set a System/Emitter/Particle parameter from gameplay** — it won't take. Expose
      it in the **User** namespace; only User parameters are settable via the component.
    - **Using Cascade tutorials** — Cascade is deprecated and no longer developed. Niagara is the
      current system; the emitter/module workflow differs. For existing Cascade assets, the
      **Cascade To Niagara Converter** plugin gives a starting point to port from.
    - **Crash on the spawned component** — `SpawnSystemAtLocation`/`SpawnSystemAttached` can return
      `nullptr` (no system asset, or the effect was culled before spawning by its scalability
      settings). Null-check the result before setting parameters. Both functions are marked unsafe
      during actor construction, so spawn from `BeginPlay` or later, not the Construction Script.
    - **Effect disappears or doesn't cull right** — fixed/incorrect bounds, especially for **GPU
      Compute** emitters which need explicit Fixed Bounds. Set bounds on the emitter/system.
    - **Looping effect never stops** — spawned with `bAutoDestroy = false` and never
      `Deactivate()`d; manage the returned component's lifetime, or mark the system non-looping for
      one-shots.
    - **GPU sim can't drive gameplay** — GPU particle data isn't readily read back to the CPU;
      collision/events that gameplay must react to should use CPU emitters (or Niagara → gameplay
      via the data interface), not GPU.
    - **Module order bugs** — a Force/Velocity module placed before the one that initializes the
      value reads zero. Mind the top-to-bottom stack order.
    
    ## References
    
    - Primary docs: "Overview of Niagara Effects"
      (`https://dev.epicgames.com/documentation/en-us/unreal-engine/overview-of-niagara-effects-for-unreal-engine`)
      and the `UNiagaraFunctionLibrary` / `UNiagaraComponent` API. Add the `Niagara` module to
      `*.Build.cs` for C++ access.
    
    ## Related skills
    
    - `shader-programming` — material/shader concepts for particle materials.
    - `unreal-cpp-gameplay` — spawning effects from gameplay code and module setup.
    - `unreal-blueprints` — triggering effects from visual scripts.
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.