Every tool. Every system.

Search MetaSound node classes, ranked

Full pin schema of a MetaSound node

List MetaSound data types

List MetaSound interfaces

Create a MetaSound Source or Patch

Summarize a MetaSound asset

Read a MetaSound graph

Add a node to a MetaSound graph

Remove a MetaSound node

Wire two MetaSound nodes together

Clear a MetaSound node input

Set a literal on a MetaSound node input

Add an input to a MetaSound's interface

Add an output to a MetaSound's interface

Remove a graph input, output or variable

Set a graph input's default value

Declare a MetaSound graph variable

Add a get or set node for a variable

Add or remove a MetaSound interface

Build a whole MetaSound graph in one call

Re-position a MetaSound graph

Check a MetaSound for faults

List Sound Cue node classes

Create a Sound Cue

Read a Sound Cue's node tree

Add a node to a Sound Cue

Remove a Sound Cue node

Attach a Sound Cue child to a parent

Build a whole Sound Cue tree in one call

Every editable property of one Sound Cue node

Set any properties on a Sound Cue node

Re-position a Sound Cue node tree

Check a Sound Cue for faults

Export an audio asset's full state to JSON

List creatable audio asset classes

Create any audio asset by class name

Identity and hierarchy of an audio asset

Re-parent a Sound Submix

Re-parent a Sound Class

Set an audio effect chain

Rank Mutable node types against keywords (5.8+ only)

Describe Mutable node types, pins and properties (5.8+ only)

List the Mutable node palette categories (5.8+ only)

Create a new Customizable Object asset (5.8+ only)

Create a Customizable Object Instance (5.8+ only)

Read a Customizable Object's source graph (5.8+ only)

Read Mutable nodes by GUID (5.8+ only)

Add a node to a Customizable Object graph (5.8+ only)

Link two pins in a Customizable Object graph (5.8+ only)

Break links on a Customizable Object pin (5.8+ only)

Delete a node from a Customizable Object graph (5.8+ only)

Write node properties in a Customizable Object graph (5.8+ only)

Attach child Customizable Objects to a parent's Object Group (5.8+ only)

List the child Customizable Objects attached to a parent (5.8+ only)

Add a pin to a Mutable node that has an add-pin button (5.8+ only)

Build a whole Customizable Object graph in one call (5.8+ only)

Auto-arrange a Customizable Object graph (5.8+ only)

Compile a Customizable Object (5.8+ only)

Validate a Customizable Object and return a verdict (5.8+ only)

List a Customizable Object's parameters (5.8+ only)

Read parameter values off an instance (5.8+ only)

Write parameter values on an instance (5.8+ only)

Regenerate a Customizable Object Instance (5.8+ only)

Full JSON export of a Customizable Object (5.8+ only)

List a Customizable Object's states (5.8+ only)

Set the current state of an instance (5.8+ only)

Reset an instance's parameters to their defaults (5.8+ only)

Copy an instance's whole parameter state (5.8+ only)

Apply a copied parameter state to instances (5.8+ only)

Write Parameter UI Metadata on parameter nodes (5.8+ only)

Create a Customizable Object Macro Library (5.8+ only)

List a Macro Library's macros (5.8+ only)

Add macros to a Macro Library (5.8+ only)

Remove macros from a Macro Library (5.8+ only)

Declare a macro's inputs and outputs (5.8+ only)

Place a Macro Instance node in a graph (5.8+ only)

Create a new empty Control Rig Blueprint

Create a Control Rig and import a skeleton (any skeleton)

Import a skeleton's bones into an existing rig

Add a bone to the rig hierarchy

Add a null (space) to the rig hierarchy

Add an animation control of any type

Add a named curve element

Add a socket under a parent bone/null

Declare a connector on a Control Rig MODULE asset

Change an existing connector's type, flags or description

Add a connection rule restricting what a connector may bind to

List the connection rule types this engine ships

Create a Control Rig MODULE asset

Read a Control Rig's module identity and metadata

Write a module's identity and library metadata

Add an asset-level member variable to a Control Rig

Add MANY member variables to a Control Rig with a single compile

List a Control Rig's member variables and their config flags

Remove an asset-level member variable from a Control Rig

Add an animation channel under a control

Reparent an element

Update a control's settings (reflection)

Set a control's initial or current value

Move a control like dragging its gizmo (select + SetControlGlobalTransform + evaluate), report bones moved

Select/deselect rig elements through the engine controller

Set a control's offset transform

Set an element's transform

Remove an element from the rig hierarchy

Rename an element

Atomically build a whole hierarchy

Read the rig hierarchy as a tree

Read one element

List valid control + element types

Search RigVM graph node types

List registered RigVM template notations

Describe one or many RigVM node types' pins

Read a RigVM graph's nodes

Describe one RigVM node in a graph

Add a node to a RigVM graph

Connect an output pin to an input pin

Break a link, or all links on a pin

Set a node pin's default value

Set a RigVM node's position

Remove a node from a RigVM graph

Atomically build a RigVM graph

Auto-arrange a RigVM graph

Batch-set many node pin defaults in one call

List available gizmo shape names

Set a control's shape / color / visibility / gizmo transform

Gizmo gate, fails the rig when controls are unfitted, buried, or wrongly shaped

Size/orient control gizmos from the mesh's real skinned cross-section (no guessed scales)

Set a RigVM node's tint color

Set a RigVM node's size (comment/collapse boxes)

Set a comment node's text/font/bubble

Rename a RigVM node

Expand/collapse a struct/array pin

Toggle a pin's debug watch

Lock a wildcard/template pin to a concrete type

Set an array pin's element count

Add, insert, remove, duplicate or clear array pin elements

Remove an extra pin from an aggregate node

Put a pin back to its node's own default value

Add exec output pin(s) to a Sequence node so the graph can fan out

Bind a pin directly to a variable

Remove a pin's variable binding

Define a new function in the function library

Remove a library function

Rename a library function

Add a top-level graph to the rig

Remove a top-level graph and its nodes

Rename a top-level graph

Change the type or the position of an exposed pin

Set a function's category, keywords and description

Rename, retype or re-default a function's local variable

Set a function public/private and/or pure/mutable

List library functions with their I/O

Place a call to a library function

Add an input/output pin to a function/collapse graph

Remove an input/output pin from a function/collapse graph

Rename an input/output pin on a function/collapse graph

Collapse nodes into a sub-graph

Expand a collapse/function node back inline

Promote collapse<->function

Add a graph-scoped local variable

Remove a graph-scoped local variable

List a graph's local variables

Reset a template node's pins to wildcard

Add a solve event node by friendly name

List every graph in the rig

Sample the live preview rig per frame

Per-bone jitter/motion statistics

THE physics alive-gate: shake a control, freeze it, measure residual jiggle

Per-bone residual jiggle after the driver stopped

Set an existing rig's preview skeletal mesh

Add a Rig Module to a Modular Rig

Bind a module connector to an element

Auto-resolve module connectors

List engine-valid targets for a module connector

List a Modular Rig's modules

Delete a module from a Modular Rig

Query the Rig Module asset library

Read a module instance's config

Set or reset a module config value

Bind a module variable to another module's variable

Rename a module instance

Reparent a module instance

Reorder a module among its siblings (5.7+)

Mirror a module (e.g. left arm to right arm)

Swap a module's source asset

List rig sockets with placement hints and claimed state

List hierarchy components (physics solvers/bodies/joints)

Numeric live pose: current vs rest per bone, worst deviation first

Detect melted / twisted / inside-out skinning on the preview mesh

Physics invariant checks: unjointed bodies, free joints, conflicts, drift

Inspect a module asset's internal graphs (any module, incl. custom)

Toggle per-command disk saves for rig commands (default off)

Size a ChainPhysics module's collision from the real skinned mesh

Generate a kinematic body-collider rig module asset

Mesh-vs-mesh clip depth: cloth/hair vertices inside body volume

Real per-bone geometry from skinned vertices + physics asset

Place a pole control out in the bend plane, and verify it moved

Purge persisted components from the blueprint hierarchy

Full field dump of live hierarchy components via reflection

List animation channels with hosts and live values

Write animation channel values on the running instance

Play an animation on the rig's asset-editor preview

Stop the preview animation and restore forwards-only solve

One-shot soft-tissue jiggle setup (tip bone + rebind + tune)

Flag dead controls and undriven bones from live VM truth

Graph red-squiggle report: bad refs, missing channels, dead exec, runtime log

Ground-truth rig I/O: events, AnimBP pins, control reads, measured bone writes, safety verdict

Headless rig performance report: solve ms, hot nodes, physics census, red flags

Which controls actually MOVE bones, empirical connectivity map

Headless N-frame simulation: anim input, limb crossing, ground clipping, deviation, NaN checks

Disconnect every connector that is part of a cycle

Turn a rig into a module, or a module back into a standalone rig

Select modules of a Modular Rig

Copy a function of another rig into this rig

Make call nodes call another function

Replace outdated nodes with the current ones

Make a variable from a pin

Set the name a pin shows

Mark pin values as overrides, or clear the override

List the trait types, and which of them a node takes

Add a trait to a node

Remove a trait from a node

Make a variant of a function, tag it, split it or join it

List the component types, and which of them an element takes

Add a component to a rig element

Change the content, the name or the element of a component

Switch the space of a control on the rig the open editor previews

Copy elements from another rig

Copy one module's settings onto other modules

Clear a module connector's binding

Give a null or a control one more parent

Remove one parent of an element, or all of them

Set how much an element follows one of its parents

Add, remove or move a space in a control's space list

Copy hierarchy elements

Make a mirrored copy of hierarchy elements

Move an element to a new place among its siblings

Write one metadata entry of a hierarchy element

Remove metadata of a hierarchy element

Create a new rig from an export_control_rig file

Export a complete Control Rig to JSON

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

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

List standalone Niagara data/utility asset types creatable via create_niagara_asset

Create a standalone Niagara data/utility asset

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

Create a new Niagara particle system

Get full info about a Niagara system

List Niagara system assets

Delete a Niagara system asset

Compile a Niagara system

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

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

List emitters in a Niagara system

Create a standalone Niagara emitter asset

Add an emitter to a Niagara system

Remove an emitter from a Niagara system

Set a property on an emitter

Duplicate an emitter within a system

Move an emitter to a new position

List modules in an emitter's stack

Add a module to an emitter's stack

Remove a module from an emitter's stack

Enable or disable a module

Move a module to a new position in stack

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

Set an input value on a module

Set a dynamic input on a module

Set a curve on a module input

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

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

Get user-exposed parameters

Add a user parameter to a system

Set a user parameter value

Remove a user parameter from a system

Link a module input to a parameter

Add a renderer to an emitter

Remove a renderer from an emitter

Get renderer properties and bindings

Set a property on a renderer

Bind a renderer slot to a particle attribute

Auto-layout a Niagara script graph

Create a scratch pad module on a system or an emitter

Set HLSL code on a scratch pad module

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

Add an event handler to an emitter

Add a simulation stage to an emitter

List event handlers on an emitter

Spawn a Niagara effect in the level

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

Add a Niagara component to an actor

List Niagara effect actors in the level

List available Niagara modules

List available emitter templates

List Niagara data interface types

List Niagara parameter types by scope

Get attributes available on an emitter

List editable properties on a renderer with current values

Set a system-level property via reflection

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

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

Get compilation errors and warnings for a Niagara system

Get live particle counts and emitter execution state

Set the timeline playback range in the Niagara editor

Get the current playback range and frame rate settings

Check for outdated modules in an emitter

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

Introspect every node inside a Niagara graph

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

BFS trace of connections upstream or downstream from a node

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

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

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

List all scratch pad modules on a Niagara System

Delete a scratch pad module from a system or emitter

Duplicate a scratch pad module with a new name

Rename a scratch pad module

Read the details-panel properties of a Niagara script

Batch-set details-panel properties on a Niagara script

List input + output parameters of a Niagara script

Add an input or output parameter to a Niagara script

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

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

Create a new node inside a Niagara graph

Delete a node from a Niagara graph

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

Add an input pin to a Custom HLSL node

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

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

Remove a pin from a Custom HLSL node

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

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

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

Rename a pin on a dynamic-pin node

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

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

Break a pin connection in a scratch pad graph

Enumerate Niagara node classes available for spawning

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

Find Niagara function, dynamic input or module scripts by words

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

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

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

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

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

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

Reproduce the stack-UI source dropdown for a specific input

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

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

Enumerate member functions on a Niagara data interface class

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Edit a Niagara system's Baker settings and outputs

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

Assign or clear a Niagara system's Effect Type

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

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

Remove a simulation stage and its modules from an emitter

Remove an event handler and its modules from an emitter

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

Add one entry to a Set Parameters module

Remove one entry from a Set Parameters module

Create a new empty PCG Graph asset

Create a PCG Graph Instance bound to a parent graph

Create a new PCG Builder Settings asset

Create a new PCG Compute Source asset

Read the HLSL source and AdditionalSources of a PCG Compute Source asset

Write the HLSL source text on a PCG Compute Source asset

Append a UComputeSource to a PCG Compute Source's AdditionalSources

Remove an entry from a PCG Compute Source's AdditionalSources

List all UPCGComputeSource assets via Asset Registry

List EPCGKernelType enum values for the Custom HLSL node

List PCG Graph assets marked as templates

Create a new PCG Graph by duplicating a template

Search PCG node types (UPCGSettings subclasses) by name or category

List EPCGSettingsType category values for search_pcg_nodes

List PCG nodes with advanced or preconfigured-only behavior

List preconfigured variants for a PCG settings class

Get full schema for a PCG node type

Get valid values for a PCG settings property (enums, attribute pickers, extractors)

Read a PCG graph at a chosen verbosity

Get full info on one PCG node

Get pin-by-pin connections for one node

Trace reachable nodes from a starting node

Enumerate UserParameters on a PCG graph

List editable UPROPERTYs on the UPCGGraph asset

Set a graph-level UPROPERTY on the UPCGGraph (HiGen, landscape, cosmetic)

Add a node to a PCG graph

Delete a node from a PCG graph

Connect two PCG pins (add edge)

Atomically build a PCG graph (nodes + edges + auto-layout) in one call

Remove all edges from one pin

Remove a specific edge

Set a property on a node's UPCGSettings

Move a node

Set a node's comment string

Add a dynamic input pin

Remove a dynamic input pin

Add a graph-level user parameter

Remove a graph parameter

Rename a graph parameter

Set a graph parameter's default value

Change a graph parameter's type

Re-target a subgraph node

List subgraph parameter overrides

Override a subgraph parameter

Clear a subgraph parameter override, putting the target graph default back

Validate a PCG graph

Read cached graph validation findings

Auto-layout the graph

Attach a comment to the graph

Generate() all components bound to a graph

CancelGeneration() on all components

Toggle UPCGComponent::bActivated for a graph

Set a nested PCG node property via a property path

Read a nested PCG node property value

Discover nested property paths on a PCG node

Append or insert an element into a PCG node TArray property

Remove an element from a PCG node TArray property

Replace an instanced FObjectProperty with a NewObject of a specified class

Switch a Custom HLSL node's kernel type (mirrors the engine's SetKernelType)

Set a Static Mesh Spawner's weighted mesh list in one call

Call UPCGComponent::Generate on the named actor

Call UPCGComponent::Cleanup on the named actor

Call UPCGComponent::GenerateLocal(Trigger, bForce, Grid)

Call UPCGComponent::CleanupLocal(bRemoveComponents)

Call UPCGComponent::CleanupLocalImmediate, synchronous, no delayed tasks

Call UPCGComponent::CancelGeneration on the named actor

Call UPCGComponent::SetGraph to assign a PCG graph to a component

Read the last generated FPCGDataCollection from a component

Call UPCGComponent::ClearPCGLink, detach generated content into a standalone actor

Check whether a UPCGComponent is partitioned

List APCGPartitionActors in the world, optionally filtered by an original PCG component

Get detailed info on one APCGPartitionActor by name

Aggregate generated output across all partition actors of a partitioned PCG component

Not available: always refuses; use pcg_set_component_graph then pcg_schedule_component

Schedule a PCG component's own graph for async execution

Schedule cleanup of a PCG component's graph

Refresh a PCG component on the current or next frame (editor only)

Generate every registered PCG component in the world (editor only)

Cleanup every registered PCG component in the world (editor only)

Refresh all GenerateAtRuntime PCG execution sources

Mark all runtime-gen PCG execution sources as dirty (5.8+ only)

Refresh PCG components matching a filter predicate (editor only)

Flush PCG results cache and compiled-graph cache

Clean up and re-generate all runtime-gen PCG components including partition actors

Refresh a single GenerateAtRuntime PCG component (optionally flushing cache first)

Build the PCG landscape cache for the current world

Clear the PCG landscape cache for the current world

Check whether per-node inspection is enabled on a UPCGComponent

Enable per-node inspection on a UPCGComponent

Disable per-node inspection on a UPCGComponent

Check whether a node's task executed during the last generation

Check whether a node produced data in the last execution

Get the bitmask of output pins deactivated by dynamic branching

Check whether a node triggered a GPU->CPU readback during last execution

Check whether a node triggered a CPU->GPU upload during last execution

Check whether data overrides were applied to a node during last execution

Inspect a node's output data collection (compact, AI-friendly summary)

Inspect a node's output across ALL partition cells of a partitioned PCG component

List all nodes executed during last generation (compact)

Clear cached inspection data on a UPCGComponent

Search the Procedural Vegetation add-node menu (UE 5.8 only)

List Procedural Vegetation node categories with node counts (UE 5.8 only)

Get full schema for one or more Procedural Vegetation nodes (UE 5.8 only)

Write the full Procedural Vegetation node schema to a JSON file (UE 5.8 only)

Create a Procedural Vegetation asset (UE 5.8 only)

Export a Procedural Vegetation asset to mesh assets (UE 5.8 only)

Preview a node's output in the open editor viewport (UE 5.8 only)

Dump a PCG/vegetation graph's AUTHORED configuration to a file (UE 5.8 only)

List Procedural Vegetation assets available as creation samples (UE 5.8 only)

Create a new Material

Create a Material Instance

Build complete node graph in one atomic call

Inspect material properties, parameters, textures

Bulk-set material properties

Force recompile and save

Apply edits to the asset (clicks the editor's Apply button)

Get material compilation errors

Report the engine's own shader cost counters for a material

Add comment boxes to material graph

Read graph nodes with verbosity control

Inspect one material expression node with its available pins

Show which material outputs (BaseColor, etc.) are connected

Add a material expression node

Connect two material expression nodes

Delete a material expression by index

Set a property on a material expression

Move a material expression node

Duplicate a material expression

Auto-layout the material graph (data-flow, right-to-left)

Auto-layout all material expressions (alias of layout_material_graph)

Auto-layout a Material Function graph (data-flow, right-to-left)

Get all parameters of a material instance

Set a parameter on a material instance

Reparent a material instance

Clear a parameter override (revert to parent)

List available material expression types

Look up pins & properties for a node type

Query available material output pins

Disconnect a specific input pin

Find Material Functions by name

Diagnose orphaned, dead-end, and unconnected nodes

Trace upstream/downstream from a node

Delete orphaned/dead-end nodes

Create a new Material Function asset

Create a Material Function Instance

Override a parameter on a Material Function Instance

Read overrides on a Material Function Instance

Set the material attribute layer stack (base or instance)

Read the material attribute layer stack

Inspect a Material Function

Build complete MF node graph in one call

Add a FunctionInput pin

Add a FunctionOutput pin

Modify an existing FunctionInput

Modify an existing FunctionOutput

Validate a Material Function

Cleanup orphaned nodes in a Material Function

Create a Material Parameter Collection

Add or update an MPC scalar/vector entry

List all entries of a Material Parameter Collection

Remove an entry from a Material Parameter Collection

List gameplay tags with source, comment and children

Read one tag's comment, sources, parent and children

Add a gameplay tag to an ini source

Remove a gameplay tag from its ini source

Rename a tag, leaving a redirector behind

Create a new tag source ini

List tag sources and which are writable

Check the tag library and return a verdict

List AttributeSet classes, including unopened Blueprints

List an AttributeSet's attributes with defaults

Create a Blueprint AttributeSet, optionally with attributes

Add an attribute to a Blueprint AttributeSet

Check an AttributeSet and return a verdict

Create a GameplayEffect Blueprint

List the effect component classes this engine has

Attach a gameplay effect component

Remove a gameplay effect component by class

Add or edit a modifier on a gameplay effect

Run the engine's own validation over an effect

Create a GameplayAbility Blueprint

Create a cue notify Blueprint bound to its cue tag

List cue notify assets and the tag each answers to

Cross-check cue tags against notifies, both directions

Ranked bulk search across tags, attributes, effects and abilities

Inspect an actor's AbilitySystemComponent

Paint every landscape layer in one normalised pass

Spawn a volume with real brush geometry at a given size

Verify a volume has brush geometry and actually does something

Create a landscape at a chosen resolution

Sculpt landscape heights with a shape

Paint a landscape weight layer

Read a landscape's resolution, scale, height range and layers

Remove all landscape splines

Deform the landscape along a spline

Edit one region of an existing landscape

Carve a river into an existing landscape

Generate a complete eroded terrain into a landscape

Verify a landscape is usable

Start a Lightmass lighting build

Poll a lighting build

Recapture sky lights

Flush or fully rebake reflection captures

Verify lighting is built

Start a navigation mesh build (asynchronous)

Poll an in-flight navigation build

Verify navigation is built and actually pathable

Set or append a spline's points

Edit one spline point: location, tangents, rotation, scale, type

Read a spline's points, length and sampled transforms

Verify a spline is usable

Add a component to a placed actor in the level

Create a foliage type asset from a static mesh

Place foliage in a reproducible pattern (the brush, without the brush)

Remove placed foliage instances, keeping the types

Remove a foliage type from the level entirely

List foliage types in the level with instance counts

Verify placed foliage is actually going to render

List the editor modes this build registers, and which is active

Switch the level editor to a mode by id

Run one geomorphic process over an existing landscape

Regenerate one region of a landscape and merge it seamlessly

Report a World Partition level's grids, data layers and loaded actor counts

List every actor in a partitioned level without loading it

Load a region of a partitioned level so its actors can be edited

Release a region loaded by load_world_partition_region

Keep matched actors loaded regardless of camera position

Set whether an actor streams with the grid or is always loaded

Create a data layer asset and an instance of it in this world

List data layers with type, parent, state and actor counts

Add or remove matched actors to a data layer

Set a data layer's editor visibility, editor loading and initial runtime state

Remove a data layer instance from this world

Create an HLOD layer asset

List HLOD layer assets with type, cell size, loading range and parent

Assign an HLOD layer to matched actors, or clear the override

Run a World Partition builder (hlod, minimap, navigation, foliage...)

Set any editable UWorldPartition property by reflection

Add, edit or remove a named runtime grid

Put matched actors onto a named runtime grid

Check a partitioned world is actually partitioned

Search Behavior Tree node classes, ranked

Read a node class: its properties and what each accepts

List available blackboard key types

Create a Behavior Tree with its graph and Root node

Create a Blackboard

Attach a Blackboard to a Behavior Tree, or set what it inherits from

Create a Blueprint task, service or decorator

Read a Behavior Tree as a tree

Read a Blackboard's keys

Check a Behavior Tree and return a verdict

Add composites and tasks to a Behavior Tree

Attach decorators and services to a node

Re-parent a node or change its sibling order

Remove a node, a subtree, or a sub-node

Set properties on a node, decorator or service

Rebuild the runtime node chain from the graph

Auto-arrange the graph layout

Combine decorators with AND, OR or NOT

Inspect Behavior Trees running in play

Start, stop, restart, pause or resume running logic

Swap the subtree behind a Run Behavior Dynamic task

Add keys to a Blackboard

Remove a key from a Blackboard

Rename, retype or edit a Blackboard key

Search EQS generators, tests and contexts, ranked

Read an EQS generator, test or context class

Create an Environment Query

Read a query's options and tests

Add a generator option to a query

Remove an option from a query

Add a test to an option

Remove a test from an option

Set a property on a generator or a test

Check a query and return a verdict

Run a query in the editor and return the engine's debug view

During play, the EQS queries each actor last ran

Get StateTree overview (schema, counts)

Export a StateTree to a complete self-contained JSON file

Get state hierarchy tree

Get detailed info for a single state

Get global evaluators with properties

Get global tasks with properties

Get tree-level parameters

Get detailed info for a single node by GUID

Get property bindings with full path details

Get complete StateTree data in one call

Search for nodes by class name or category

Create a new StateTree asset

Add a state to the tree

Add a task to a state

Add a global evaluator

Add a global task

Add a condition to state enter or transition

Add a utility consideration to a state

Add a transition to a state

Add a tree-level parameter

Set the value of an existing tree-level parameter

Set a property on a state

Set a property on a task/evaluator/condition

Set a property on a transition

Change the schema of a StateTree

Assign a StateTree asset to a StateTree component (placed actor or Blueprint)

Add a property binding between nodes / tree parameters

Bind a delegate dispatcher to a listener

Bind a listener to a task's completion (UE 5.8+)

Add or update a theme color

Remove a state and its children

Remove a task/evaluator/condition by GUID

Remove a transition from a state

Remove a property binding

Remove a tree-level parameter

Compile a StateTree and return errors

List available task/evaluator/condition types

List valid binding sources for a node (context/params/functions)

Deep type-aware property search across a node's binding sources

List available StateTree schema classes

List valid transition targets for a StateTree

List valid enum values for StateTree properties

Create a new Level Sequence asset

Open a Level Sequence in the Sequencer editor

Read timeline settings + binding/track counts

Set the playback range (frames or seconds)

Set the display rate / FPS

Set the tick resolution (migrating)

Bind an existing level actor as a possessable

Add a spawnable binding from a class

Add a spawnable binding from a level actor template

List bindings (possessables + spawnables), filterable by type/name

Rename a binding by GUID

Remove a binding by GUID

Convert a possessable binding to spawnable

Convert a spawnable binding to possessable

List available track classes (reflection)

List tracks on a binding (or root tracks)

Add an object-bound track to a binding

Add a root/master track (camera cut, audio...)

Remove a track by index

Add a section to a track

List sections on a track (display-rate frames; reports ease_in/ease_out and blend_type when set)

Set a section's range (frames or seconds)

Remove a section by index

Set a property on a track (universal writer)

Set a property on a section (universal writer)

List a section's animatable channels

Add a keyframe to a channel

List keys on a channel (compact: time + value, one shared interp)

Remove a key from a channel by index or by frame

Set or clear a channel's default value

DEPRECATED: use add_keys. Key location/rotation/scale on a transform section in one call

Spawn a cine camera and bind it in the sequence

Add a camera cut to the camera (auto-creates the cut track)

Render a Level Sequence to disk via Movie Render Queue (async)

Report Movie Render Queue progress + written files

Set an existing key's value (float/double channel)

Move an existing key in time

Set a key's interpolation + tangent mode

Set a key's tangents (arrive/leave + weights)

Set channel pre/post-infinity extrapolation (looping)

Read a channel's keys into a portable payload

Write a copy_keys payload onto a channel at an offset

Shift every key on a channel (or section) by a delta

Move keys explicitly, or scale a range about a pivot

Key reduction / curve optimise within a tolerance

Blend selected keys with one of the editor's blend tools

Key every channel of a binding at one frame (current value)

Sample a channel per frame over a range and write keys

Mute or unmute a track or one of its rows (headless)

Solo or unsolo a track or one of its rows (headless)

Disable or enable evaluation of a track or row (saved; not mute)

Mute/solo/eval-disabled/colour/sort/lock state per binding, track, row and section

Set a section's active, locked, row, colour, pre-roll and post-roll

Set a track's colour tint

Rename a track or one of its rows

Set a track's sort order among its siblings

Set a binding's sort order among its siblings

Create a folder nested under another folder

Rename a sequence folder

Set a sequence folder's colour

Unlink a binding or root track from a folder

Remove a folder (its contents return to the root)

Set the Sequencer selection (window-gated)

Read the Sequencer selection (window-gated)

Drive the open Sequencer: play, pause, play_to, speed, loop, lock (window-gated)

Current/focused sequence, playing, speed, loop, lock and camera-cut lock of the open Sequencer

Add a sub-sequence on a given row of the existing shot track

Set a sub-section's bias, time scale, loop, offsets, sequence or shot name

Rename a cinematic shot section

Sub-sequence/shot sections with ranges, bias, time scale and loop settings

Camera cuts with binding, range, ease, lock-previous, plus track blend settings and gaps

Retarget, retime, ease or lock-previous one camera cut

Camera cut track settings: can_blend, auto-manage sections, rearrange

Remove one camera cut

Edit the spawnable's template actor (any property, any component)

Spawn ownership, continuous respawn and net-addressable name of a spawnable

Convert a binding to a custom binding class (headless)

Custom binding class and properties per binding

Every binding tag and the bindings it marks

Unregister a binding tag sequence-wide

Find (and optionally prune) possessable references that no longer resolve

Report the sequence's director Blueprint and its functions

Put a condition on a section, track or track row (native on 5.6/5.7/5.8)

Read the condition on a section, track or track row

Remove the condition from a section, track or track row

Key an event bound to a director-Blueprint endpoint, with payload values

Copy sections into a portable payload (also lands on the OS clipboard)

Paste a copy_sections payload onto a track at a frame

Copy tracks into a portable payload (also lands on the OS clipboard)

Paste a copy_tracks payload into a sequence (bound tracks need a target binding)

Create a director-Blueprint resolver function for a binding (dynamic binding)

Point a binding's dynamic binding at an existing director-Blueprint function

Put a director-Blueprint condition on a section, track or row and create its function

Export a Level Sequence to FBX (headless)

Import an FBX onto a Level Sequence's bindings (headless, no dialog)

Bake a binding's animation to an AnimSequence asset

Bake to an AnimSequence after a delay (5.7+), letting spawnables settle first

Link an existing AnimSequence to a binding

Linked AnimSequences of a sequence, or the sequence an AnimSequence links to

Drop every AnimSequence link from a sequence

Import an FBX onto a binding's Control Rig track channels

Export a binding's Control Rig track channels to FBX

Jobs in the Movie Render Queue with config mode, presets and shots

Add a render job for a Level Sequence to the Movie Render Queue

Remove a job from the Movie Render Queue

Duplicate a job in the Movie Render Queue

Assign a preset, a graph preset, a config mode or setting values to a job

Enable/disable a shot or give it an override config or graph preset

Save the Movie Render Queue as an asset and/or a manifest file

Replace the Movie Render Queue from a queue asset or a manifest file

Cancel the active render (editor queue and CLI-started renders)

Primary, shot and graph render config assets in the project

Start a headless Take Recorder take (the Sequencer window is not opened)

Stop the active take and report the recorded sequence

Cancel the active take

Take Recorder plugin/enabled/recording state and the pending sources

Add actor (or other) sources to the pending take

Pending take sources

Recorded takes for a slate

Set section ease-in/out (fade) length

Set section blend type (additive layering)

Add a sound on a master audio track

Add a sub-sequence (shot) on a cinematic shot track

Add an event track section (repeater/trigger)

Add a time-warp track with a fixed play rate

Add a timeline marker

List timeline markers

Remove a timeline marker by index

Add a root folder (organization)

List root folders

Add a binding or root track to a folder

Set evaluation type (framelocked/withsubframes)

Add a tag to a binding

Remove a tag from a binding

Deep report for one binding: tracks, sections, channels (filterable), optional keys

Evaluate channel value(s) at a frame/time (e.g. Location.X at frame 500)

Move the Sequencer timeline bar to a frame/time (sequence must be open)

Read the Sequencer playhead position (sequence must be open)

Play or pause the open Sequencer

List keyable properties of a binding's object/component (discover what you can animate)

Possess an actor's component as a child binding (needed to animate LightColor/Intensity)

Add a property track bound to a property (auto-picks track class); enables color/intensity/etc.

Batch-add keys to multiple channels of a section in ONE call

Verdict for a whole sequence: broken bindings, dead sections, missing assets, compile state

Scrub a headless player to a frame and read back what the bindings actually evaluate to

Add an animation to a skeletal-mesh binding; loops to fill the section by default

Control Rig tracks on a sequence, with their rig class and priority

The channel map: every control's channel indices, kinds, labels and mask state

Add a Control Rig track + section to a binding, headless

Key one control at one frame

Batch: N controls x M frames on a rig section in ONE call and one undo step

Read a rig section's keys back per control and channel

Delete a control's keys, all of them or inside a frame range

Set a control's channel defaults - the value it holds with no keys

Show or hide controls on a rig section

Set an FK Control Rig track's apply mode

Set a Control Rig track's evaluation priority order

Repoint a track's channels at renamed rig controls

Add an anim layer for some controls of a rig track

Delete one anim layer and its sections

Copy one anim layer with its keys

Merge two or more anim layers into the lowest one

Change an anim layer: name, weight, type, mute, lock, key target, controls

Move an anim layer to another index (UE 5.8+)

Read controls in WORLD space at given frames

Key a control at a WORLD transform on given frames

Move one space key of a control to another frame

Move one activation key of a timeline constraint to another frame

Add the transform keys that stop a control jumping at a space key

Add the transform keys that stop a constrained control jumping at an activation key

Bake a timeline constraint into plain keys on the child

Read the sequence's Control Rig anim layers (index, name, weight, type, controls)

Select controls of a rig track

Read which controls of a rig track are selected

Mirror the pose of some controls to or from the other side

Put controls back to their default values

Key controls between their key before and their key after

Change the rig of a Control Rig track and keep its keys

Save the pose of a Sequencer rig as a pose asset

Paste a pose asset onto a Sequencer rig

Read the controls a pose asset holds

Rename one control inside a pose asset

Read the rig settings of a Control Rig track: the public variables of its rig

Set public variables of a track's rig and build the rig again with them

Read the rotation order each control uses on a Control Rig track

Convert the rotation keys of a track to the rotation order the rig has now

List the selection sets of a Level Sequence (UE 5.7+)

Make a selection set from controls of a rig track, or mirror a set (UE 5.7+)

Rename a selection set, change its colour or row, add or remove controls (UE 5.7+)

Remove one selection set, or all of them (UE 5.7+)

Use a selection set: select, deselect, show, hide, isolate, show all or key its controls (UE 5.7+)

Verdict for the rig tracks: rig class resolvable, every control has channels, mask consistent

Key a space switch on a rig control (world, default parent, another control, or a bone)

Space keys per control: keyed frames, the unique space list, and the resulting intervals

Delete one space key from a control's space channel

Constrain a rig control or actor to another, with an activation channel on the rig section

Constraints on a rig section: name, type, child, parent, and their activation keys

Key a timeline constraint on or off at a frame

Delete one constraint activation key

Bake an AnimSequence onto a Control Rig section, headless

Bake a skeletal binding's animation onto a new Control Rig track (needs an open Sequencer)

Export a binding's animation back out to an AnimSequence (needs an open Sequencer)

Key reduction tuned for rig channels (needs an open Sequencer)

Snap controls onto an actor or another control over a frame range (needs an open Sequencer)

Flatten every section and layer on a rig track into one (needs an open Sequencer)

Bake space switches into plain keys over a range (needs an open Sequencer)

Toggle a rig track between layered/additive and absolute (needs an open Sequencer)

Rebuild a rig track's instance against the blueprint's current compiled class, keeping the keys

Layers of an Animation Mixer track (UE 5.8+, MovieSceneAnimMixer plugin)

Append or insert a layer on an Animation Mixer track (UE 5.8+)

Rename a mixer layer (UE 5.8+)

Put an animation sequence on a mixer layer (UE 5.8+); overlapping sections on one layer auto-create a crossfade transition

Put a child track (e.g. MovieSceneControlRigParameterTrack) on an empty mixer layer (UE 5.8+)

Transitions on an Animation Mixer track (UE 5.8+)

Change a transition's class, e.g. MovieSceneAnimInertialDeadBlendTransitionSection (UE 5.8+)

Decorations on a track, section or mixer layer plus the compatible classes (UE 5.8+)

Add a decoration (weight, mask, mirroring, root motion target...) to a track, section or mixer layer (UE 5.8+)

Remove a decoration from a track, section or mixer layer (UE 5.8+)

Set a mixer layer's weight as a default or a key (UE 5.8+); creates the Layer Weight decoration and its section on demand

Verdict on an Animation Mixer track: layers, section/child-track exclusivity, transitions (UE 5.8+)

List all actors in the current level

Find actors by name pattern

Spawn an actor in the level

Search available UClasses by name, optionally filtered by a base class

Delete an actor from the level

Set actor location/rotation/scale

Spawn a Blueprint actor instance

Spawn an actor from a class name

Get currently selected viewport actors

Get current level info (world name, actor count)

Capture the level viewport or a named editor window to PNG