Niagara

Scan a Niagara system's full stack for issues (the per-module warnings/errors the editor shows)

Walks the live Niagara stack, system stack plus every emitter stack, every module/entry, and reports all FStackIssue entries (the same warnings/errors shown on modules in the Niagara editor, e.g. unmet module dependencies). Each issue reports scope, module, category, severity (error/warning/info), short + long description, a stable issue_key, whether it is auto_fixable, and its list of fixes. Pass min_severity to filter. The system must be open in the Niagara editor (the command opens it if needed) since stack issues come from the live stack view model.

cfa validate_niagara_stack --system-path /Game/VFX/NS_Fire
cfa validate_niagara_stack --system-path /Game/VFX/NS_Fire --min-severity warning

Apply a stack issue's fix (the editor's "Fix issue" button), one issue or all auto-fixes

Executes a Niagara stack issue's fix delegate, the same action as clicking "Fix issue" in the editor (e.g. reorder a module before its dependency, add a required module). Target one issue with issue_key (from validate_niagara_stack) or match (a substring of the issue text); choose a specific fix with fix_index (default: the first auto-fix). Or pass all=true to apply every auto-fixable issue in a loop until none remain. Recompiles + saves the system afterward and reports remaining issues.

cfa fix_niagara_stack_issue --system-path /Game/VFX/NS_Fire --all=true
cfa fix_niagara_stack_issue --system-path /Game/VFX/NS_Fire --match "SolveForcesAndVelocity"
cfa fix_niagara_stack_issue --system-path /Game/VFX/NS_Fire --issue-key <key-from-validate>

List standalone Niagara data/utility asset types creatable via create_niagara_asset

Lists the asset_type values accepted by create_niagara_asset, each with its runtime asset class, availability in this build, and a one-line note. Backed by the engine factory registry (not a hardcoded doc), so it stays truthful across engine versions.

cfa list_niagara_asset_types

Create a standalone Niagara data/utility asset

Creates a standalone Niagara data/utility asset (parameter collection, parameter collection instance, parameter definitions, effect type, data channel, sim cache, validation rule set) via its engine factory. Run list_niagara_asset_types for the asset_type values. Edit the created asset afterward with the generic describe_object / set_object_property reflection commands. Note: sim_cache is created blank, its data is captured at runtime, not authored here.

cfa create_niagara_asset --asset-type parameter_collection --asset-path /Game/CFATest/NPC_Wind
cfa create_niagara_asset --asset-type parameter_collection_instance --asset-path /Game/CFATest/NPCI_Wind --parent /Game/CFATest/NPC_Wind.NPC_Wind
cfa create_niagara_asset --asset-type effect_type --asset-path /Game/CFATest/ET_Default

Add a named parameter (with optional default value) to a parameter collection

Populates a Niagara Parameter Collection (NPC) so it actually drives values: adds a named, typed parameter under the collection's namespace and optionally sets its default on the collection's default instance. Supported types: float, int, bool, vector (vec3), color (linear color). Value format: number for float/int, true/false for bool, {"x":..,"y":..,"z":..} for vector, {"r":..,"g":..,"b":..,"a":..} for color. A value that does not parse, or a name the collection already has, is refused before anything is added. The returned parameter_name is the fully namespaced name to reference from systems/emitters.

cfa add_niagara_parameter_collection_parameter --asset-path /Game/FX/NPC_Wind.NPC_Wind --name Strength --type float --value 2.5
cfa add_niagara_parameter_collection_parameter --asset-path /Game/FX/NPC_Wind.NPC_Wind --name Tint --type color --value '{"r":0.2,"g":0.6,"b":1.0,"a":1.0}'

Create a new Niagara particle system

Creates a new Niagara system asset at the given path. Use template to start from a preset (e.g., "empty" for a blank system, or a template name for pre-configured emitters). A Niagara *system* template is duplicated as a whole asset (same as Epic's MCP StaticDuplicateObject path) so inner scratch-pad scripts stay in the new package. Adding another system's emitters instead leaves illegal private FunctionScript refs (e.g. SpinPosition on a Fluids template) and the command now errors instead of saving. Pass a NiagaraFluids system path to clone a finished fluid solver, never rebuild those from empty; tune the clone's User parameters instead. Returns the created asset path.

cfa create_niagara_system --asset-path /Game/VFX/NS_Explosion
cfa create_niagara_system --asset-path /Game/VFX/NS_Fire --template "Fountain"

Get full info about a Niagara system

Returns detailed information about a Niagara system including its emitters, user parameters, system settings, and compilation status. Use include to control what sections are returned (all, emitters, parameters, compilation). Use filter to narrow emitters and parameters by name substring.

cfa get_niagara_system_info --system-path /Game/VFX/NS_Explosion
cfa get_niagara_system_info --system-path /Game/VFX/NS_Fire --include emitters
cfa get_niagara_system_info --system-path /Game/VFX/NS_Fire --filter Spark

List Niagara system assets

Lists all Niagara system assets under the given path. Use name_filter to narrow results by name substring. Useful for discovering existing systems before creating new ones or for finding systems to modify. Engine content is searchable too: use --path /NiagaraFluids with --name-filter Grid3D (3D water/gas), Grid2D (2D water/gas) or ShallowWater to find the ready-made fluid solver systems to clone (needs the NiagaraFluids plugin enabled).

cfa list_niagara_systems
cfa list_niagara_systems --path /Game/VFX --name-filter "Fire"
cfa list_niagara_systems --path /NiagaraFluids --name-filter Grid3D
cfa list_niagara_systems --max-results 50

Delete a Niagara system asset

Deletes a Niagara system asset. Checks for references by default. Set force to true to delete even if other assets reference this system. Use find_references first to understand the impact of deletion.

cfa delete_niagara_system --system-path /Game/VFX/NS_OldEffect
cfa delete_niagara_system --system-path /Game/VFX/NS_Unused --force

Compile a Niagara system

Triggers compilation of a Niagara system. Compilation resolves all module scripts, validates parameter bindings, and generates GPU compute shaders. Set wait_for_completion to false for async compilation. Returns the full compile state: is_valid, error_count, warning_count, a summary string, per-script statuses, and a messages[] array with every compile event ({script, severity error|warning|display|log, message, short_description}), the same errors and warnings the Niagara editor reports.

cfa compile_niagara_system --system-path /Game/VFX/NS_Explosion
cfa compile_niagara_system --system-path /Game/VFX/NS_Fire --wait-for-completion=false

Compile a standalone Niagara script (module / dynamic input / function)

Compiles a STANDALONE Niagara script asset, the standalone script editor's "Compile" button (UNiagaraScript::RequestCompile). Standalone module/dynamic-input/function scripts do not self-compile as you author them (they compile inside the system that uses them), so their editor shows 'compile status unknown' until you compile them. This runs a real, synchronous compile and returns the full state: is_valid, compile_status (up_to_date | up_to_date_with_warnings | error | dirty | unknown), error_count, warning_count, last_op_count (0 means never compiled), and a messages[] array of every compile event ({severity, message, short_description}). Pass script_path to the module/DI/function asset. If the script is OPEN in its editor this drives the editor's own Compile button on the edited copy (so the Stats panel + status update live) and returns editor_open:true, the edit persists to disk on apply_niagara_script; otherwise it compiles and saves the asset directly.

cfa compile_niagara_script --script-path /Game/VFX/Modules/NM_SineTornado
cfa compile_niagara_script --script-path /Game/VFX/DI/DI_Jitter --force=false

Apply a standalone Niagara script's edits to the asset (editor Apply button)

Replicates the standalone script editor's "Apply" button (FNiagaraScriptToolkit::OnApply) for a script open in its own editor: it compiles the transient edited copy, commits it onto the on-disk asset, refreshes every script that references it, and saves. Use after build_niagara_graph / compile_niagara_script when the script is open in the editor so the change persists exactly as a user clicking Apply. Returns editor_open and applied (false when the script isn't open, the asset already holds the edits, or when the edited copy matches the original, i.e. nothing to apply).

cfa apply_niagara_script --script-path /Game/VFX/DI/DI_Jitter

List emitters in a Niagara system

Returns emitters in a Niagara system with their names, indices, enabled states, and summary info (sim target, local_space, determinism, renderer_count). Use filter to narrow results by emitter name substring.

cfa get_niagara_emitters --system-path /Game/VFX/NS_Explosion
cfa get_niagara_emitters --system-path /Game/VFX/NS_Fire --filter Spark

Create a standalone Niagara emitter asset

Creates a standalone UNiagaraEmitter asset at the given path via the engine emitter factory. With add_default_modules=true (default) the emitter ships with a sprite renderer plus the standard EmitterState/SpawnRate/SystemLocation/AddVelocity/UpdateAge/Color/Solver modules; set it false for a truly empty emitter. Reuse it in a system with add_niagara_emitter --emitter-path (use --inherit to control parented vs copied).

cfa create_niagara_emitter --asset-path /Game/CFATest/E_Spark
cfa create_niagara_emitter --asset-path /Game/CFATest/E_Blank --add-default-modules=false

Add an emitter to a Niagara system

Adds an emitter to a Niagara system. Provide emitter_path to add from an existing emitter asset (template or standalone), or template to add from a built-in template. Use emitter_name to set a custom display name. If neither emitter_path nor template is given, adds an empty emitter. Use inherit to force the new handle to be parented to the source (true, live inheritance) or a standalone copy (false); omit it to use the source emitter's own setting.

cfa add_niagara_emitter --system-path /Game/VFX/NS_Fire --template "Fountain" --emitter-name "Sparks"
cfa add_niagara_emitter --system-path /Game/VFX/NS_Fire --emitter-path /Game/CFATest/E_Spark.E_Spark --inherit=true

Remove an emitter from a Niagara system

Removes an emitter from a Niagara system by name. This also removes all modules, renderers, and event handlers associated with the emitter. Use get_niagara_emitters to confirm the exact emitter name before removal.

cfa remove_niagara_emitter --system-path /Game/VFX/NS_Fire --emitter-name Sparks

Set a property on an emitter

Sets a property on an emitter within a Niagara system. Supported keys: enabled, sim_target (CPUSim/GPUComputeSim), local_space, determinism, bounds_mode, max_particles. Value is JSON-encoded. Set local_space=true for any effect that should play at its actor: a module that writes Particles.Position directly renders at world (0,0,0) in the default world space; local space makes positions relative to the component so the effect follows the actor.

cfa set_niagara_emitter_property --system-path /Game/VFX/NS_Fire --emitter-name Sparks --property sim_target --value '"GPUComputeSim"'
cfa set_niagara_emitter_property --system-path /Game/VFX/NS_Fire --emitter-name Sparks --property local_space --value true

Duplicate an emitter within a system

Creates a copy of an existing emitter within the same Niagara system. The duplicate inherits all modules, renderers, and settings from the source. Optionally provide new_name to rename the copy; otherwise it gets a default suffix.

cfa duplicate_niagara_emitter --system-path /Game/VFX/NS_Fire --emitter-name Sparks --new-name "Sparks_Large"

Move an emitter to a new position

Changes the execution order of an emitter within a Niagara system by moving it to a new index. Emitter order affects rendering draw order (later emitters draw on top) and can affect event handler resolution.

cfa reorder_niagara_emitter --system-path /Game/VFX/NS_Fire --emitter-name Sparks --new-index 0

List modules in an emitter's stack

Returns modules in an emitter's script stack. Filter by script_usage to see only specific stages: EmitterSpawn, EmitterUpdate, ParticleSpawn, ParticleUpdate, or all. Use filter to narrow by module function name substring. Set include_inputs to also return each module's inputs and values; by default only names, stages and paths are listed.

cfa get_niagara_modules --system-path /Game/VFX/NS_Fire --emitter-name Sparks
cfa get_niagara_modules --system-path /Game/VFX/NS_Fire --emitter-name Sparks --script-usage ParticleUpdate
cfa get_niagara_modules --system-path /Game/VFX/NS_Fire --emitter-name Sparks --filter Color
cfa get_niagara_modules --system-path /Game/VFX/NS_Fire --emitter-name Sparks --include-inputs

Add a module to an emitter's stack

Adds a module to an emitter's script stack at the specified stage. Target the emitter with either system_path + emitter_name (an emitter inside a system) OR emitter_path (a standalone UNiagaraEmitter asset). module_path is the asset path of a Niagara module script or scratch pad module. Use list_niagara_modules to discover available modules. Set index to -1 (default) to append at the end, or specify a zero-based position to insert at.

cfa add_niagara_module --system-path /Game/VFX/NS_Fire --emitter-name Sparks --module-path /Niagara/Modules/ScaleSpriteSize --script-usage ParticleUpdate
cfa add_niagara_module --emitter-path /Game/CFATest/E_Spark.E_Spark --module-path /Niagara/Modules/Update/Velocity/VortexVelocity.VortexVelocity --script-usage ParticleUpdate

Remove a module from an emitter's stack

Removes a module from an emitter's script stack by name and stage. Use get_niagara_modules to find the exact module name and which script_usage stage it belongs to.

cfa remove_niagara_module --system-path /Game/VFX/NS_Fire --emitter-name Sparks --module-name ScaleSpriteSize --script-usage ParticleUpdate

Enable or disable a module

Enables or disables a module in an emitter's stack without removing it. Disabled modules are skipped during simulation but their configuration is preserved. Useful for debugging or A/B testing different module setups.

cfa set_niagara_module_enabled --system-path /Game/VFX/NS_Fire --emitter-name Sparks --module-name Drag --script-usage ParticleUpdate --enabled=false
cfa set_niagara_module_enabled --system-path /Game/VFX/NS_Fire --emitter-name Sparks --module-name Drag --script-usage ParticleUpdate --enabled

Move a module to a new position in stack

Changes the execution order of a module within its script stage. Module order within a stage determines execution priority (earlier modules run first). Useful for ensuring dependent calculations happen in the correct sequence.

cfa reorder_niagara_module --system-path /Game/VFX/NS_Fire --emitter-name Sparks --module-name Drag --script-usage ParticleUpdate --new-index 0

Get input parameters for a module (keyword + top-N)

Returns the reveal-aware input parameters for a specific module in an emitter's stack, including the conditionally-revealed value inputs (Cylinder Radius, SpawnRate, Lifetime...) that the summary get_niagara_modules omits, with names, types and current values. input_filter narrows by keyword and ranks results by relevance (exact > prefix > substring); max_results caps the count (0 = all). Use both for a precise, token-light lookup like 'the radius input on ShapeLocation, top 5'. Response includes total_matched and truncated. Inputs the stack hides (a static switch or visibility condition leaves them out) are skipped and counted in hidden; include_hidden lists them. An inline on/off checkbox shows as its input's enabled.

cfa get_niagara_module_inputs --system-path /Game/VFX/NS_Fire --emitter-name Sparks --module-name AddVelocity --script-usage ParticleSpawn
cfa get_niagara_module_inputs --system-path /Game/VFX/NS_Fire --emitter-name Sparks --module-name ShapeLocation --script-usage ParticleSpawn --input-filter radius --max-results 5

Set an input value on a module

Sets a static input value on a module. The value is JSON-encoded and must match the parameter type (float for scalars, array for vectors, object for structs). Use get_niagara_module_inputs to discover available inputs and their types. For dynamic values (random ranges, curves, linked parameters), use set_niagara_dynamic_input instead.

cfa set_niagara_module_input --system-path /Game/VFX/NS_Fire --emitter-name Sparks --module-name SpawnRate --input-name SpawnRate --value 500 --script-usage EmitterUpdate
cfa set_niagara_module_input --emitter-path /Game/CFATest/E_Spark.E_Spark --module-name VortexVelocity --input-name "Velocity Amount" --value 400 --script-usage ParticleUpdate

Set a dynamic input on a module

Assigns a dynamic input to a module parameter. Dynamic inputs provide runtime-computed values. The 'script' type attaches ANY of the engine/project dynamic-input scripts (there are hundreds: Random Range Float, Random Jitter Float, Remap Range, Select Float from Array, Waveform, etc.) by its asset path via dynamic_input_script_path, discover paths with resolve_niagara_built_in_dynamic_input or search_niagara_functions --usage dynamic_input. Convenience shortcuts: random_range / uniform_random (min_value/max_value), parameter_link (parameter_name), custom_expression (expression). Not all fields apply to every type.

cfa set_niagara_dynamic_input --system-path /Game/VFX/NS_Fire --emitter-name Sparks --module-name InitialSize --input-name "SpriteSize" --script-usage ParticleSpawn --dynamic-input-type random_range --min-value 5.0 --max-value 15.0
cfa set_niagara_dynamic_input --system-path /Game/VFX/NS_Fire --emitter-name Sparks --module-name InitializeParticle --input-name "Mass" --script-usage ParticleSpawn --dynamic-input-type script --dynamic-input-script-path "/Niagara/DynamicInputs/Utility/RandomJitterFloat.RandomJitterFloat" --pin-defaults '{"Jitter Amount":"0.5"}'

Set a curve on a module input

Assigns a curve to a module input parameter. curve_type specifies the curve dimensionality (Float, Vector2, Vector3, Vector4, LinearColor). keys is a JSON array of key objects with time and value fields. Use for time-varying properties like color over life, size over life, or velocity curves.

cfa set_niagara_curve --system-path /Game/VFX/NS_Fire --emitter-name Flame --module-name ScaleColor --input-name "Scale Factor" --script-usage ParticleUpdate --curve-type Float --keys '[{"time": 0, "value": 0}, {"time": 0.2, "value": 1}, {"time": 1, "value": 0}]'
cfa set_niagara_curve --system-path /Game/VFX/NS_Fire --emitter-name Flame --module-name Color --input-name "Color" --script-usage ParticleUpdate --curve-type LinearColor --keys '[{"time": 0, "value": [1,0.5,0,1]}, {"time": 1, "value": [0.2,0,0,0]}]'

Set any module input value via the stack (local/enum/linked/hlsl/dynamic_input/data_interface/reset)

Universal, crash-free module-input value setter. Drives the editor's own stack (UNiagaraStackFunctionInput), so it never leaves the graph in a state the Niagara compiler rejects. kind selects the value form: local (scalar, [array] for vector/color, or {object} of fields), enum (name/display/int), linked (parameter_name), hlsl (expression), dynamic_input (dynamic_input_script), data_interface (data_interface_class + properties), reset (to_base for parent-emitter base). For a nested dynamic-input pin, pass input_name_stack instead of input_name.

cfa set_niagara_stack_value --system-path /Game/VFX/NS_Fire --emitter-name Sparks --module-name AddVelocity --input-name "Velocity" --script-usage ParticleSpawn --kind local --value '[0,0,250]'
cfa set_niagara_stack_value --system-path /Game/VFX/NS_Fire --emitter-name Sparks --module-name Color --input-name "Color" --script-usage ParticleUpdate --kind linked --parameter-name Particles.Color

Read a module input's current value and kind (round-trips to set_niagara_stack_value)

Reads an input's current value mode via the stack view model and reports it in the same shape set_niagara_stack_value accepts: kind plus value/parameter_name/expression/dynamic_input_script/data_interface_class. Dynamic inputs recurse into their child inputs. Pass input_name_stack to read a nested dynamic-input pin.

cfa get_niagara_stack_value --system-path /Game/VFX/NS_Fire --emitter-name Sparks --module-name AddVelocity --input-name "Velocity" --script-usage ParticleSpawn

Get user-exposed parameters

Returns user-exposed parameters on a Niagara system asset or on a placed Niagara component in the level. Provide system_path to read the asset definition, or actor_name to read runtime overrides on a placed instance. Shows parameter names, types, and value types. Use filter to narrow by parameter name substring.

cfa get_niagara_user_parameters --system-path /Game/VFX/NS_Fire
cfa get_niagara_user_parameters --actor-name "NS_Fire_Instance"
cfa get_niagara_user_parameters --system-path /Game/VFX/NS_Fire --filter Color

Add a user parameter to a system

Adds a new user-exposed parameter to a Niagara system. User parameters appear in the Details panel when the system is placed in a level and can be set per-instance. parameter_type is the Niagara type name (Float, Vector, LinearColor, Bool, Int32, etc.). Optionally provide a JSON-encoded default_value.

cfa add_niagara_user_parameter --system-path /Game/VFX/NS_Fire --parameter-name "Intensity" --parameter-type Float --default-value 1.0
cfa add_niagara_user_parameter --system-path /Game/VFX/NS_Fire --parameter-name "ParticleColor" --parameter-type LinearColor --default-value '[1, 0.5, 0, 1]'

Set a user parameter value

Sets the value of a user-exposed parameter. When actor_name is provided, sets the per-instance override on a placed Niagara component. When system_path is provided, sets the default value on the asset. parameter_type must match the parameter's declared type.

cfa set_niagara_user_parameter --actor-name "NS_Fire_Instance" --parameter-name "Intensity" --parameter-type Float --value 2.5
cfa set_niagara_user_parameter --system-path /Game/VFX/NS_Fire --parameter-name "ParticleColor" --parameter-type LinearColor --value '[0, 1, 0, 1]'

Remove a user parameter from a system

Removes a user-exposed parameter from a Niagara system the way the editor's parameter panel does. On UE 5.8 module inputs linked to it fall back to a local value holding its value, and renderer bindings to it are cleared; on 5.6 and 5.7 the editor leaves those links in place, and so does this command, so relink them (link_niagara_parameter) or reset them (clear_niagara_module_input). Placed instances that override this parameter lose their overrides. An unknown name is refused with the real ones listed.

cfa remove_niagara_user_parameter --system-path /Game/VFX/NS_Fire --parameter-name Intensity

Link a module input to a parameter

Links a module input to a Niagara parameter by namespace path. This makes the module input read its value from the linked parameter at runtime instead of using a static value. Common parameter paths include User.ParamName for user parameters, Emitter.Age, Particles.Lifetime, Engine.DeltaTime, etc.

cfa link_niagara_parameter --system-path /Game/VFX/NS_Fire --emitter-name Sparks --module-name ScaleColor --input-name "Scale Factor" --script-usage ParticleUpdate --linked-parameter "User.Intensity"
cfa link_niagara_parameter --system-path /Game/VFX/NS_Fire --emitter-name Sparks --module-name Color --input-name "Color" --script-usage ParticleUpdate --linked-parameter "User.ParticleColor"

Add a renderer to an emitter

Adds a renderer to an emitter. renderer_type specifies the kind: SpriteRenderer, MeshRenderer, RibbonRenderer, LightRenderer, ComponentRenderer, etc. Optionally set the material and mesh at creation time. Use set_niagara_renderer_property and set_niagara_renderer_binding to configure further.

cfa add_niagara_renderer --system-path /Game/VFX/NS_Fire --emitter-name Sparks --renderer-type SpriteRenderer --material-path /Game/Materials/M_Spark
cfa add_niagara_renderer --system-path /Game/VFX/NS_Fire --emitter-name Debris --renderer-type MeshRenderer --mesh-path /Game/Meshes/SM_Chunk --material-path /Game/Materials/M_Rock

Remove a renderer from an emitter

Removes a renderer from an emitter by its zero-based index. An emitter can have multiple renderers; use get_niagara_emitters or get_niagara_renderer_info to see their indices.

cfa remove_niagara_renderer --system-path /Game/VFX/NS_Fire --emitter-name Sparks --renderer-index 1

Get renderer properties and bindings

Returns detailed information about a renderer on an emitter, including its type, material, mesh (if applicable), all configurable properties, and all attribute bindings (which particle attributes drive which rendering features). Use to inspect before modifying.

cfa get_niagara_renderer_info --system-path /Game/VFX/NS_Fire --emitter-name Sparks
cfa get_niagara_renderer_info --system-path /Game/VFX/NS_Fire --emitter-name Sparks --renderer-index 1

Set a property on a renderer

Sets a property on a renderer. Common properties include SortMode, SubImageSize, Material, Alignment, FacingMode, SourceMode (for ribbons), and mesh-specific settings. Use get_niagara_renderer_info to discover available properties.

cfa set_niagara_renderer_property --system-path /Game/VFX/NS_Fire --emitter-name Sparks --property SortMode --value '"ViewDistance"'
cfa set_niagara_renderer_property --emitter-path /Game/CFATest/E_Spark.E_Spark --property Material --value "/Niagara/DefaultAssets/DefaultSpriteMaterial.DefaultSpriteMaterial"

Bind a renderer slot to a particle attribute

Binds a renderer slot to an attribute, like the slot's dropdown in the editor. The attribute must exist in the emitter's last compile (or be a User parameter) and have the slot's type: a ribbon's RibbonIdBinding takes a NiagaraID, not an int. A wrong name or type is refused with the valid choices listed. binding_name accepts the slot with or without the Binding suffix (Color = ColorBinding); a wrong slot lists the renderer's slots.

cfa set_niagara_renderer_binding --system-path /Game/VFX/NS_Fire --emitter-name Sparks --binding-name ColorBinding --attribute "Particles.Color"
cfa set_niagara_renderer_binding --system-path /Game/VFX/NS_Fire --emitter-name Sparks --binding-name SpriteSizeBinding --attribute "Particles.SpriteSize"

Auto-layout a Niagara script graph

Re-arranges a Niagara graph so it reads left to right into its Output node. Nodes are placed in columns by longest path to that sink, each one pin-aligned to what it feeds, and rows are stacked so boxes never overlap; unrelated sub-graphs become separate bands and fully disconnected nodes are parked out of the way. Node sizes are measured from the real graph widgets rather than guessed, so a Custom HLSL node gets the width its code actually needs and a Map Get with many pins gets the height. Long or node-crossing wires are then rerouted through reroute knots along a clean lane. Connectivity is never changed (A to B becomes A to knot to B, same endpoints) and knots from a previous run are dissolved first, so running it twice gives the same result. That dissolve takes out EVERY reroute in the graph, hand-placed ones included: a connected reroute is dissolved losslessly (its source is rewired straight to its targets, then routing is re-derived) while a disconnected one routes nothing and is dropped. The count comes back as reroutes_dissolved, so pass --route-knots=false if a graph has reroutes you placed deliberately. Addresses a graph exactly the way export_graph and build_graph do, so omitting --graph on an asset holding several lists them instead of guessing; --all-graphs lays out every one.

  cfa layout_niagara_graph --asset "/Game/FX/NSM_Drift"
  cfa layout_niagara_graph --asset "/Game/FX/NS_Sparks" --graph "ScratchPad/TurbulentDrift"
  cfa layout_niagara_graph --asset "/Game/FX/NS_Sparks" --all-graphs

Create a scratch pad module on a system or an emitter

Creates a new scratch pad module. Scratch pad modules are local scripts used for prototyping custom logic before extracting it to a standalone module asset. There are exactly TWO scopes, decided by which asset owns the scratch pad: pass system_path for a SYSTEM scratch pad (shared across that system's emitters, and the only kind a system editor can show), or emitter_path for a scratch pad on an emitter ASSET, which then travels with that emitter into any system reusing it. system_path plus emitter_name is REFUSED: a system editor resolves its scratch pad list to System->ScratchPadScripts and nothing else, so a scratch pad written into an emitter's container through a system would be invisible and uneditable there. Set parent_scratch only when building or repairing an inheritance chain, since parent scratch pads are what an inheriting emitter sees from its base. NOTE: the engine uniquifies the name (e.g. "CustomDrag" becomes "CustomDrag_0"); use the returned module_name verbatim for all follow-up scratch-pad commands.

  cfa create_niagara_scratch_pad_module --system-path /Game/VFX/NS_Fire --script-usage ParticleUpdate --module-name "CustomDrag"
  cfa create_niagara_scratch_pad_module --emitter-path /Game/VFX/E_Spark --script-usage ParticleUpdate --module-name "Wobble"

Set HLSL code on a scratch pad module

Sets the HLSL code body, input definitions, and output definitions on a scratch pad module. inputs is a JSON array of {name, type} objects defining input pins. outputs is a JSON array of {name, type} objects defining output pins. The HLSL code runs per-particle or per-emitter depending on the module's script_usage.

cfa set_niagara_scratch_pad_hlsl --system-path /Game/VFX/NS_Fire --module-name "CustomDrag" --hlsl-code "OutVelocity = Velocity * (1.0 - DragCoeff * DeltaTime);" --inputs '[{"name":"Velocity","type":"Vector"},{"name":"DragCoeff","type":"Float"}]' --outputs '[{"name":"OutVelocity","type":"Vector"}]'

Create a standalone Niagara script asset (module / dynamic input / function)

Creates a new standalone Niagara script asset that can be shared across systems. module_type selects the kind: module, dynamic_input, or function. Duplicates the editor's matching default template when available, else builds a minimal compilable graph. Author its graph afterward with the graph/HLSL/pin verbs via --script-path, then reference it into a system with add_niagara_module --module-path. Each graph/HLSL/pin edit auto-saves the standalone asset to disk, so authored scripts survive editor restarts. Standalone module/dynamic-input/function scripts have no self-compile, they compile in the context of the system that uses them, so 'compile status unknown' on the standalone asset is expected until it is placed in a system. New assets default to library_visibility=Exposed so they show up in the stack's Add menu; override as needed.

cfa create_niagara_module_asset --asset-path /Game/VFX/Modules/NM_CustomForce --module-type module --description "Applies custom force"
cfa create_niagara_module_asset --asset-path /Game/VFX/DynamicInputs/DI_Jitter --module-type dynamic_input --category "Custom/Motion" --suggested

Add an event handler to an emitter

Adds an event handler that responds to events generated by another emitter. execution_mode controls how the handler runs: every_particle (run on each existing particle), spawned_particles (spawn new particles per event). Use for collision responses, death events, or inter-emitter communication.

cfa add_niagara_event_handler --system-path /Game/VFX/NS_Fire --emitter-name Sparks --source-emitter Flame --event-name "CollisionEvent" --execution-mode spawned_particles --spawn-number 3
cfa add_niagara_event_handler --system-path /Game/VFX/NS_Fire --emitter-name Smoke --source-emitter Flame --event-name "DeathEvent" --execution-mode every_particle

Add a simulation stage to an emitter

Adds a custom simulation stage to an emitter. Simulation stages run additional passes after the main ParticleUpdate, useful for multi-pass algorithms like fluid simulation, neighbor searches, or iterative constraint solving. iteration_source can be particles or a data interface.

cfa add_niagara_simulation_stage --system-path /Game/VFX/NS_Fluid --emitter-name Particles --stage-name "PressureSolve" --iteration-source particles --num-iterations 4
cfa add_niagara_simulation_stage --system-path /Game/VFX/NS_Cloth --emitter-name Vertices --stage-name "ConstraintSolve" --num-iterations 8

List event handlers on an emitter

Returns all event handlers configured on an emitter, including source emitter, event type, execution mode, spawn number, and associated module stacks. Use before adding or modifying event handlers.

cfa get_niagara_event_handlers --system-path /Game/VFX/NS_Fire --emitter-name Sparks

Spawn a Niagara effect in the level

Spawns a Niagara system as an actor in the current level at the specified location. Returns the spawned actor name. Transform args accept Unreal canonical strings "(X=..,Y=..,Z=..)" / "(P=..,Y=..,R=..)" as well as bare CSV "X,Y,Z" or JSON object/array. Set auto_activate to false to spawn deactivated (use control_niagara_effect to activate later). Use actor_label for the Outliner display label (canonical across MCP tools); name is a legacy alias kept for backward compat.

cfa spawn_niagara_effect --system-path /Game/VFX/NS_Explosion --location "(X=100,Y=200,Z=0)"
cfa spawn_niagara_effect --system-path /Game/VFX/NS_Fire --location "(X=0,Y=0,Z=50)" --scale "(X=2,Y=2,Z=2)" --actor-label "CampfireVFX"
cfa spawn_niagara_effect --system-path /Game/VFX/NS_Ambient --location "(X=0,Y=0,Z=0)" --auto-activate=false

Control a Niagara effect in the level (play, stop, reset, pause, advance, seek, debug)

Controls the Niagara component of any level actor. action: activate, deactivate (finish naturally), kill (stop now), toggle, reset (the Details panel Reset button), reinit (rebuild the system instance), pause, unpause, advance (simulate --ticks or --seconds now), seek (restart at --age seconds), debug (the Details panel Debug button: opens the Niagara Debugger on this component). The response reports state, paused, age and live particle count. Use get_niagara_actors to find actor names.

cfa control_niagara_effect --actor-name "NS_Fire_Instance" --action activate
cfa control_niagara_effect --actor-name "CampfireVFX" --action pause
cfa control_niagara_effect --actor-name "CampfireVFX" --action advance --seconds 0.5
cfa control_niagara_effect --actor-name "NS_Ambient_0" --action seek --age 2

Add a Niagara component to an actor

Adds a UNiagaraComponent to an existing actor in the level. The component plays the specified Niagara system as a child of the actor. Use relative_location to offset the effect from the actor's root. Set auto_activate to false if you want to trigger it later.

cfa add_niagara_component --actor-name "Torch_BP" --system-path /Game/VFX/NS_TorchFlame --component-name "FlameVFX" --relative-location '{"X": 0, "Y": 0, "Z": 100}'
cfa add_niagara_component --actor-name "PlayerCharacter" --system-path /Game/VFX/NS_FootDust --auto-activate=false

List Niagara effect actors in the level

Returns all Niagara system actors currently placed in the level. Optionally filter by system asset name or path (substring of either) to find instances of a specific effect. Shows actor name, system path, location, and active state.

cfa get_niagara_actors
cfa get_niagara_actors --system-filter "/Game/VFX/NS_Fire"

List available Niagara modules

Searches the modules the editor's Add Module menu offers (engine and project), with the same filters: deprecated and non-library modules are hidden unless asked for, and --stage keeps only modules valid in that stage. --search matches every word anywhere in the name, keywords, category, description or path, ignoring case, spaces and underscores ("spawn burst" finds SpawnBurst_Instantaneous); name hits rank first. No match returns close names.

cfa list_niagara_modules --search "spawn burst"
cfa list_niagara_modules --search vortex --stage particle_update
cfa list_niagara_modules --search curl --include-deprecated

List available emitter templates

Lists built-in and project emitter templates that can be used with add_niagara_emitter. Templates provide pre-configured emitters with modules and renderers for common effects like fountains, sprites, mesh particles, ribbons, etc. The fluids category lists the NiagaraFluids solver emitters (needs the NiagaraFluids plugin enabled). The project category is every emitter asset under /Game, read from the asset registry with its Asset Description; pass its path to add_niagara_emitter --template. Filter by category to narrow results.

cfa list_niagara_emitter_templates
cfa list_niagara_emitter_templates --category sprite
cfa list_niagara_emitter_templates --category fluids

List Niagara data interface types

Lists available Niagara data interface types. Data interfaces provide external data to Niagara simulations (meshes, textures, audio, physics, landscape, splines, etc.). Use filter to search by name. Returns type names and descriptions.

cfa list_niagara_data_interfaces
cfa list_niagara_data_interfaces --filter "Mesh"

List Niagara parameter types by scope

Lists the Niagara types the type registry allows in a scope: user (User.* parameters), particle (Particles.* attributes), emitter, system, parameter, payload, numeric, index, or all. An unknown scope or kind is refused. Use filter to narrow results by name; max_results caps the list and total_matched says how many matched.

cfa list_niagara_parameter_types
cfa list_niagara_parameter_types --scope particle --filter "Color"
cfa list_niagara_parameter_types --scope all --filter Vector

Get attributes available on an emitter

Returns attributes available on an emitter including rapid iteration parameters and well-known particle attributes (Position, Velocity, Color, etc.). Shows names, types, scope, and source. Use filter to narrow by attribute name substring.

cfa get_niagara_emitter_attributes --system-path /Game/VFX/NS_Fire --emitter-name Sparks
cfa get_niagara_emitter_attributes --system-path /Game/VFX/NS_Fire --emitter-name Sparks --scope particle
cfa get_niagara_emitter_attributes --system-path /Game/VFX/NS_Fire --emitter-name Sparks --filter Color

List editable properties on a renderer with current values

Returns all editable UPROPERTY fields on a renderer (sprite, ribbon, mesh, light, component) with their current values and valid enum options. Use filter to get specific properties, strongly recommended to save tokens. Property names can be used directly with set_niagara_renderer_property.

cfa get_niagara_renderer_properties --system-path /Game/VFX/NS_Fire --emitter-name Sparks --filter Facing
cfa get_niagara_renderer_properties --system-path /Game/VFX/NS_Fire --emitter-name Sparks --filter Material
cfa get_niagara_renderer_properties --system-path /Game/VFX/NS_Fire --emitter-name Sparks --filter Sort

Set a system-level property via reflection

Sets any UPROPERTY on UNiagaraSystem: WarmupTime, WarmupTickDelta, bDeterminism, RandomSeed, bFixedBounds, FixedBounds, bFixedTickDelta, FixedTickDeltaTime, etc. Use the exact C++ property name (PascalCase). For booleans, can auto-add 'b' prefix.

cfa set_niagara_system_property --system-path /Game/VFX/NS_Fire --property WarmupTime --value 2.0
cfa set_niagara_system_property --system-path /Game/VFX/NS_Fire --property bDeterminism --value true
cfa set_niagara_system_property --system-path /Game/VFX/NS_Fire --property RandomSeed --value 42

Get actual module input values (spawn rate, colors, forces, etc.)

Returns all rapid iteration parameters, the real configurable values on Niagara modules. These include spawn rate, gravity, colors, sizes, lifetimes, and every other editable module input. Each parameter includes its module name, input name, current value, and type. Use the filter parameter to narrow results.

cfa get_niagara_rapid_iteration_parameters --system-path /Game/VFX/NS_Fire --emitter-name Sparks
cfa get_niagara_rapid_iteration_parameters --system-path /Game/VFX/NS_Fire --emitter-name Sparks --filter SpawnRate
cfa get_niagara_rapid_iteration_parameters --system-path /Game/VFX/NS_Fire --emitter-name Sparks --script-usage particle_spawn --filter Color

Set a module input value (spawn rate, color, force, size, etc.)

Sets a rapid iteration parameter value on a Niagara module. This is the primary way to change module inputs like spawn rate, colors, forces, sizes, and lifetimes. Use get_niagara_rapid_iteration_parameters first to discover available parameters. Value format: float (5.0), int (10), bool (true), vector ({"x":1,"y":2,"z":3} or [1,2,3]), color ({"r":1,"g":0.5,"b":0,"a":1}); fields left out keep their value. A value that does not parse for the input's type is refused and nothing is written.

cfa set_niagara_rapid_iteration_parameter --system-path /Game/VFX/NS_Fire --emitter-name Sparks --module-name SpawnRate --input-name SpawnRate --value 50 --script-usage emitter_update
cfa set_niagara_rapid_iteration_parameter --system-path /Game/VFX/NS_Fire --emitter-name Sparks --module-name InitializeParticle --input-name Color --value '{"r":1,"g":0.3,"b":0,"a":1}' --script-usage particle_spawn
cfa set_niagara_rapid_iteration_parameter --system-path /Game/VFX/NS_Fire --emitter-name Sparks --module-name GravityForce --input-name Gravity --value '{"x":0,"y":0,"z":-980}' --script-usage particle_update

Get compilation errors and warnings for a Niagara system

Returns compile and runtime-setup issues: compile events from the system and each emitter script (each names the module that raised it), GPU shader errors, renderer feedback and message-log entries. Most severe first. Module-level stack issues (unmet dependencies, deprecated modules, missing fixed bounds) come from validate_niagara_stack.

cfa get_niagara_system_errors --system-path /Game/VFX/NS_Fire
cfa get_niagara_system_errors --system-path /Game/VFX/NS_Fire --emitter-name Sparks --severity error

Get live particle counts and emitter execution state

Returns live particle counts per emitter, total spawned, execution state, sim target and per-emitter bounds (component-local). Reads the open editor preview, the PIE world or a level actor (--source, --actor-name); the result names which instance it read.

cfa get_niagara_particle_stats --system-path /Game/VFX/NS_Fire
cfa get_niagara_particle_stats --system-path /Game/VFX/NS_Fire --emitter-name Sparks

Set the timeline playback range in the Niagara editor

Controls how long the Niagara editor preview plays. If your effect dies at 0.02s, extend the range. For looping effects set a longer range (e.g. 5-10 seconds). Optionally override the frame rate.

cfa set_niagara_playback_range --system-path /Game/VFX/NS_Fire --range-end 5.0
cfa set_niagara_playback_range --system-path /Game/VFX/NS_Fire --range-start 0.5 --range-end 10.0 --frame-rate 30

Get the current playback range and frame rate settings

Returns the current timeline playback range (start/end in seconds) and frame rate configuration. Use to check if the playback range is too short, a common cause of effects appearing to not play.

cfa get_niagara_playback_range --system-path /Game/VFX/NS_Fire

Check for outdated modules in an emitter

Identifies modules that have newer versions available, a common source of Niagara warnings and compatibility issues. Lists each module of every stack stage once (events and simulation stages included), labelled with its stage like get_niagara_modules, with current and available versions. Use filter to narrow by module name substring.

cfa get_niagara_module_versions --system-path /Game/VFX/NS_Fire --emitter-name Sparks
cfa get_niagara_module_versions --system-path /Game/VFX/NS_Fire --emitter-name Sparks --filter "Spawn"

Export a full Niagara System / Script / Emitter as reflection-grounded JSON

Auto-detects the asset class and writes one JSON file. System export captures: system properties, user parameters (with default values), every emitter (sim target, local space, full emitter-data properties, renderers), every stage's ordered module stack with resolved input values (including dynamic inputs + nested pins), and all scratch-pad/local scripts WITH their full node graph + dynamic inputs. Separate-asset modules/DIs (engine or /Game) are listed as lightweight references (path + name + description/category/library-visibility + usage flags), NOT their internal graph, which is re-exportable by running export_niagara on that asset's path. Written to Saved/CodeFizzEditorAgent/Exports/.

cfa export_niagara --asset /Game/VFX/NS_SolarSystem
cfa export_niagara --asset /Game/VFX/NM_PlanetInit
cfa export_niagara --asset /Game/VFX/NS_SolarSystem --include-values=false --include-stage-graphs=true

Introspect every node inside a Niagara graph

Three resolver modes: (1) system_path + module_name for scratch pad module, (2) system_path + emitter_name + script_usage for emitter stack graph, (3) script_path for standalone UNiagaraScript asset. Returns nodes with pin/link detail based on verbosity. Token-efficient, use type_filter/name_filter to narrow.

cfa get_niagara_graph_nodes --system-path /Game/VFX/NS_Fire --module-name MyScratchPad
cfa get_niagara_graph_nodes --system-path /Game/VFX/NS_Fire --emitter-name Sparks --script-usage emitter_update --type-filter FunctionCall

Deep inspect a single Niagara node by index, class, or GUID

Returns full pin layout, link detail, and node-type-specific fields (op_name for Op, function_script for FunctionCall, hlsl_preview for CustomHlsl, input_name/type for Input).

cfa get_niagara_node_info --system-path /Game/VFX/NS_Fire --module-name MyDI --node-index 2
cfa get_niagara_node_info --script-path /Game/VFX/MyModule --node-class MapGet

BFS trace of connections upstream or downstream from a node

Walks the graph from a starting node with optional pin_name filter. Returns each visited node with depth so the dependency chain is visible without dumping the whole graph. A start node that is not in the graph is refused, naming it and listing the node classes present.

cfa trace_niagara_connection --system-path /Game/VFX/NS_Fire --module-name MyDI --node-class MapGet --direction downstream --pin-name "Vector Array"

Classify orphaned, dead-end, and missing-input nodes in a Niagara graph

Returns orphaned (no incoming or outgoing links), dead_ends (inputs connected but no outputs consumed), missing_inputs (no link and no default) and unreachable_from_output, plus a verdict: fail when an input has neither link nor default, pass_with_warnings for stray nodes or an open editor copy out of sync with the asset, pass otherwise. Skips +Add placeholder pins.

cfa validate_niagara_graph --system-path /Game/VFX/NS_Fire --module-name MyDI

Apply scratch pad changes in an open Niagara System (Apply Scratch button)

Triggers exactly what a user clicks in the open Niagara System editor. With module_name it applies that one scratch script (FNiagaraScratchPadScriptViewModel::ApplyChanges). WITHOUT module_name it is the toolbar's "Apply Scratch" button, applies ALL pending scratch changes via the system's scratch-pad view model (FNiagaraSystemToolkit::OnApplyScratchPadChanges). Pass compile=true to also recompile + refresh + save the system afterwards (like clicking Compile next). Requires the system to be open in the editor.

cfa apply_niagara_scratch_pad --system-path /Game/VFX/NS_Fire            # Apply Scratch (all)
cfa apply_niagara_scratch_pad --system-path /Game/VFX/NS_Fire --module-name MyDI  # one script
cfa apply_niagara_scratch_pad --system-path /Game/VFX/NS_Fire --compile

Apply a scratch pad module's edit-copy and save the asset (Apply & Save button)

Mirrors FNiagaraScratchPadScriptViewModel::ApplyChangesAndSave.

cfa apply_and_save_niagara_scratch_pad --system-path /Game/VFX/NS_Fire --module-name MyDI

List all scratch pad modules on a Niagara System

Returns name, path, usage, node counts, and custom HLSL node count per script.

cfa list_niagara_scratch_pad_modules --system-path /Game/VFX/NS_Fire

Delete a scratch pad module from a system or emitter

Removes the scratch pad from the container that actually owns it. Searching starts with the system's own scratch pads, then every emitter's own and inherited ones, so a scratch pad that ended up on an emitter can still be found and cleaned up. Narrow the search with emitter_name.

  cfa delete_niagara_scratch_pad_module --system-path /Game/VFX/NS_Fire --module-name MyDI
  cfa delete_niagara_scratch_pad_module --emitter-path /Game/VFX/E_Spark --module-name Wobble

Duplicate a scratch pad module with a new name

The copy is placed in the same container as its source. Duplicating an emitter-scoped scratch pad reached through a system is refused for the same reason create is: a system editor never displays an emitter's container. Address the emitter asset with emitter_path instead.

  cfa duplicate_niagara_scratch_pad_module --system-path /Game/VFX/NS_Fire --module-name MyDI --new-name MyDICopy
  cfa duplicate_niagara_scratch_pad_module --emitter-path /Game/VFX/E_Spark --module-name Wobble --new-name Wobble2

Rename a scratch pad module

Renames in place, keeping the script under the outer that owns it. Works in every scope so a scratch pad on an emitter can be renamed too. Narrow the search with emitter_name.

  cfa rename_niagara_scratch_pad_module --system-path /Game/VFX/NS_Fire --module-name Old --new-name New
  cfa rename_niagara_scratch_pad_module --emitter-path /Game/VFX/E_Spark --module-name Old --new-name New

Read the details-panel properties of a Niagara script

Returns Category, Description, Keywords, ModuleUsageBitmask, ProvidedDependencies, RequiredDependencies, LibraryVisibility, bDeprecated, DeprecationMessage, bExperimental, ExperimentalMessage, NumericOutputTypeSelectionMode, ScriptMetaData, ConversionUtility.

cfa get_niagara_script_properties --system-path /Game/VFX/NS_Fire --module-name MyDI

Batch-set details-panel properties on a Niagara script

Pass a JSON object under --properties with any subset of the editable fields. ModuleUsageBitmask uses ENiagaraScriptUsage bitmask (e.g. particle spawn + update = (1<<3)|(1<<4)). ProvidedDependencies takes a JSON array of strings; RequiredDependencies an array of objects.

cfa set_niagara_script_properties --system-path /Game/VFX/NS_Fire --module-name MyDI --properties '{"Category":"MCP/DI","bExperimental":true,"ProvidedDependencies":["MCP.ArrayLength"]}'

List input + output parameters of a Niagara script

Outputs come from UNiagaraNodeOutput::Outputs. Inputs come from script variable metadata filtered to Module.* / Input.* / User.* namespaces.

cfa list_niagara_script_parameters --system-path /Game/VFX/NS_Fire --module-name MyDI

Add an input or output parameter to a Niagara script

For 'output' direction appends to UNiagaraNodeOutput::Outputs. Type must be a FNiagaraTypeRegistry name (e.g. float, Vector, Vector2D, Vector4, LinearColor, Quat, Position, NiagaraID, int32, bool, Matrix, NiagaraDataInterfaceArrayPosition).

cfa add_niagara_script_parameter --system-path /Game/VFX/NS_Fire --module-name MyDI --name TestFloat --type float --direction output

Remove a named input or output parameter, cascades to Map Get/Set pins; an unknown name is refused

cfa remove_niagara_script_parameter --system-path /Game/VFX/NS_Fire --module-name MyDI --name Module.Default --direction input

Rename a script parameter across asset and edit-copy graphs; an input also renames its Map Get/Set pins

cfa rename_niagara_script_parameter --system-path /Game/VFX/NS_Fire --module-name MyDI --old-name NewOutput --new-name FinalNoise --direction output

Create a new node inside a Niagara graph

Provide node_type OR class_path. node_type options: Op (requires op_name), FunctionCall (requires function_script), DataInterfaceFunction (requires di_class + function_name), ParameterMapGet, ParameterMapSet, Reroute, Input (requires input_name + input_type). class_path spawns ANY UNiagaraNode subclass (full path, NiagaraNodeXxx, or Xxx), discover via list_niagara_node_types / search_niagara_nodes. Discover op_name via get_niagara_schema_actions and DI function_name via list_niagara_data_interface_functions, never guess.

cfa add_niagara_graph_node --system-path /Game/VFX/NS_Fire --module-name MyDI --node-type Op --op-name "Numeric::Mul" --pos-x 100 --pos-y 100
cfa add_niagara_graph_node --script-path /Game/VFX/DI/DI_Foo.DI_Foo --class-path NiagaraNodeStaticSwitch

Delete a node from a Niagara graph

Provide node_index (ordinal) OR node_id (FGuid from get_niagara_graph_nodes). An index out of range or an unknown id is refused, naming it and the graph's node count.

cfa delete_niagara_graph_node --system-path /Game/VFX/NS_Fire --module-name MyDI --node-index 4

Build a whole Niagara graph at once, many nodes + connections in one call

Bulk graph builder (parity with build_material_graph). Spawns every node in 'nodes' (array index = node id), wires every edge in 'connections', then applies per-node pin defaults. The schema validates each wire and inserts conversion nodes like a drag-connect; a refused wire names the side that failed and lists that node's pins. Targets a standalone script (script_path) or a scratch module (system_path + module_name). success is false when any node, wire, default or the auto-compile failed. Node spec: {node_type|class_path, op_name|function_script|di_class+function_name|input_name+input_type, pos_x, pos_y, defaults:{Pin: value}, properties:{Property: value}}. Input nodes take default (the argument's default value). CustomHlsl takes hlsl_code + inputs/outputs [{name,type}]. ParameterMapGet takes get_pins [{name,type,default?}] (default sets a Module.* input's default value, as the Parameters panel does); ParameterMapSet takes set_pins [{name,type}]; Output takes outputs [{name,type}] and retypes the kept Output node. Connections use from_node/to_node (index) or from_node_class/to_node_class for a kept node such as Input/Output. Unconnected Map Get/Set sources are wired to the Input map for you. clear_existing keeps only the Output node and the parameter-map Input; typed function inputs are rebuilt from the document. Unknown op_name values fail with the closest real op names.

cfa build_niagara_graph --system-path /Game/VFX/NS_Fire --module-name MyMod_0 --clear-existing --nodes '[{"node_type":"ParameterMapGet","get_pins":[{"name":"Particles.Age","type":"float"}]},{"node_type":"CustomHlsl","hlsl_code":"OutV=Age*2;","inputs":[{"name":"Age","type":"float"}],"outputs":[{"name":"OutV","type":"float"}]},{"node_type":"ParameterMapSet","set_pins":[{"name":"Particles.Lifetime","type":"float"}]}]' --connections '[{"from_node_class":"Input","from_pin":"Input","to_node":0,"to_pin":"Source"},{"from_node":0,"from_pin":"Particles.Age","to_node":1,"to_pin":"Age"},{"from_node":1,"from_pin":"OutV","to_node":2,"to_pin":"Particles.Lifetime"},{"from_node":2,"from_pin":"Dest","to_node_class":"Output","to_pin":"OutputMap"}]'

Add an input pin to a Custom HLSL node

cfa add_niagara_custom_hlsl_input --system-path /Game/VFX/NS_Fire --module-name MyDI --pin-name Value --pin-type float

Add an output pin to a Custom HLSL node (a name the node already has is refused)

cfa add_niagara_custom_hlsl_output --system-path /Game/VFX/NS_Fire --module-name MyDI --pin-name Result --pin-type float

Rename a Custom HLSL pin and the identifier in the HLSL body (whole tokens and Name.member, never comments or other names)

cfa rename_niagara_custom_hlsl_pin --system-path /Game/VFX/NS_Fire --module-name MyDI --old-name Value --new-name Scalar

Remove a pin from a Custom HLSL node

cfa remove_niagara_custom_hlsl_pin --system-path /Game/VFX/NS_Fire --module-name MyDI --pin-name Value

Add a typed output pin to the first ParameterMapGet node in a scratch pad graph

Mirrors clicking + on a Map Get node in the editor. The pin name becomes the parameter handle (e.g. Module.MyParam, Engine.DeltaTime, User.MyParam).

cfa add_niagara_map_get_pin --system-path /Game/VFX/NS_Fire --module-name MyDI --parameter-name Module.Position --parameter-type Vector

Add a typed input pin to the first ParameterMapSet node in a scratch pad graph

cfa add_niagara_map_set_pin --system-path /Game/VFX/NS_Fire --module-name MyModule --parameter-name Particles.Velocity --parameter-type Vector

Add a pin to a node that shows a '+' pin on that side (Map Get/Set, Custom HLSL, some ops); others are refused

cfa add_niagara_node_pin --system-path /Game/VFX/NS_Fire --module-name MyDI --node-index 3 --pin-name Extra --pin-type float --direction output

Rename a pin on a dynamic-pin node

cfa rename_niagara_node_pin --system-path /Game/VFX/NS_Fire --module-name MyDI --node-index 3 --old-name Foo --new-name Bar

Remove a dynamic pin from any node in a scratch pad graph

cfa remove_niagara_node_pin --system-path /Game/VFX/NS_Fire --module-name MyDI --node-index 2 --pin-name Module.Default

Wire one node's output pin to another node's input pin inside a scratch pad graph

Validated via UEdGraphSchema_Niagara::TryCreateConnection. Identify each side via (class|index|id) + pin name. A pin that is not on the node is refused, naming it and listing that node's pins on that side; a refused connection carries the schema's reason.

cfa connect_niagara_pins --system-path /Game/VFX/NS_Fire --module-name MyDI --from-node-index 2 --from-pin Module.Position --to-node-index 3 --to-pin Array\ interface

Break a pin connection in a scratch pad graph

cfa disconnect_niagara_pins --system-path /Game/VFX/NS_Fire --module-name MyDI --node-index 3 --pin-name "Array interface"

Enumerate Niagara node classes available for spawning

cfa list_niagara_node_types --filter Parameter

Get pin schema for a node class (class_name) or a script asset (script_path); either one is enough

cfa get_niagara_node_type_info --class-name NiagaraNodeParameterMapGet

Find Niagara function, dynamic input or module scripts by words

Searches the same script list the graph's Functions menu and the stack's dynamic input menu show. Every word must match the name, keywords, description or path (case, spaces and underscores ignored), best matches first. Deprecated scripts are hidden unless include_deprecated. A miss returns the closest names.

cfa search_niagara_functions --search "random range" --usage dynamic_input

Search the full Niagara node palette (the right-click menu) by keyword + category

Wraps UEdGraphSchema_Niagara::GetGraphActions, the exact data the editor's right-click menu uses (ops, function/module/dynamic-input scripts, make/break, convert, DI nodes). Runs against a standalone script (script_path) OR an in-system scratch module (system_path + module_name). Each entry has display_name, category, tooltip, keywords, the spawn descriptor (op_name / function_script / node_type / input_name+type) and full input/output pin schema with Niagara types, feed straight into add_niagara_graph_node.

cfa get_niagara_schema_actions --script-path /Game/VFX/DI/DI_Foo.DI_Foo --filter align --max-results 5
cfa get_niagara_schema_actions --system-path /Game/VFX/NS_Fire --module-name MyDI --category Math --filter multiply

Generic type query, handles registered Niagara types AND raw UEnums/UScriptStructs

First tries FNiagaraTypeRegistry; falls back to UEnum/UScriptStruct reflection for script-property enums like ENiagaraScriptLibraryVisibility or any custom project enum.

cfa describe_niagara_type --type Vector
cfa describe_niagara_type --type ENiagaraScriptLibraryVisibility

Walk a UNiagaraDataInterface class default object and return its editable property schema

cfa get_niagara_data_interface_schema --di-class NiagaraDataInterfaceArrayPosition

List available Niagara parameters (Engine.*, Particles.*, Emitter.*, User.*)

cfa list_niagara_available_parameters --namespace engine --filter Time

Resolve the actual binding of each module input, Default / Local / Linked / Dynamic / Data

Answers 'what is Spawn Count actually driven by?'. Recursively walks dynamic-input children up to max_depth so a single call returns the full binding tree with nested parameter links and literal values. A literal the stack keeps as a rapid-iteration constant reads as mode local with its value; default means neither an override nor a constant is set.

cfa get_niagara_module_input_binding --system-path /Game/VFX/NS_Fire --emitter-name Sparks --module-name SpawnPerFrame --script-usage emitter_update

Reset a module input to its default (including nested paths like 'Spawn Count.Position Array')

Runs the stack's own 'Reset to Default' on the input: links, dynamic inputs, expressions and local values (rapid-iteration constants included) all go back to the module default. was_overridden says whether it differed from the default. An unknown input is refused with the module's inputs listed. Supports nested path syntax to reach inputs inside dynamic inputs.

cfa clear_niagara_module_input --system-path /Game/VFX/NS_Fire --emitter-name Sparks --module-name SpawnPerFrame --script-usage emitter_update --input-name "Spawn Count.Position Array"

Reproduce the stack-UI source dropdown for a specific input

Returns the exact options the stack's dropdown offers for this input, asked of the input itself: dynamic_inputs are the library dynamic inputs and scratch pads whose output type fits the input (source asset_registry or scratch_pad), link_parameters the parameters it can link to, each with its namespace and any conversion_script. An unknown input is refused. Call this before set_niagara_dynamic_input / link_niagara_parameter to never guess.

cfa list_niagara_input_source_menu --system-path /Game/VFX/NS_Fire --emitter-name Sparks --module-name SpawnPerFrame --script-usage emitter_update --input-name "Spawn Count" --name-filter Length

Find where a scratch pad script is referenced across all emitter/system graphs

Scans every emitter × {spawn, update, particle_spawn, particle_update} + system_spawn + system_update graphs for UNiagaraNodeFunctionCall nodes whose FunctionScript matches. Returns usage sites as {emitter, script_usage, function_name, node_id, is_dynamic_input}.

cfa find_niagara_scratch_pad_usage --system-path /Game/VFX/NS_Fire --module-name GetDataInterfaceLength

Discover built-in dynamic-input script paths via AssetRegistry (replaces hardcoded guesses)

Replaces guessed paths like /Niagara/Modules/DynamicInputs/UniformRangedFloat (which vary across UE versions) with a live AssetRegistry scan. Returns UNiagaraScript assets with Usage=DynamicInput matching the filter, with total_matched and truncated when max_results cut the list. An exact_name that matches nothing is refused with the closest names.

cfa resolve_niagara_built_in_dynamic_input --name-filter Random --max-results 10

Enumerate member functions on a Niagara data interface class

Returns the functions the editor's right-click 'Functions' submenu shows on a DI pin, built-in DI members like Array.Length, Array.Get, Array.Add. These aren't UNiagaraScript assets so search_niagara_functions won't find them. Pass the result as function_name to add_niagara_graph_node(node_type='DataInterfaceFunction').

cfa list_niagara_data_interface_functions --di-class NiagaraDataInterfaceArrayPosition --filter Length

Read live particle attributes (the Attribute Spreadsheet) from a running Niagara system

Captures one frame of a running Niagara system through the engine's sim cache, the same capture the Niagara editor's Attribute Spreadsheet uses, and returns it column-oriented per emitter: columns (Position.X, Color.R, Age...), rows for particles [offset, offset+max_results), and stats with min, max and mean per component over EVERY particle, not just the returned rows. verdict is fail when any attribute holds NaN or infinite values (issues names them). The instance comes from the open Niagara editor preview, the level or the PIE world (source, actor_label and matches say which was read). It must be running: a paused, not-yet-spawned or completed instance is refused with how to resume it. GPU emitters are read back synchronously. Systems with lightweight (stateless) emitters are refused because the engine's capture crashes on them; get_niagara_particle_stats still covers those. Pass --attributes to capture only what you need, which also keeps the output small. Positions are world space unless --world-space=false.

  cfa get_niagara_particle_data --system-path /Game/VFX/NS_Fire
  cfa get_niagara_particle_data --system-path /Game/VFX/NS_Fire --emitter-name Sparks --attributes Position,Velocity --max-results 5
  cfa get_niagara_particle_data --actor-name FxTest --source level --attributes Color --stats=false

Read the live parameter values a running Niagara instance is simulating with

Lists the parameter stores of a running Niagara instance as compact rows {n: name, t: type, v: value, src: store}. --scope user reads the component's user parameter overrides (world positions for Position types), engine reads the instance parameters (Engine.Owner.Position and friends), system reads the system spawn/update script contexts, emitter reads each emitter's particle script contexts and GPU context, constants keeps only Constants.* (the rapid-iteration values the VM actually runs), and all (default) reads everything with duplicates removed. Data interfaces report their class and object parameters their path. The instance is found the same way get_niagara_particle_data finds it.

  cfa get_niagara_runtime_parameters --system-path /Game/VFX/NS_Fire --scope user
  cfa get_niagara_runtime_parameters --actor-name FxTest --source level --scope constants --emitter-name Sparks
  cfa get_niagara_runtime_parameters --system-path /Game/VFX/NS_Fire --filter SpawnRate

VM op counts and GPU instruction counts for a Niagara system's scripts

Reports each script of a system (system spawn/update plus every emitter's scripts) as {usage, emitter, status, op_count, stale}, and for GPU emitters the gpu_compute script's instruction count per simulation stage on the platform the editor is running. op_count is computed only by a real compile and is not saved with the asset, so a script loaded from disk or served from the DDC reports op_count null with stale:true; compile_niagara_system --force fills it.

  cfa get_niagara_script_stats --system-path /Game/VFX/NS_Fire
  cfa get_niagara_script_stats --system-path /Game/VFX/NS_Fire --emitter-name Sparks

Read the HLSL, VM assembly or GPU HLSL a Niagara script compiled to

With no script_usage, grep or function it returns an availability table: characters of hlsl, assembly and gpu text per script (under 1 KB). Then read one script: --function extracts one module's generated function body by name (e.g. SolveForcesAndVelocity; without --script-usage the first script defining it is used), --grep returns matching lines with --context lines around them (wrap it in slashes, /like.*this/, for a regular expression; --offset skips matches), and otherwise --offset/--max-lines page through the text. Lines are numbered, grep -n style. hlsl and assembly are not saved with the asset and exist only after a real compile in this editor session (compile_niagara_system --force); kind gpu is saved and always readable for GPU emitters.

  cfa get_niagara_generated_code --system-path /Game/VFX/NS_Fire
  cfa get_niagara_generated_code --system-path /Game/VFX/NS_Fire --emitter-name Sparks --function SolveForcesAndVelocity
  cfa get_niagara_generated_code --system-path /Game/VFX/NS_Fire --emitter-name Sparks --script-usage particle_update --grep Velocity
  cfa get_niagara_generated_code --system-path /Game/VFX/NS_Gpu --kind gpu --grep "/Particles_Position.*=/"

Pause, step, loop or slow down every Niagara effect (the Niagara Debugger toolbar)

Drives the Niagara Debugger's playback toolbar without opening its window, for every world the editor runs. --mode play, pause, loop (effects restart when they finish, or every --loop-time seconds) or step (run one frame, then hold paused, like the toolbar's Step button). --rate sets the speed, above 0 and at most 10 (0.25 is quarter speed, 1 is normal). Custom playback only applies while the Debug HUD gate is open, so this opens it; that alone draws nothing on screen. The result reads each world's mode and rate back. A world switches mode on its next tick, so worlds[].mode can still show the old mode right after a change; get_niagara_debug_state verifies it. A placed effect only moves while its world ticks: in the editor that needs a Realtime level viewport (focus_viewport turns it on) or Play In Editor, and world_ticking says which.

  cfa set_niagara_debug_playback --mode pause
  cfa set_niagara_debug_playback --mode step
  cfa set_niagara_debug_playback --mode play --rate 0.25
  cfa set_niagara_debug_playback --mode loop --loop-time 2

Configure the Niagara Debug HUD: presets, filters and any HUD setting by name

Sets the Niagara Debug HUD, the in-viewport overlay the Niagara Debugger draws, without opening the Debugger window. --enabled turns it on or off. --preset component is the Debug button of a Niagara component's Details panel: it filters the HUD to that component, its system and its actor and shows in-world system info (--target is the actor, --component-name picks one of several components). --preset system filters to one system (--target is a System path, or an actor) and turns the overview on. --preset validate checks system and particle buffers for NaN every frame and logs each bad value to the Output Log; add --target to narrow it. --preset off turns the HUD off. --properties sets any HUD settings field by its UPROPERTY name through reflection, e.g. {"bOverviewEnabled": true, "OverviewMode": "Performance", "SystemFilter": "NS_Fire*"}; get_niagara_debug_state --fields "*" lists every field with its value, and a misspelled name suggests the closest. Properties apply after the preset, and a failed write changes nothing. On UE 5.8 setting a filter also turns on the master switch bFiltersEnabled, which the engine's own Debug button leaves off. Settings are saved to your per-project editor settings, as the Debugger window does. The result lists every changed field with its value read back, hud_active, and warnings when the HUD would draw nothing. The HUD draws in viewports that render; --open-debugger also opens the Niagara Debugger window on its Debug HUD tab.

  cfa set_niagara_debug_hud --preset component --target "NS_Fire_1"
  cfa set_niagara_debug_hud --preset system --target /Game/VFX/NS_Explosion
  cfa set_niagara_debug_hud --preset validate
  cfa set_niagara_debug_hud --properties '{"bOverviewEnabled": true, "OverviewMode": "Performance"}'
  cfa set_niagara_debug_hud --preset off

Read back the Niagara Debugger's playback and HUD state, with a verdict

The verification counterpart of set_niagara_debug_playback and set_niagara_debug_hud. Reads the playback settings (mode, effective rate, loop time, and whether the HUD gate lets them apply), each world's live Niagara mode and rate, whether a level world is ticking, the Debug HUD summary (active, overview and its mode, system verbosity, validation, particle attributes, active filters) and whether the Debugger window is open. verdict is pass, pass_with_warnings or fail, and each warning names its cause: playback ignored because the HUD is off, a world that never got the current mode, no ticking world, a HUD that is on but draws nothing, filters ignored by the UE 5.8 master switch. --fields lists the HUD settings fields whose name contains the text, with their values ("*" for all): the names set_niagara_debug_hud --properties takes.

  cfa get_niagara_debug_state
  cfa get_niagara_debug_state --fields Filter
  cfa get_niagara_debug_state --fields "*" --max-results 100

Capture the Niagara FX Outliner: every live system and component, with state and timings

Takes the capture the Niagara Debugger's FX Outliner tab takes, through the editor's own debugger client: every world running Niagara (editor, Play In Editor, asset previews), each system asset in it, and each component instance with its execution state (plus the requested state when they differ), particle count, scalability cull reason, cull proxy, pooling, solo ticking and, with --include-emitters, each emitter's sim target, state and particle count. --delay-frames 0 (default) captures now and returns the data. --delay-frames N waits N frames while gathering average and max game and render thread times in microseconds per world, system and component, and returns a capture_id with state pending: collect it with get_niagara_outliner_capture. Timings only accumulate while the world ticks (a Realtime viewport or Play In Editor). The client runs one capture at a time and drops a request made while another is pending, which is reported as an error. --world, --system-filter and --max-results keep the answer small; the result reports total_components and truncated.

  cfa capture_niagara_outliner
  cfa capture_niagara_outliner --system-filter NS_Fire --include-emitters
  cfa capture_niagara_outliner --delay-frames 60 --world UEDPIE

Collect a delayed FX Outliner capture, or re-slice the latest one

Returns the capture that capture_niagara_outliner started: state pending with frames_left while it gathers, the data once it is done, or an error when the debugger client dropped it because another capture was pending. Only the latest capture is kept, and it can be read again with a different --world, --system-filter, --include-emitters or --max-results to page through a large scene.

  cfa get_niagara_outliner_capture --capture-id 3
  cfa get_niagara_outliner_capture --system-filter NS_Fire --include-emitters

Read the Niagara editor's Simulation menu options and playback speeds

Reads the options under the Niagara editor toolbar's Simulation menu: auto_play, reset_on_change, resimulate_when_paused, reset_dependent_systems (emitter editors only) and auto_compile, plus the playback speeds the timeline's speed menu offers. These are per-user editor settings, shared by every Niagara editor.

  cfa get_niagara_simulation_options

Set the Niagara editor's Simulation menu options (auto play, reset on change...)

Sets any of the Niagara editor's Simulation menu options with the same setters the menu calls, each of which saves the per-user Niagara editor config. Only the options you pass change. Returns every option read back plus 'changed', the ones that actually moved. Nothing here touches an asset, so there is nothing to undo.

  cfa set_niagara_simulation_options --auto-play=false
  cfa set_niagara_simulation_options --reset-on-change=true --resimulate-when-paused=true

Play, pause, step, seek or read the timeline of an open Niagara system editor

Drives the timeline of a system open in the Niagara editor. --action play, pause, toggle, step_forward, step_backward, to_start and to_end run through the toolkit's own command list, the path the timeline's buttons and shortcuts take. --action seek needs --time in seconds. --speed and --loop apply before the action, so '--action play --speed 0.25' plays at quarter speed; loop is the Niagara timeline's shared loop setting. --action status changes nothing. Returns status (playing, stopped...), time, speed, the playback range in seconds and loop, read back. CFA attaches to a Niagara timeline when its editor opens; for an editor that was already open before that, seek, speed and the exact status are unavailable (time falls back to the preview's age) until the system is closed and reopened. The system must be open: cfa open_asset --asset-path <system>.

  cfa niagara_preview_playback --system-path /Game/VFX/NS_Fire --action play
  cfa niagara_preview_playback --system-path /Game/VFX/NS_Fire --action seek --time 1.5
  cfa niagara_preview_playback --system-path /Game/VFX/NS_Fire --action play --speed 0.25 --loop=false
  cfa niagara_preview_playback --system-path /Game/VFX/NS_Fire --action status

Measure a running Niagara system's game thread, render thread, GPU and per-script cost

Profiles one running Niagara component over --frames editor frames (default 60) without freezing the editor. The first call attaches the engine's particle perf stats listener and a Niagara GPU profiler listener and returns complete=false; run the same command again until complete=true (a sample left uncollected for 2 minutes is dropped). --source preview (the default) profiles the system editor's preview; level or pie profile a component in the level or the Play In Editor world (--actor-name picks one; 'matches' reports how many ran the system); auto, the default once --actor-name is given, tries PIE, then the level (and the preview first when no actor is named). The result gives gt_us, rt_us and gpu_us (average per frame in microseconds, with *_max_us), frames_active (frames the system actually ticked on each thread) and instances. --per-script (preview only) also turns on the editor's Performance mode for the sample, which recompiles the system with stat scopes, and reports scripts: [{emitter, usage, ms}] for system/emitter spawn and update, particle spawn and update, and GPU stages; the mode is turned back off afterwards if CFA turned it on. verdict compares the cost with the project's global FX budget (fx.Budget.*): over half of it warns, over all of it fails, and a system that never ticked fails. GPU time needs a GPU simulation and fx.NiagaraGpuProfiling.Enabled. --restart discards a sample in progress; a new --frames or --per-script only applies to a new sample.

  cfa profile_niagara_system --system-path /Game/VFX/NS_Fire
  cfa profile_niagara_system --system-path /Game/VFX/NS_Fire --frames 120 --per-script
  cfa profile_niagara_system --system-path /Game/VFX/NS_Fire --source level --actor-name "NS_Fire_2"

Set a Niagara system's or emitter's fixed bounds from the preview or an explicit box

Sets fixed bounds, which keep an effect from being culled while visible and let GPU emitters render inside a real box. --mode from_preview (default) measures the running preview exactly as the editor's Set Fixed Bounds menu does: --target system runs the menu's own Set Fixed Bounds (System) entry, --target emitter measures that emitter's live particles (GPU emitters are read back) without touching the stack selection. The system editor must be open with the effect playing. When the system already has fixed bounds the preview can only report that old box, so the first call turns them off, restarts the preview and returns complete=false; play the effect through and run it again. --mode explicit takes --min and --max as [x,y,z] in local space. --padding grows the box on every side. The asset is saved and the box comes back read back; get_niagara_bounds verifies it.

  cfa set_niagara_fixed_bounds --system-path /Game/VFX/NS_Fire
  cfa set_niagara_fixed_bounds --system-path /Game/VFX/NS_Fire --target emitter --emitter-name Sparks --padding 20
  cfa set_niagara_fixed_bounds --system-path /Game/VFX/NS_Fire --mode explicit --min "[-200,-200,0]" --max "[200,200,600]"

Read a Niagara system's fixed and live bounds, with a verdict

Reports whether the system has fixed bounds and the box, and for each emitter its sim target, bounds mode (dynamic, fixed or programmable) and fixed box. When the system is open in the Niagara editor it adds the live preview's bounds and particle counts. verdict fails when a GPU emitter has dynamic bounds and the system has none fixed (Epic's own GPUSimsMissingFixedBounds check: it would render inside a default box and cull wrongly) and warns on a box with no volume. The verification counterpart of set_niagara_fixed_bounds.

  cfa get_niagara_bounds --system-path /Game/VFX/NS_Fire

Read a Niagara system's Baker settings, outputs and available output classes

Reads the system's Baker settings through reflection as flat path -> value pairs (StartSeconds, DurationSeconds, FramesPerSecond, FramesPerDimension, CameraSettings[n]..., BakeQualityLevel...), with --filter and --max-results and the truncation reported in _summary. 'outputs' lists each baker output with its class and properties, and 'output_classes' the classes add_output accepts. A system that never opened the Baker tab has no settings object; the defaults are shown and exists=false, and nothing is created.

  cfa get_niagara_baker_settings --system-path /Game/VFX/NS_Fire
  cfa get_niagara_baker_settings --system-path /Game/VFX/NS_Fire --filter camera

Edit a Niagara system's Baker settings and outputs

Writes Baker settings through the reflection property writer: --properties maps a dotted path to a value, e.g. {"DurationSeconds": 2, "FramesPerDimension": {"X": 4, "Y": 4}, "Outputs[0].OutputName": "Flipbook"}. --add-output appends an output of a baker output class (get_niagara_baker_settings lists them) and --remove-output removes one by index, as the Baker tab's buttons do; removal applies first. Each written path comes back with its value read back, or its own error. Creates the settings when the system has none, as opening the Baker tab does, and saves the asset. Running the bake itself is not exposed by the engine outside the Baker tab.

  cfa set_niagara_baker_settings --system-path /Game/VFX/NS_Fire --properties '{"DurationSeconds": 2, "FramesPerSecond": 30}'
  cfa set_niagara_baker_settings --system-path /Game/VFX/NS_Fire --add-output NiagaraBakerOutputTexture2D
  cfa set_niagara_baker_settings --system-path /Game/VFX/NS_Fire --remove-output 1

Read a Niagara system's effect type and resolved scalability, per quality level

Reports the system's effect type, allowed_by_scalability, and for the system and each emitter the resolved scalability settings (only values that differ from the defaults) plus each scalability override. resolved and allowed_by_scalability are for the current quality level and device profile. --quality-level (an index or a name such as Low or Epic, from the project's Niagara quality levels) sets the level that enabled_at_level and applies_at_level test each platform set against, so one call shows what a lower level turns off. quality_level lists the level names and the current one.

  cfa get_niagara_scalability --system-path /Game/VFX/NS_Fire
  cfa get_niagara_scalability --system-path /Game/VFX/NS_Fire --quality-level Low

Assign or clear a Niagara system's Effect Type

Sets the system's Effect Type through UNiagaraSystem::SetEffectType, which re-resolves scalability and reinitializes running instances, then notifies the details panel. --effect-type none clears it. Saves the asset and returns the effect type and resolved scalability read back.

  cfa set_niagara_effect_type --system-path /Game/VFX/NS_Fire --effect-type /Game/VFX/ET_Ambient
  cfa set_niagara_effect_type --system-path /Game/VFX/NS_Fire --effect-type none

Preview a Niagara quality level in one system's editor or for every effect

--scope editor (default) switches the open system's Niagara editor into its Scalability mode and sets the preview quality level there, which only that preview uses; --level clear leaves Scalability mode. --scope global overrides the quality level of every Niagara effect in the editor, as fx.Niagara.SetOverrideQualityLevel does, until cleared with --level clear. --level takes an index or a quality level name. Returns the level in effect, read back.

  cfa preview_niagara_quality_level --system-path /Game/VFX/NS_Fire --level Low
  cfa preview_niagara_quality_level --scope global --level 0
  cfa preview_niagara_quality_level --scope global --level clear

Capture an open Niagara system's thumbnail from its preview viewport

Runs the Niagara editor toolbar's Thumbnail button for a system open in the editor, bringing the editor to the front first because the viewport captures on its next draw. That makes it two calls: the first returns captured=false, the next confirms the new thumbnail and saves the asset (--save=false to skip). A request that never drew within 10 seconds is sent again.

  cfa capture_niagara_thumbnail --system-path /Game/VFX/NS_Fire

Remove a simulation stage and its modules from an emitter

Removes a simulation stage and every module in it, the way the stack's delete button does. The system's Niagara editor, if open, is closed for the edit and reopened (reopened_editor). List stages with get_niagara_event_handlers.

  cfa remove_niagara_simulation_stage --system-path /Game/VFX/NS_Fluid --emitter-name Grid --stage Swirl

Remove an event handler and its modules from an emitter

Removes an event handler and every module in it, the way the stack's delete button does; running instances are torn down first. List handlers with get_niagara_event_handlers.

  cfa remove_niagara_event_handler --system-path /Game/VFX/NS_Fire --emitter-name Sparks --handler 0

Add a Set Parameters module (write attributes directly) to a Niagara stage

Adds the stack's Set Parameters module to any stage with the entries you list, each with its namespace (Particles.Scale, Particles.Hue, Emitter.Speed, User.Tint), a type and an optional starting value. The type may be left out for a known attribute (Particles.Position, Particles.Color...), a User parameter, or an attribute the emitter's last compile already has. This is how a new particle attribute is created, e.g. a NiagaraID RibbonID for a ribbon renderer. Change entry values later with set_niagara_stack_value --input-name <entry name>.

  cfa add_niagara_set_parameters_module --system-path /Game/VFX/NS_Fire --emitter-name Sparks --script-usage particle_spawn --parameters '[{"name":"Particles.Hue","type":"float","value":0.3},{"name":"Particles.Color","value":[1,0.2,0.1,1]}]'

Add one entry to a Set Parameters module

Adds one entry to an existing Set Parameters module. A name already in the module is refused (change its value with set_niagara_stack_value, or remove it first to change its type).

  cfa add_niagara_set_parameter_entry --system-path /Game/VFX/NS_Fire --emitter-name Sparks --script-usage particle_spawn --module-name SetVariables_1 --name Particles.Spin --type float --value 2

Remove one entry from a Set Parameters module

Removes one entry from a Set Parameters module. A wrong name lists the module's entries.

  cfa remove_niagara_set_parameter_entry --system-path /Game/VFX/NS_Fire --emitter-name Sparks --script-usage particle_spawn --module-name SetVariables_1 --name Particles.Spin