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, {"x":..,"y":..,"z":..} for vector, {"r":..,"g":..,"b":..,"a":..} for color. 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). Returns the created asset path. Call add_niagara_emitter afterward to populate it.

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.

cfa list_niagara_systems
cfa list_niagara_systems --path /Game/VFX --name-filter "Fire"
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 true to also return each module's input parameters and their current values.

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=false

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.

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. Any module inputs linked to this parameter will be unlinked. Placed instances that override this parameter will lose their overrides. Use get_niagara_user_parameters to confirm the parameter name.

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 attribute slot to a particle attribute. Bindings control which particle data drives rendering features. Common binding_name values: PositionBinding, ColorBinding, SpriteRotationBinding, SpriteSizeBinding, VelocityBinding, DynamicMaterialBinding, NormalizedAgeBinding, etc.

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"

Create a scratch pad module on a system

Creates a new scratch pad module within a Niagara system. Scratch pad modules are system-local scripts that can be used across emitters within that system. They are useful for prototyping custom logic before extracting to a standalone module asset. Specify the script_usage stage and an optional module_name. 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"

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 spawned Niagara effect

Controls a Niagara effect actor in the level. action can be: activate (start playing), deactivate (stop with completion), kill (stop immediately), reset (restart from beginning), or toggle (flip active state). Use get_niagara_actors to find effect actor names.

cfa control_niagara_effect --actor-name "NS_Fire_Instance" --action activate
cfa control_niagara_effect --actor-name "CampfireVFX" --action kill
cfa control_niagara_effect --actor-name "NS_Ambient_0" --action reset

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 path 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

Lists every module-usage Niagara script from the Asset Registry, the same source the editor's Add Module menu uses (engine + project). Filter by category (the module's folder, e.g. spawn, update, forces, beams, ribbons) or search by name/path substring. Returns module asset paths and categories. total_matched reports the count before max_results.

cfa list_niagara_modules --search velocity
cfa list_niagara_modules --category beams
cfa list_niagara_modules --search jitter --max-results 20

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. Filter by category to narrow results.

cfa list_niagara_emitter_templates
cfa list_niagara_emitter_templates --category sprite

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 valid Niagara parameter types for a given scope. scope controls which namespace to list: user (User.* parameters), particle (Particles.* attributes), emitter (Emitter.* variables), system (System.* variables), or engine (Engine.* built-ins). Use filter to narrow results by name.

cfa list_niagara_parameter_types
cfa list_niagara_parameter_types --scope particle --filter "Color"
cfa list_niagara_parameter_types --scope engine

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}), color ({"r":1,"g":0.5,"b":0,"a":1}).

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 compilation errors, warnings, and validation issues for a Niagara system. Use to diagnose why a system isn't working, find outdated modules, or check for configuration problems. Filter by emitter name or severity level.

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 count, execution state (Active/Inactive/Complete), and bounds info. Requires the system to be previewing in the Niagara editor or spawned in the level. Use to verify emitters are spawning particles and to diagnose empty effects.

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. Returns current and available versions per module. 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.

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 three arrays: orphaned (no incoming or outgoing links), dead_ends (inputs connected but no outputs consumed), missing_inputs (no link and no default). 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 Niagara System

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

Duplicate a scratch pad module with a new name

cfa duplicate_niagara_scratch_pad_module --system-path /Game/VFX/NS_Fire --module-name MyDI --new-name MyDICopy

Rename a scratch pad module

cfa rename_niagara_scratch_pad_module --system-path /Game/VFX/NS_Fire --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

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

Rename a script parameter in-place across asset and edit-copy graphs

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).

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) then wires every edge in 'connections'. The schema validates connections and auto-inserts conversion nodes (e.g. float->Vector) like the editor. Targets a standalone script (script_path) OR scratch module (system_path + module_name); reflects live in an open editor. Per-item failures are reported in errors[]; returns node index->guid map. Each node: {node_type|class_path, op_name|function_script|di_class+function_name|input_name+input_type, pos_x, pos_y}. Rich node types for building a whole module/dynamic input in ONE call: node_type=CustomHlsl takes hlsl_code + inputs:[{name,type}] + outputs:[{name,type}] (code + typed pins built together); ParameterMapGet takes get_pins:[{name,type}] (typed output params like Particles.Age, Module.Foo); ParameterMapSet takes set_pins:[{name,type}] (typed input params like Particles.Position). Connections use from_node/to_node (array index of a node built this call) OR from_node_class/to_node_class to reference a pre-existing node by class (e.g. "Input"/"Output" kept by clear_existing), so MapGet->CustomHlsl->MapSet + the Input/Output wiring all build in one call. Any ParameterMapGet/Set whose map Source pin you leave unconnected is auto-wired to the module's Input map (like the editor), a disconnected Source builds a module that fails to compile and can crash the Niagara translator, so this is done for you. Discover node specs with get_niagara_schema_actions.

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

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 (also rewrites {PinName} references in the HLSL body)

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 any UNiagaraNodeWithDynamicPins-derived node

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.

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 or script asset

cfa get_niagara_node_type_info --class-name NiagaraNodeParameterMapGet

Find Niagara script assets by usage + name filter

cfa search_niagara_functions --filter Length --usage function

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.

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')

Finds the override pin, breaks its connections, removes orphan nodes exclusively feeding it, then removes the override pin. Mirrors 'Reset to Default' in the stack UI. 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 editor offers: dynamic_inputs (engine UNiagaraScript assets + scratch-pad DIs with source='scratch_pad' tag) + link_parameters grouped by namespace. Authoritative, the AI should 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.

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