HomeUnreal EngineNiagara Electrical Arcing
CompleteUE 5.8

Niagara Electrical Arcing

UE5 · Niagara · GPU Sim · HDR Materials

UE5NiagaraGPU SimVFXMaterialsLightning

A GPU-driven Niagara system for procedural electrical arcs — branching paths, per-segment jitter, and bloom-tuned emissive ribbons. Endpoints, chaos, branch depth, and colour curves are exposed as user parameters for weapons, ambient effects, and environmental hazards.

Overview

The Niagara Electrical Arcing system produces procedural GPU-simulated lightning arcs between two user-defined endpoints. The system is built around a single emitter that spawns ribbon particles along a jittered path, with branching handled by child emitter spawns triggered probabilistically at each interior segment point. All visual properties — chaos scale, branch count, arc colour, lifetime, and ribbon width — are declared as User Parameters at the system level so Blueprint can drive them at runtime without touching the graph.

// Step Media

System & Emitter Properties

The system and emitter properties panels define simulation space, fixed bounds, loop behaviour, and the user-exposed parameters that drive the entire effect. Setting these up correctly before building the spawn and update graphs avoids having to rewire parameter references later.

  1. Open the Niagara System asset and navigate to the System Properties panel.
  2. Set Simulation Target to GPU Compute Sim for performance on dense arc counts.
  3. Enable Fixed Bounds and set a bounding box large enough to contain the longest expected arc — this prevents GPU culling from clipping active particles.
  4. Add User Parameters for ArcStart (Vector), ArcEnd (Vector), ChaosScale (Float), ArcColor (LinearColor), ArcLifetime (Float), and RibbonWidth (Float).
  5. In the Emitter Properties panel, set the emitter to Looping with a short loop duration matching the desired arc flicker rate.
  6. Set Spawn Rate to 0 and use Spawn Burst Instantaneous instead — this fires a fixed segment count at the start of each loop rather than streaming particles continuously.
// Step Media

Particle Spawn

The spawn stage distributes the initial arc segment points evenly along the straight line between the two endpoint User Parameters. Each point is given a unique index used in the update stage to compute its jitter offset. Branching probability is also evaluated here — a random roll against the branch parameter determines whether a child arc emitter is spawned from that segment.

  1. Add an Initialize Particle module. Set Lifetime to the ArcLifetime User Parameter.
  2. Add a Set (Particle) Position module. Use a Lerp between the ArcStart and ArcEnd User Parameters, with the particle normalised index (ParticleIndex / (SpawnCount - 1)) as the alpha — this spaces segments evenly along the arc line.
  3. Add a Set (Particle) Integer module to store the raw ParticleIndex as a Particle Attribute for use in the update stage.
  4. Add a Set (Particle) Float module. Sample a random float and compare it against the BranchProbability User Parameter. Store the result as a ShouldBranch bool attribute.
  5. Add a Spawn Particles from Emitter module referencing the child branch emitter. Gate it with the ShouldBranch attribute so only qualifying segments spawn a branch.
  6. Connect ArcStart and ArcEnd from the User Parameters into the child emitter spawn so branches inherit the correct endpoint context.
// Step Media

Particle Update

The update stage runs every tick on each active arc segment. A noise sample scaled by the ChaosScale User Parameter displaces each interior point perpendicularly away from the straight arc line, producing the characteristic crackling motion. End points (index 0 and the last index) are pinned to ArcStart and ArcEnd so the arc always connects its endpoints regardless of chaos value. The update stage also evaluates the colour curve and feeds the final displaced positions into the ribbon renderer.

  1. Add a Curl Noise Force module. Connect ChaosScale as the Noise Strength input — this drives the per-tick perpendicular displacement.
  2. Add a Set (Particle) Position module. Read the stored ParticleIndex attribute and use a Select node to pin index 0 to ArcStart and the last index to ArcEnd, passing all other indices through the noise-displaced position.
  3. Add a Set (Particle) Color module. Sample the ArcColor User Parameter and multiply it by a Curve Float evaluated against the normalised particle age (Age / Lifetime) — this fades the arc out as it approaches the end of its lifetime.
  4. Add a Set (Particle) Ribbon Width module. Read the RibbonWidth User Parameter and optionally multiply by the same age curve to taper the ribbon toward the end of its life.
  5. Ensure the Scale Color module is downstream of the colour set so the HDR emissive multiplier is applied after the curve evaluation.
// Step Media

Ribbon Renderer & Material

The ribbon renderer connects the displaced segment points into a continuous strip mesh. The arc material uses an HDR emissive core — a bright, narrow centre band surrounded by a softer falloff — so the post-process bloom stack picks up the glow without any additional lights in the scene. Ribbon width and emissive intensity are driven by the User Parameters set at the system level.

  1. Add a Ribbon Renderer to the emitter. Set Sort Order to Ribbon Age so segments connect in the correct sequence.
  2. Set Tessellation Type to Custom and dial in a tessellation factor of 4–8 — this smooths the jittered path without a large particle count.
  3. Create a new Material and set its Blend Mode to Translucent and Shading Model to Unlit.
  4. In the material graph, add a Radial Gradient Exponential node driven by the ribbon UV V coordinate. This produces a bright centre band that fades to transparent at the ribbon edges.
  5. Multiply the gradient output by an EmissiveColor vector parameter and an EmissiveBrightness scalar parameter (default 8.0–12.0) to push the output into HDR range.
  6. Connect the multiplied result to the Emissive Color pin. Leave Base Color black and set Opacity to the gradient output.
  7. Assign the material to the Ribbon Renderer and verify bloom is enabled in the scene post-process volume.
// Step Media

// Key Features

  • GPU-simulated polyline arcs with per-frame perpendicular jitter for organic motion
  • Recursive branching with adjustable depth, split probability, and length decay
  • Niagara ribbon renderer with HDR emissive core and bloom-tuned falloff
  • Endpoint sockets — drive arc origin and target from any actor or component transform
  • User-exposed chaos, branch count, lifetime, and colour curves for per-instance variation

// Project Info

Engine
UE 5.8
Status
Complete
Category
Unreal Engine