Control Rig

Create a new empty Control Rig Blueprint

Creates a UControlRigBlueprint at the given path via UControlRigBlueprintFactory. Works for any skeleton; import bones separately or use create_control_rig_from_skeleton.

cfa create_control_rig --asset-path /Game/Rigs/CR_Spider

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

Creates a Control Rig then imports the whole bone hierarchy (and optionally curves) in one call. Human, quadruped, snake, vehicle, any skeleton works. REQUIRES a USkeletalMesh: a USkeleton asset is REJECTED with a clear error, because a Skeleton has no geometry and the rig would have no visible preview. To import bones from a Skeleton into an EXISTING rig, use import_rig_skeleton instead.

cfa create_control_rig_from_skeleton --asset-path /Game/Rigs/CR_Wolf --skeleton-path /Game/Wolf/SKM_Wolf

Import a skeleton's bones into an existing rig

cfa import_rig_skeleton --asset-path /Game/Rigs/CR_Wolf --skeleton-path /Game/Wolf/SK_Wolf

Add a bone to the rig hierarchy

cfa add_rig_bone --asset-path /Game/Rigs/CR_X --name spine_01 --parent root

Add a null (space) to the rig hierarchy

cfa add_rig_null --asset-path /Game/Rigs/CR_X --name hand_ik_null

Add an animation control of any type

Adds a control (transform/float/bool/vector2d/position/scale/rotator/eulertransform/...). Shape/color/limits and any further FRigControlSettings fields come from cosmetic params or the settings JSON object.

cfa add_rig_control --asset-path /Game/Rigs/CR_X --name hand_r_ctrl --control-type transform --parent hand_r

Add a named curve element

cfa add_rig_curve --asset-path /Game/Rigs/CR_X --name jaw_open

Add a socket under a parent bone/null

cfa add_rig_socket --asset-path /Game/Rigs/CR_X --name weapon_socket --parent hand_r

Declare a connector on a Control Rig MODULE asset

Declares the socket a modular rig binds this module by. A module has exactly ONE primary connector; secondary ones may be optional and/or arrays. Without connection rules a connector accepts anything, so auto_connect_rig_modules cannot resolve it, add rules with add_rig_connection_rule, or pass --default-rules for the engine's Socket-only rule.

cfa add_rig_connector --asset-path /Game/Rigs/CR_Module --name Root --type primary --default-rules

Change an existing connector's type, flags or description

Omitted flags are left unchanged. Primary connectors cannot be optional or arrays, the command refuses rather than writing state the engine silently drops.

cfa set_rig_connector_settings --asset-path /Game/Rigs/CR_Module --name Parent --type secondary --optional true

Add a connection rule restricting what a connector may bind to

Rules are what let the rule manager auto-resolve a connector. Rule properties are Unreal struct text. The available rule set DIFFERS BY ENGINE, run list_rig_connection_rule_types first.

cfa add_rig_connection_rule --asset-path /Game/Rigs/CR_Module --connector Root --rule Type --properties "(ElementType=Socket)"

List the connection rule types this engine ships

The set is version dependent: FRigOnChainRule exists on 5.6/5.7 only, FRigArraySizeConnectionRule on 5.8 only. Discovered by reflection, so it is always what THIS engine actually has.

cfa list_rig_connection_rule_types

Create a Control Rig MODULE asset

Creates a building block for a Modular Rig. This is NOT create_control_rig --modular, which creates the modular rig CONTAINER. Import the skeleton via --skeleton-path in the same call: conversion rebuilds the hierarchy and a module may otherwise only hold bones, curves and connectors. When the hierarchy has no connector yet, the engine spawns a primary connector plus matching socket automatically.

cfa create_control_rig_module --asset-path /Game/Rigs/CFA_ChainLimited --skeleton-path /Game/Chars/SK_Hero --category Physics

Read a Control Rig's module identity and metadata

cfa get_rig_module_settings --asset-path /Game/Rigs/CFA_ChainLimited

Write a module's identity and library metadata

display_name IS the module identifier, an asset is a module precisely because that field is non-empty. Everything else is browser metadata.

cfa set_rig_module_settings --asset-path /Game/Rigs/CFA_ChainLimited --category Physics --keywords "jiggle,dangle"

Add an asset-level member variable to a Control Rig

public=true is what makes the variable appear as per-instance module CONFIG in a Modular Rig: it clears CPF_DisableEditOnInstance, which is exactly what the modular rig tests for. Struct and array types need a CPP type PATH, a bare struct name asserts.

cfa create_rig_variable --asset-path /Game/Rigs/CFA_ChainLimited --name ConeAngle --cpp-type float --default-value 20.0

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

Use this instead of calling create_rig_variable in a loop. Each singular call runs a FULL blueprint compile (class reinstancing + garbage collection), so a few in a row crash the editor. This adds every variable skeleton-only and compiles once at the end. Flags match the singular command exactly, so public=true still yields module config.

cfa create_rig_variables --asset-path /Game/Rigs/CFA_ChainLimited --variables '[{"name":"ConeAngleDeg","cpp_type":"float","default_value":"20.0"},{"name":"SquishCm","cpp_type":"float","default_value":"3.0"},{"name":"Bones","cpp_type":"TArray</Script/ControlRig.RigElementKey>"}]'

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

cfa list_rig_variables --asset-path /Game/Rigs/CFA_ChainLimited

Remove an asset-level member variable from a Control Rig

cfa remove_rig_variable --asset-path /Game/Rigs/CFA_ChainLimited --name ConeAngle

Add an animation channel under a control

Adds an animation channel. ALWAYS pass minimum/maximum for a scalar channel: without them the channel is created with Min=Max=0, and the details panel and Sequencer feed the spin box straight from those values with no limit check, so SSpinBox clamps every drag commit to 0, the slider looks alive and always returns 0. minimum/maximum fix the slider; limit_enabled additionally hard-clamps typed values.

cfa add_rig_animation_channel --asset-path /Game/Rigs/CR_X --name HairGravity --parent-control root_ctrl --control-type float --minimum 0 --maximum 50

Reparent an element

cfa set_rig_element_parent --asset-path /Game/Rigs/CR_X --name hand_ctrl --parent arm_null

Update a control's settings (reflection)

cfa set_rig_control_settings --asset-path /Game/Rigs/CR_X --name hand_ctrl --settings '{"ShapeName":"Box"}'

Set a control's initial or current value

cfa set_rig_control_value --asset-path /Game/Rigs/CR_X --name switch_ctrl --value true

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

cfa move_rig_control --asset-path /Game/Rigs/CR_X --name global_ctrl --transform '{"location":{"x":0,"y":0,"z":50}}' --relative

Select/deselect rig elements through the engine controller

cfa select_rig_elements --asset-path /Game/Rigs/CR_X --names global_ctrl,hips_ctrl

Set a control's offset transform

cfa set_rig_control_offset --asset-path /Game/Rigs/CR_X --name hand_ctrl --transform '{"location":{"x":0,"y":0,"z":10}}'

Set an element's transform

cfa set_rig_element_transform --asset-path /Game/Rigs/CR_X --name spine_01 --transform '{"location":{"x":0,"y":0,"z":100}}'

Remove an element from the rig hierarchy

cfa remove_rig_element --asset-path /Game/Rigs/CR_X --name hand_ctrl

Rename an element

cfa rename_rig_element --asset-path /Game/Rigs/CR_X --name ctrl_a --new-name hand_l_ctrl

Atomically build a whole hierarchy

Builds bones/nulls/controls/curves/sockets from an elements[] array in one call, validated before mutation. Each element: {type,name,parent,parent_type,transform,control_type,value...}. For controls prefer "offset_from_bone":"<bone>" over a raw offset_transform, a control's offset is PARENT-RELATIVE, so feeding a bone's global transform to a parented control compounds every ancestor offset (the build refuses it and tells you the correct value).

cfa build_rig_hierarchy --asset-path /Game/Rigs/CR_X --json '{"elements":[...]}'

Read the rig hierarchy as a tree

cfa get_rig_hierarchy --asset-path /Game/Rigs/CR_X --include-transforms

Read one element

cfa get_rig_element --asset-path /Game/Rigs/CR_X --name hand_ctrl

List valid control + element types

cfa list_rig_control_types

Search RigVM graph node types

Fuzzy-searches available RigVM node types (template notations + unit structs) and returns the top-N ranked, like search_nodes for blueprints.

cfa search_rig_vm_nodes --filter "get transform"

List registered RigVM template notations

cfa list_rig_vm_node_types --filter Math

Describe one or many RigVM node types' pins

Returns inputs/outputs for a node type. Single: --type-name. Batch: --type-names "A,B,C" (or a JSON array via --json) describes each in one call.

cfa get_rig_vm_node_type_info --type-names "RigVMFunction_MathFloatAdd,RigVMFunction_MathFloatMul"

Read a RigVM graph's nodes

cfa get_rig_vm_graph_nodes --asset-path /Game/Rigs/CR_X

Describe one RigVM node in a graph

cfa describe_rig_vm_node --asset-path /Game/Rigs/CR_X --node-name GetTransform

Add a node to a RigVM graph

Adds a unit/template/variable/reroute/comment node. Unit: node_type = struct name/path. Template: node_type = notation. Variable: variable_name + cpp_type + is_getter.

cfa add_rig_vm_node --asset-path /Game/Rigs/CR_X --node-type RigVMFunction_MathFloatAdd --pos-x 100

Connect an output pin to an input pin

cfa connect_rig_vm_nodes --asset-path /Game/Rigs/CR_X --source-node A --source-pin Result --target-node B --target-pin Value

Break a link, or all links on a pin

cfa disconnect_rig_vm_nodes --asset-path /Game/Rigs/CR_X --node B --pin Value

Set a node pin's default value

cfa set_rig_vm_pin_default --asset-path /Game/Rigs/CR_X --node Add --pin A --value 2.0

Set a RigVM node's position

cfa set_rig_vm_node_position --asset-path /Game/Rigs/CR_X --node Add --pos-x 400 --pos-y 100

Remove a node from a RigVM graph

cfa remove_rig_vm_node --asset-path /Game/Rigs/CR_X --node Add

Atomically build a RigVM graph

Adds nodes[] and connections[] in one undo bracket, with optional auto-layout. Connection endpoints are node indices (into nodes[]) or explicit node names.

cfa build_rig_vm_graph --asset-path /Game/Rigs/CR_X --json '{"nodes":[...],"connections":[...]}'

Auto-arrange a RigVM graph

cfa layout_rig_vm_graph --asset-path /Game/Rigs/CR_X

Batch-set many node pin defaults in one call

Applies an array of {node, pin, value} in one undo bracket. The efficient way to assign bones/values across many nodes (vs one set_rig_vm_pin_default per pin).

cfa set_rig_vm_pin_defaults --asset-path /Game/Rigs/CR_X --json '{"pins":[{"node":"AddNode","pin":"A","value":"5.0"}]}'

List available gizmo shape names

Lists the shape names a rig can use (from its shape libraries; falls back to the engine default library). Use these for --shape-name on add_rig_control / set_rig_control_shape.

cfa list_rig_control_shapes --asset-path /Game/Rigs/CR_X

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

cfa set_rig_control_shape --asset-path /Game/Rigs/CR_X --name hand_l_ik_ctrl --shape-name Box --shape-color '{"r":1,"g":0,"b":0}'

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

Owns the gizmo pass/fail verdict so callers cannot write the gate wrong. Errors: shape_transform_identity (fit_rig_control_shapes never ran), gizmo_inside_mesh (buried, unclickable). Warnings: default_shape_name, gizmo_oversized. Animation-channel and bool controls are skipped, not flagged, they cannot own a shape (FRigControlSettings::SupportsShape), and are counted in 'non_shape_controls_skipped'. Read 'verdict', pass or fail.

cfa validate_rig_gizmos --asset-path /Game/Rigs/CR_X

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

cfa fit_rig_control_shapes --asset-path /Game/Rigs/CR_X --margin 1.25

Set a RigVM node's tint color

cfa set_rig_vm_node_color --asset-path /Game/Rigs/CR_X --node AddNode --color '{"r":0.2,"g":0.4,"b":1}'

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

cfa set_rig_vm_node_size --asset-path /Game/Rigs/CR_X --node NoteNode --width 500 --height 300

Set a comment node's text/font/bubble

cfa set_rig_vm_comment --asset-path /Game/Rigs/CR_X --node NoteNode --text "Leg IK" --font-size 24

Rename a RigVM node

cfa rename_rig_vm_node --asset-path /Game/Rigs/CR_X --node RigVMFunction_MathFloatAdd --new-name LegBlend

Expand/collapse a struct/array pin

cfa set_rig_vm_pin_expansion --asset-path /Game/Rigs/CR_X --node SetTransform --pin Value --expanded=true

Toggle a pin's debug watch

cfa set_rig_vm_pin_watch --asset-path /Game/Rigs/CR_X --node SetTransform --pin Value

Lock a wildcard/template pin to a concrete type

cfa resolve_rig_vm_wildcard_pin --asset-path /Game/Rigs/CR_X --node MakeArray --pin Values --cpp-type FVector

Set an array pin's element count

cfa set_rig_vm_array_pin_size --asset-path /Game/Rigs/CR_X --node SelectNode --pin Values --size 3

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

Edits one element of an array pin without resizing the whole pin. op: add (append), insert (at index), remove (the element at index), duplicate (the element at index), clear (every element). The reply gives the new size and, for add/insert/duplicate, the new element's pin path. Use set_rig_vm_array_pin_size to set a size outright.

cfa edit_rig_vm_array_pin --asset-path /Game/Rigs/CR_X --node SetTransforms --pin Items --op insert --index 0 --default-value "(Type=Bone,Name=\"hand_l\")"

Remove an extra pin from an aggregate node

The inverse of add_rig_vm_aggregate_pin: removes one extra pin of a Sequence or a variadic math node, with its links.

cfa remove_rig_vm_aggregate_pin --asset-path /Game/Rigs/CR_X --node Sequence --pin D

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

Resets a pin to the value its node type starts with, and returns that value. Use it instead of guessing the default text for set_rig_vm_pin_default.

cfa reset_rig_vm_pin_default --asset-path /Game/Rigs/CR_X --node BasicIK --pin Weight

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

cfa add_rig_vm_aggregate_pin --asset-path /Game/Rigs/CR_X --node SequenceNode --count 3

Bind a pin directly to a variable

cfa bind_rig_vm_pin_to_variable --asset-path /Game/Rigs/CR_X --node SetTransform --pin Weight --variable IKWeight

Remove a pin's variable binding

cfa unbind_rig_vm_pin_from_variable --asset-path /Game/Rigs/CR_X --node SetTransform --pin Weight

Define a new function in the function library

Creates a reusable function in the rig's function library. Edit its body by passing its name as graph_name to add_rig_vm_node / build_rig_vm_graph, and define its interface with add_rig_vm_exposed_pin.

cfa create_rig_vm_function --asset-path /Game/Rigs/CR_X --name TwoBoneLeg --mutable=true

Remove a library function

cfa remove_rig_vm_function --asset-path /Game/Rigs/CR_X --name TwoBoneLeg

Rename a library function

cfa rename_rig_vm_function --asset-path /Game/Rigs/CR_X --name TwoBoneLeg --new-name IKLeg

Add a top-level graph to the rig

Adds a second (third...) top-level graph beside the default one. The engine stores the name as 'RigVMModel <name>'; the reply gives the stored graph_name, which is what every other command takes as graph_name.

cfa add_rig_vm_graph --asset-path /Game/Rigs/CR_X --name Fingers

Remove a top-level graph and its nodes

Removes a top-level graph that add_rig_vm_graph or build_graph made. The default graph cannot be removed (the engine refuses it).

cfa remove_rig_vm_graph --asset-path /Game/Rigs/CR_X --graph-name "RigVMModel Fingers"

Rename a top-level graph

cfa rename_rig_vm_graph --asset-path /Game/Rigs/CR_X --graph-name "RigVMModel Fingers" --new-name Hands

Change the type or the position of an exposed pin

Changes an exposed pin of a function or a collapse node in place: its type, its position among the pins, or both. Links that no longer fit the new type are dropped by the engine. Rename with rename_rig_vm_exposed_pin.

cfa set_rig_vm_exposed_pin --asset-path /Game/Rigs/CR_X --graph-name IKLeg --pin-name Weight --cpp-type double --index 0

Set a function's category, keywords and description

Sets where a library function shows in the node menu (category), what a search finds it by (keywords) and its tooltip (description). Only the flags you pass change; an empty string clears one. list_rig_vm_functions returns all three.

cfa set_rig_vm_function_metadata --asset-path /Game/Rigs/CR_X --name IKLeg --category "Limbs|Legs" --description "Two bone IK with a pole vector"

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

Changes a local variable of a function graph in place. Only the flags you pass change. Variable nodes that use it follow a rename.

cfa set_rig_vm_local_variable --asset-path /Game/Rigs/CR_X --graph-name IKLeg --name Temp --new-name Blend --default-value 0.5

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

Toggles a function's visibility and/or purity. is_pure requires UE 5.8+. Pass only the flags you want to change.

cfa set_rig_vm_function_access --asset-path /Game/Rigs/CR_X --name IKLeg --is-public true

List library functions with their I/O

cfa list_rig_vm_functions --asset-path /Game/Rigs/CR_X

Place a call to a library function

Adds a node that calls a function of this rig's library. With --function-asset-path the function is of another rig: it must be public there (list_rig_vm_functions shows is_public). The node then depends on that rig; localize_rig_vm_function copies the function in when the rig must stand alone.

cfa add_rig_vm_function_node --asset-path /Game/Rigs/CR_X --function-name IKLeg

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

Adds an interface pin to a function or collapse sub-graph. Pass the function name as graph_name. Direction is input|output|io. For struct/enum types set cpp_type_object to the type's object path.

cfa add_rig_vm_exposed_pin --asset-path /Game/Rigs/CR_X --graph-name IKLeg --pin-name Weight --direction input --cpp-type float

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

cfa remove_rig_vm_exposed_pin --asset-path /Game/Rigs/CR_X --graph-name IKLeg --pin-name Weight

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

cfa rename_rig_vm_exposed_pin --asset-path /Game/Rigs/CR_X --graph-name IKLeg --pin-name Weight --new-name Alpha

Collapse nodes into a sub-graph

Collapses the given nodes into a single collapse node with its own contained graph. Edit that sub-graph by passing the collapse node's name as graph_name. Promote it to a reusable library function with promote_rig_vm_node.

cfa collapse_rig_vm_nodes --asset-path /Game/Rigs/CR_X --node-names get_leg,solve_leg,set_leg --collapse-name LegBlock

Expand a collapse/function node back inline

cfa expand_rig_vm_node --asset-path /Game/Rigs/CR_X --node LegBlock

Promote collapse<->function

to_function turns a collapse node into a reusable library function (+ a reference to it). to_collapse turns a function reference back into an inline collapse node.

cfa promote_rig_vm_node --asset-path /Game/Rigs/CR_X --node LegBlock --direction to_function

Add a graph-scoped local variable

cfa add_rig_vm_local_variable --asset-path /Game/Rigs/CR_X --graph-name MyFunction --name IKWeight --cpp-type float --default-value 1.0

Remove a graph-scoped local variable

cfa remove_rig_vm_local_variable --asset-path /Game/Rigs/CR_X --name IKWeight

List a graph's local variables

cfa list_rig_vm_local_variables --asset-path /Game/Rigs/CR_X

Reset a template node's pins to wildcard

Inverse of resolve_rig_vm_wildcard_pin — resets one or more template nodes back to their wildcard state so their type can be re-inferred from new connections.

cfa unresolve_rig_vm_node --asset-path /Game/Rigs/CR_X --node MakeArray

Add a solve event node by friendly name

Adds a Control Rig solve event: construction (setup), forward (Forwards Solve, the per-frame solve), backward (Backwards Solve), preforward, postforward, or interaction.

cfa add_rig_vm_event --asset-path /Game/Rigs/CR_X --event backward

List every graph in the rig

Lists all graphs — top models (Forwards/Construction/Backwards live here), the function library, each function, and each collapse sub-graph — with the graph_name to pass to other commands and its kind + node count.

cfa list_rig_vm_graphs --asset-path /Game/Rigs/CR_X

Sample the live preview rig per frame

Starts capturing every rendered frame's bone transforms from the OPEN asset editor's preview rig instance. Measures what screenshots cannot: frame-to-frame jitter, oscillation, and frame-dt spikes. Fetch results with get_rig_motion_report.

cfa start_rig_motion_capture --asset-path /Game/Rigs/CR_X --frames 120

Per-bone jitter/motion statistics

Returns the capture report: per-bone RMS frame-to-frame position delta, direction-flip ratio, amplitude, rotation deltas, and a jittering/swinging/moving/stable verdict — worst offenders first — plus frame-dt stats. Poll until complete=true.

cfa get_rig_motion_report

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

Drives one control through a sine shake on the OPEN asset editor's preview instance, freezes it, then keeps sampling. Residual bone motion AFTER the driver stops IS jiggle: a pure-FK bone stops dead with its control, a simulated bone keeps decaying. This is the only gate that separates a calm rig from a DEAD one - a body census, a solver count and a 'healthy' verdict all read identical on a rig where nothing simulates. Needs no animation asset. Fetch results with get_rig_physics_probe_report.

cfa start_rig_physics_probe --asset-path /Game/Rigs/CR_X --shake-cm 30

Per-bone residual jiggle after the driver stopped

Returns the probe report: per-bone LINEAR and ANGULAR residual measured only in the settle window, worst first, plus how far the shake actually moved each bone. Judge only rows with excited=true - a bone the shake never reached carries no verdict. residual_rms_deg is what catches flesh and hair, which rotate about their own origin and barely translate, so a linear-only reading calls a visibly jiggling chain dead. verdict is one of physics_alive, no_physics_response (bones moved then stopped dead) or inconclusive (the shake excited nothing). Poll until complete=true.

cfa get_rig_physics_probe_report

Set an existing rig's preview skeletal mesh

Sets the skeletal mesh a Control Rig previews on (UControlRigBlueprint::SetPreviewMesh — the same engine path as the editor's Preview Settings mesh picker). create_control_rig_from_skeleton sets this automatically; use this to change it afterwards or on rigs created empty.

cfa set_rig_preview_mesh --asset-path /Game/Rigs/CR_X --mesh-path /Game/Chars/SK_Hero

Add a Rig Module to a Modular Rig

Adds a Rig Module instance to a Modular Rig — the same engine path as the editor's drag-and-drop Module workflow. Epic ships a module library under /ControlRigModules/Modules (Arm, Leg, Spine, Neck, Shoulder, Foot, Finger, Chain...). Returns the new module's connectors so you can bind them next.

cfa add_rig_module --asset-path /Game/Rigs/MR_X --module-name Arm_l --module-asset-path /ControlRigModules/Modules/Arm

Bind a module connector to an element

Connects a module's connector (primary or secondary, e.g. "Arm_l/Root") to a hierarchy element. Pre-validates with the engine's CanConnectConnectorToElement so failures explain WHY; other connectors auto-resolve where possible.

cfa connect_rig_module_connector --asset-path /Game/Rigs/MR_X --connector "Arm_l/Root" --target-name upperarm_l

Auto-resolve module connectors

Runs the engine's modular-rig rule manager to auto-resolve connectors for the given modules (all modules when omitted) — the same logic as the editor's auto-resolve. Returns every connector with its resolved targets.

cfa auto_connect_rig_modules --asset-path /Game/Rigs/MR_X

List engine-valid targets for a module connector

Queries Unreal's Modular Rig rule manager for one connector. Returns compatible targets in engine order with default/possible state, parent and transforms; optionally includes rejected targets with the engine's reason. Use this before choosing primary sockets or correcting secondary auto-resolution on arbitrary skeletons.

cfa get_rig_module_connector_candidates --asset-path /Game/Rigs/MR_X --connector "Spine/Spine Primary"

List a Modular Rig's modules

Lists every module instance in a Modular Rig with its module class, parent module, each connector's resolved targets (plus primary/optional/array flags), warnings (required-but-unconnected connectors, outdated module assets — the editor's red triangles), and config-override/binding counts.

cfa list_rig_modules --asset-path /Game/Rigs/MR_X

Delete a module from a Modular Rig

Deletes a module instance (and its elements) from a Modular Rig.

cfa remove_rig_module --asset-path /Game/Rigs/MR_X --module-name Arm_l

Query the Rig Module asset library

The editor's Module Assets browser as a command: scans the asset registry (no asset loads) for every Rig Module asset and returns name, category, connectors summary and variant tags (Epic/Physics/Stable/...). Assets whose tags mark them deprecated are excluded by default, matching the editor's 'Exclude Outdated' filter. --detailed adds keywords, description and the full connector list (the module's documentation, e.g. ChainPhysics' options).

cfa list_rig_module_assets --filter Chain --detailed

Read a module instance's config

Lists a module instance's config variables: name, type, read-only flag and bindings, plus active overrides. Use --filter and --max-results for compact discovery, --include-defaults for full Unreal-text defaults, and --variable for possible binding sources.

cfa get_rig_module_config --asset-path /Game/Rigs/MR_X --module-name Arm_l

Set or reset a module config value

Sets a config value on a module instance (recorded as an override, exactly like editing the Details panel). Paths can address nested members with '->' (e.g. "Settings->Strength"). --reset clears the override so the module default applies again. Values use Unreal text syntax: 2.5, true, (X=1,Y=0,Z=0).

cfa set_rig_module_config --asset-path /Game/Rigs/MR_X --module-name Tail --path Control_Count --value 8

Bind a module variable to another module's variable

Binds a module's variable to a source variable in another module (or the rig itself), so the value flows through at runtime. Pre-validates with the engine and, on failure, lists the valid binding sources. Empty --source-path unbinds.

cfa bind_rig_module_variable --asset-path /Game/Rigs/MR_X --module-name Arm_l --variable Speed --source-path "Spine.Speed"

Rename a module instance

Renames a module instance with engine validation (CanRenameModule) — all namespaced element names update automatically.

cfa rename_rig_module --asset-path /Game/Rigs/MR_X --module-name Arm_l --new-name LeftArm

Reparent a module instance

Moves a module under a new parent module in the module hierarchy. Empty --new-parent-module makes it a root module.

cfa reparent_rig_module --asset-path /Game/Rigs/MR_X --module-name Hand_l --new-parent-module Arm_l

Reorder a module among its siblings (5.7+)

Changes a module's index among its siblings in the module hierarchy. Requires UE 5.7+ (the engine API does not exist on 5.6).

cfa reorder_rig_module --asset-path /Game/Rigs/MR_X --module-name Arm_l --index 0

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

Creates a mirrored copy of a module — the editor's Mirror action. Connector targets and config values are mirrored across the axis, with element names rewritten via search/replace (e.g. "_l" to "_r"). Returns the new module and its connectors.

cfa mirror_rig_module --asset-path /Game/Rigs/MR_X --module-name Arm_l --search _l --replace _r

Swap a module's source asset

Replaces the Rig Module asset behind a module instance (e.g. upgrade a module flagged outdated by list_rig_modules), keeping connections where the connectors are compatible.

cfa swap_rig_module --asset-path /Game/Rigs/MR_X --module-name Arm_l --new-module-asset-path /ControlRigModules/Modules/Arm

List rig sockets with placement hints and claimed state

Lists every socket with its parent bone, placement hint (the schematic's 'Place the leg module here' text authored by modules) and whether a module connector already claims it. With the asset editor open it reads the DEBUG hierarchy, where module-spawned placement sockets live, the workflow: query --only-empty, place the suggested module on each hinted socket, re-query (new sockets appear as modules spawn them), repeat until none are empty.

cfa list_rig_sockets --asset-path /Game/Rigs/MR_X --only-empty

List hierarchy components (physics solvers/bodies/joints)

Lists every hierarchy component with its type and owning element. Construction-spawned components (RigPhysics solver/body/joint components from ChainPhysics etc.) only exist on the DEBUG instance, open the asset editor first. An empty list with physics modules present means their construction did not build physics.

cfa list_rig_components --asset-path /Game/Rigs/MR_X --filter Solver

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

Reads the LIVE debug instance's bone positions and compares each to the rest pose. A large deviation means the rig is visibly broken (fallen physics bodies, bad IK) regardless of jitter stats. Works on modular and manual-graph rigs. open_asset first so a debug instance exists.

cfa get_rig_pose --asset-path /Game/Rigs/MR_X --threshold-cm 5

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

Reads the real GPU skinning matrices for every bone (RefBasesInv * ComponentSpaceTransform, which is the IDENTITY at rest) and reports the three things that visibly wreck a character but are invisible to a bone-position check: non-unit scale (melted or inflated), a sheared basis (smeared skin), and a mirrored basis with negative determinant (renders inside-out). Also reports plain displacement from rest for context. Needs the asset OPEN so the debug instance exists; if component-space transforms are not ready it refuses to report rather than hand back bind-pose inverses that would make every bone look broken.

cfa validate_rig_deformation --asset-path /Game/Rigs/CR_X

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

Validates the LIVE rig's physics: dynamic bodies without joints (they FREE-FALL and stretch their bones to the floor), joints left FULLY UNCONSTRAINED (Swing1, Swing2 and Twist all ACM_Free - the engine's default for an unedited joint, under which the Swing/Twist limit degrees are ignored entirely) WHOSE BONE POINTS ACROSS GRAVITY, reported with the roll angle each will take to hang below its pivot; free joints on bones that already hang along gravity are at equilibrium and are reported as info, not as a defect, because that is the normal and correct state of a hair chain. Also elements carrying multiple bodies (cross-module conflict that breaks joint resolution), solver count, and bones currently displaced from rest. Run after every physics change; healthy=true means no issues. If joints exist but their limits could not be read, rollover_joints is omitted and an issue says the check did not run - never read a missing field as zero.

cfa validate_rig_physics --asset-path /Game/Rigs/MR_X

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

Summarizes what a rig module actually does: per-graph node counts, node-type histogram, and the config variables its graph reads. Accepts Control Rig Blueprint modules on every version and 5.8 runtime-asset modules (ChainPhysics etc.).

cfa analyze_rig_module_asset --module-asset-path /ControlRigModules/Modules58/ChainPhysics

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

By default rig mutations only mark the asset dirty, a full disk save per command costs 2-3s on big rigs and made long build sessions crawl. Persist explicitly with save_asset/save_all at your validation gates. Pass --enabled to restore save-every-command behavior for this editor session.

cfa set_rig_autosave --enabled=false

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

Derives collision from get_skeletal_bone_bounds instead of guessing: dynamic links get ONE median-fitted shape (ChainPhysics applies the same collision to every link, the per-bone spread is reported so the compromise is visible) and every kinematic bone gets its own mesh-true capsule via ExtraCollisionSettings (indexed in Kinematic order). Requests a construction pass so the live instance picks it up. Gate after: dump_rig_components, measure_mesh_penetration, validate_rig_physics.

cfa fit_rig_chain_collision --asset-path /Game/Rigs/MR_X --module-name Braid --shape sphere --margin-cm 0.5

Generate a kinematic body-collider rig module asset

Creates a module whose config Bones[] + Colliders[] spawn one KINEMATIC physics body per bone at construction, auto-joins the solver on the root bone and collides with every chain in that solver. This solves the disjoint-bones deadlock: cover glutes/hips/thighs with mesh-true shapes WITHOUT putting colliders on any chain's Start/anchor bone. After creating: add_rig_module it, connect its Root connector to any bone, then set Bones/Colliders config sized from get_skeletal_bone_bounds.

cfa create_rig_body_collider_module --asset-path /Game/CFA_Modules/CFA_BodyColliders

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

CPU-skins the rig's preview mesh at the live (or rest) pose and reports how deep chain-side vertices (hair/braid/dress, selected by chain_filter) sit inside per-bone body volumes, worst chain-vs-body bone pairs with depth in cm. Bone motion stats CANNOT see mesh clip: a rig can be 'stable' while the braid rests inside the glutes. Gate contact quality on this command after any collision change.

cfa measure_mesh_penetration --asset-path /Game/Rigs/MR_X --chain-filter hair_braid,dress --body-filter pelvis,thigh,spine,butt

Real per-bone geometry from skinned vertices + physics asset

Computes each bone's actual geometric bounds from the mesh's skinned vertices: axis-aligned box, a fitted capsule (axis/radius/half-length), and 'fit_oriented', Epic's own primitive fit (covariance -> dominant eigenvector -> OBB in that frame, the same math Create Physics Asset uses) giving radius, CYLINDER-ONLY length and a ready-to-paste capsule TM whose rotation puts local +Z on the measured long axis. Plus the physics asset's authored shapes. weight_mode 'dominant' answers 'how thick is THIS bone's flesh'; 'any' answers 'all skin this bone can move', the right question for a collider. Size physics collision from this instead of guessing.

cfa get_skeletal_bone_bounds --mesh-path /Game/Chars/SKM_Hero --filter butt --weight-mode any

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

A pole control left ON its joint gives the IK solver a degenerate bend plane: it ROLLS the limb instead of bending it, and the visible symptom is the hips/shoulders twisting. This derives the bend direction from the limb's own geometry (never a hardcoded axis), pushes the control out along it, and VERIFIES the resulting world position, set_rig_control_offset takes a PARENT-RELATIVE transform, so a world position written straight into it silently leaves the control where it was. If the limb is STRAIGHT in the rest pose the bend vector is numerical noise and the command refuses to guess: supply facing_bone_a + facing_bone_b (a measured direction, e.g. ankle -> toe) or fallback_direction, and use invert for joints that bend away from it (an elbow vs a knee).

cfa place_rig_pole_vector --asset-path /Game/Rigs/CR_X --control PV_leg_l_ctrl --root-bone thigh_l --mid-bone calf_l --end-bone foot_l --facing-bone-a foot_l --facing-bone-b ball_l

Purge persisted components from the blueprint hierarchy

Removes components matching a type/name substring from the BLUEPRINT hierarchy. Construction-spawned physics components must never persist in the asset, stale saved copies duplicate on every rebuild (auto-renamed) and silently break joint resolution. Run 'validate_rig_physics' after to confirm one body per bone.

cfa remove_rig_components --asset-path /Game/Rigs/MR_X --filter Physics

Full field dump of live hierarchy components via reflection

Dumps EVERY reflected field of live components (physics solver/body/joint: BodyData.MovementType, Collision shape dims, joint Parent/ChildBodyComponentKey, DriveData, KinematicTarget...) from the running debug instance. On UE 5.8 physics bodies also include live_state: the simulated transform, linear/angular velocity and speed, the direct answer to 'is this body actually moving/jiggling' and 'why does it rest offset'. Scope with --element or --fields to keep output small.

cfa dump_rig_components --asset-path /Game/Rigs/MR_X --element butt_l --fields '["BodyData","Dynamics"]'

List animation channels with hosts and live values

Lists every animation channel (module config such as Gravity Multiplier / Simulation Mode is exposed as channels) with its host control, value type, and live current + initial values from the running instance. The live 'current' value is what the graph actually reads each frame, config variables only seed channels at first construction.

cfa list_rig_channels --asset-path /Game/Rigs/MR_X --filter Gravity

Write animation channel values on the running instance

Sets Bool/Float/Integer animation channel CURRENT values on the running debug instance, the sim reads them next tick, no reconstruction. This is the correct way to live-tune module physics. Pass --set-initial to also persist through re-construction. Exact or unambiguous-suffix channel names accepted. Batch: --channels '[{"channel":"butt_l/Stiffness","value":"1"},{"channel":"butt_r/Stiffness","value":"1"}]'.

cfa set_rig_channel_value --asset-path /Game/Rigs/MR_X --channel "butt_l/GravityScale" --value 2.0

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

Plays an animation asset as the preview's source pose. Default solve mode 'backwards_and_forwards' runs Backwards Solve (animation -> control values) then Forwards Solve each frame, so the animation actually DRIVES the rig and physics reacts to the motion, combine with start_rig_motion_capture to measure real jiggle amplitude headless. A rig without a Backwards Solve event gets a clear warning (module-driven bones would hold the control pose).

cfa play_rig_preview_animation --asset-path /Game/Rigs/MR_X --anim-path /Game/Anims/Walk

Stop the preview animation and restore forwards-only solve

Stops playback, clears the preview animation, restores the Forwards Solve event queue and resets the pose to initial.

cfa stop_rig_preview_animation --asset-path /Game/Rigs/MR_X

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

Jiggle amplitude comes from lever geometry, not spring values: a leaf flesh bone (butt, belly) has no swinging mass, so it reads rigid at any softness. This command adds an unskinned tip bone placed along the flesh bone's REAL skinned-vertex protrusion direction (furthest vertex + margin), rebinds the ChainPhysics module's 'End Bone' connector to it, optionally sets Strength/MinSize, reconstructs and verifies bodies exist on the tip. The tip is the pendulum bob whose momentum makes the flesh visibly wobble, the same mechanism as a breast/nipple chain.

cfa add_rig_jiggle_bob --asset-path /Game/Rigs/MR_X --flesh-bone butt_l --module-name Butt_l --strength 1.5 --min-size 5

Flag dead controls and undriven bones from live VM truth

Uses the engine's own VM dependency map (built from the rig's actual instruction read/write records) to flag controls that influence NOTHING, no instruction reads them, no hierarchy children, no hosted channels, no proxy drives, never referenced in any graph pin, plus bones nothing animates (no VM write up the parent chain, no physics body). Every flagged control carries a CURE suggestion: 'connect' when a bone name-matches (spine_02_ctrl -> spine_02, with the exact wiring recipe), 'review' when it sits on a bone without a name match, 'delete' (with the remove_rig_element line) when nothing plausible exists. Works WITHOUT the asset editor: falls back to a private headless instance and runs the forward solve with bool channels forced true so gated branches record; with the editor open it reads the live debug instance instead (source field says which).

cfa validate_rig_controls --asset-path /Game/Rigs/CR_X

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

The CLI-side equivalent of the editor's red node errors. Static pass over every graph: FRigElementKey pins referencing bones/controls that don't exist, animation-channel units whose Control/Channel can't resolve (with the available channel list), unresolved wildcard pins (whose defaults are silently dropped), mutable nodes with no incoming execute link (dead code), If nodes whose True and False hold the same unlinked constant (the Condition changes nothing, how an IK/FK switch ships stuck at weight 0), and visible controls that no node reads (dragging them moves nothing). With the asset editor open it also reads the running instance's RigVM log and maps every runtime warning/error back to the node that raised it.

cfa validate_rig_graph --asset-path /Game/Rigs/CR_X

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

Answers 'how will this rig behave in an AnimBP?' with hard data instead of guessing. Static pass: which solve events exist, which pins the Control Rig anim node would expose (public variables, animatable controls, animation channels with hosts), and which controls the Forwards Solve reads (pose controls vs safe channels). Measured pass: runs a PRIVATE headless instance on a perturbed pose and diffs which bones the forward solve overrides, once with channels at authored defaults and once with every bool channel forced true, so gated branches (IK weights, grounding, physics toggles) are exercised. Verdicts: pass_through | gated_writes | writes_bones | overrides_animation (the last means the rig will stomp incoming animation in an AnimBP).

cfa analyze_rig_io --asset-path /Game/Rigs/CR_X_Physics

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

Answers 'why is this rig slow?' with numbers. Runs the forward solve on a PRIVATE headless instance (5-frame warmup, then N timed frames) and reports: wall-clock avg/max ms and % of a 60fps frame budget, the hottest nodes from the engine's own RigVM instruction profiling (per-node ms, module cost attributed to the invoking instruction), a physics census (solvers, bodies, joints, per-solver body distribution), and red flags with the fix spelled out, multiple solvers (the ChainPhysics 'Solver Bone' trap: every bound Solver Bone CREATES an independent Chaos sim; unbound chains auto-join the one shared solver), construction re-requested every frame, over-budget averages, excessive body counts. Bool channels are forced true by default so gated physics/IK is included in the cost.

cfa profile_rig --asset-path /Game/Rigs/CR_X

Which controls actually MOVE bones, empirical connectivity map

Answers "if I grab this control in the viewport and move it, does anything happen?" by DOING it: every animatable control is nudged on a PRIVATE headless instance and the resulting bone movement is measured. Static checks cannot answer this, validate_rig_controls only asks whether some VM instruction READS the control, and a control can be read and still have zero effect (the IK/blend weight feeding it is 0, it sits on a branch that never executes, or a later stage overwrites those bones). Each control gets a verdict: drives_bones, weak_effect, no_effect, or undetermined (the control itself could not be moved, position-only controls cannot rotate, so nothing can be concluded). Rotation and translation are probed separately (rotation_verdict/translation_verdict) because FK controls are ROTATED while IK effectors are MOVED. Read-only: nothing is saved.

cfa analyze_rig_control_impact --asset-path /Game/Rigs/CR_X

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

Runs the rig's forward solve on a PRIVATE instance for N frames, independent of any open editor window, feeding a real AnimSequence frame-by-frame as the input pose (bones matched by name), with real delta time so physics actually simulates. Reports: minimum segment-to-segment distance per requested bone-segment pair with a crossing flag (catches crossed/crushed legs numerically), every bone dipping below --ground-z, per-bone deviation from the input animation (what the rig changed), NaN/explosion instability, and optional per-frame trajectories for named bones. By default the rig is bound to the editor world so SphereTrace/world-collision units hit level geometry. Also reports bones_moved_by_rig, the WORLD-space displacement the rig added on top of the input pose, which is the number to read for 'did anything move' (bones_modified_by_rig counts local overrides only and collapses a driven chain onto its root). Pass --shake-bone to run the physics alive-gate: the input pose is oscillated then FROZEN, and any remaining motion is reported as residual RMS per bone with bones_responding / physics_alive.

cfa simulate_rig --asset-path /Game/Rigs/CR_X_Physics --anim-sequence /Game/Anims/Walk --frames 90 --channels '{"foot_grounding":"true"}' --segment-pairs '[{"a":["thigh_l","calf_l"],"b":["thigh_r","calf_r"]}]'

Disconnect every connector that is part of a cycle

A module whose connector lands on an element that the module itself drives is a cycle, and the rig cannot order its modules. This disconnects every connector in a cycle and lists them. A rig with no cycle returns count 0.

cfa disconnect_cyclic_rig_connectors --asset-path /Game/Rigs/MR_X

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

The rig editor's own conversion, on an asset that exists. --to module: the rig becomes a Control Rig Module with a primary connector. The engine allows it only when the hierarchy holds imported bones, curves and connectors; --auto-convert-hierarchy lets the engine convert the rest. --to standalone: a module becomes a plain rig again; the engine CLEARS the hierarchy and imports the bones and sockets of the preview mesh again, so connectors and authored elements are gone. --check-only replies can_convert and the engine's reason, and changes nothing. create_control_rig_module makes a new module asset.

cfa convert_control_rig --asset-path /Game/Rigs/CR_Arm --to module --check-only

Select modules of a Modular Rig

Sets the module selection of a Modular Rig, the one the rig editor's module tree shows. --mode replace (default) selects only the named modules, add keeps the selection, remove takes the named modules off. --clear selects none. list_rig_modules marks the selected modules with selected=true.

cfa select_rig_modules --asset-path /Game/Rigs/MR_Hero --module-names Arm_L,Arm_R

Copy a function of another rig into this rig

The editor's Localize Function. Copies the function into this rig's library, with the private functions it calls, and makes every node of this rig that called the other rig's function call the copy. The reply gives the name of the copy (the engine adds a number when the name is taken), the functions added, and how many call nodes were moved to the copy. A private function can be copied; a public function it calls stays a call into the other rig.

cfa localize_rig_vm_function --asset-path /Game/Rigs/CR_X --function-asset-path /Game/Rigs/CR_Library --function-name IKLeg

Make call nodes call another function

The editor's Swap Function. --node swaps one call node of the graph. --old-function-name swaps every call of that function in the graph, or with --all-graphs in every graph of the rig. The new function is of this rig, or of --function-asset-path (public there). A pin the new function does not have stays as an orphan pin with its links (orphan_pins, pass_with_warnings: the rig does not compile until the link is moved); --setup-orphan-pins=false drops those links. UE 5.6 drops such a link by itself: the reply lists every dropped link in lost_links.

cfa swap_rig_vm_function_reference --asset-path /Game/Rigs/CR_X --old-function-name IKLeg --function-name IKLeg_V2 --all-graphs

Replace outdated nodes with the current ones

The editor's Upgrade Nodes. A node whose type Epic deprecated still runs, but it gets no fixes; validate_rig_graph reports each as outdated_node and get_rig_vm_graph_nodes marks it outdated. This replaces them with the current node and keeps the links the new node can take. --check-only lists them and changes nothing. With no --node-names every outdated node of the graph is upgraded; --all-graphs does the whole rig. A node the engine has no upgrade for is listed in still_outdated with pass_with_warnings.

cfa upgrade_rig_vm_nodes --asset-path /Game/Rigs/CR_X --all-graphs --check-only

Make a variable from a pin

The editor's Promote to Variable. Makes a variable of the rig with the type and the value of the pin, adds a variable node and links it to the pin: a Get node for an input pin, a Set node for an output pin (an output pin needs UE 5.8 or later). --create-variable-node=false binds an input pin to the variable with no node. --local makes a local variable of the function (UE 5.8 or later). A pin that is bound to a variable already uses that variable. The reply gives the variable name the engine chose.

cfa promote_rig_vm_pin_to_variable --asset-path /Game/Rigs/CR_X --node BasicIK --pin Weight

Set the name a pin shows

Gives a pin a label that is not its real name. Use it on the pins of a function so that every call of the function reads well: --graph-name FunctionLibrary --node <function> --pin <argument>. The pin keeps its real name for every command; only the label on the node changes. A call node takes none: the engine keeps the label on the function. --reset-display-name shows the real name again. get_rig_vm_graph_nodes shows display_name on a pin that has one. Pin categories are not offered: the engine keeps that feature switched off (RigVM.EnableNodeLayouts) and it asserts when used.

cfa set_rig_vm_pin_display_name --asset-path /Game/Rigs/CR_X --graph-name FunctionLibrary --node IKLeg --pin PoleWeight --display-name "Pole Weight"

Mark pin values as overrides, or clear the override

Works only while the engine's own switch for pin overrides is on (console variable RigVM.EnablePinOverrides, off by default: the feature is experimental in the engine). With the switch off the command is refused and nothing changes. A pin value that is an override stays as it is when the default of the node or of the function changes; a value that is not follows the new default. --clear takes the override off, and the pin then has the default value again (the same as reset_rig_vm_pin_default). With no --pins every pin of the node that holds a value is done. get_rig_vm_graph_nodes shows is_override on a pin.

cfa set_rig_vm_pin_override --asset-path /Game/Rigs/CR_X --node BasicIK --pins Weight,bPropagateToChildren

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

A trait is an extra block of pins a node can carry. The trait types are found by reflection: every struct under FRigVMTrait that a loaded plugin brings (the Deformer Graph plugin brings the traits of the Add Deformer node). With --node each type also says can_add, from the trait's own test, with the reason when it says no, and the reply lists the traits the node has.

cfa list_rig_vm_trait_types --asset-path /Game/Rigs/CR_X --node AddDeformer

Add a trait to a node

Adds a trait pin to a node. The trait type comes from list_rig_vm_trait_types; a type the node does not take is refused with the trait's own reason. --default-value sets the members of the trait as struct text. The node listing shows the traits of a node.

cfa add_rig_vm_trait --asset-path /Game/Rigs/CR_X --node AddDeformer --trait-type RigVMTrait_OptimusDeformerSettings

Remove a trait from a node

cfa remove_rig_vm_trait --asset-path /Game/Rigs/CR_X --node AddDeformer --trait-name RigVMTrait_OptimusDeformerSettings

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

Functions that share a variant id are variants of each other: the editor offers them as swaps for one another, and a tag such as Deprecated tells the user which one to move away from. --op create copies the function as a new variant (--variant-name, or the engine picks a name). add_tag and remove_tag take --tag, one of the Variant Tags of Project Settings > RigVM. split gives the function a variant id of its own. join puts it in the variants of --join-with. list_rig_vm_functions shows variant_tags and variants per function. Move the calls with swap_rig_vm_function_reference. A call node of a variant shows the title of the function the variant was made from (the engine copies the title); the function field of get_rig_vm_graph_nodes is the function it calls.

cfa edit_rig_vm_function_variant --asset-path /Game/Rigs/CR_X --name IKLeg --op create --variant-name IKLeg_V2

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

A component is a block of data on a rig element, such as a physics body on a bone. The types are found by reflection: every struct under FRigBaseComponent that a loaded plugin brings (Control Rig Physics and, on UE 5.8, Control Rig Dynamics). Each type gives its default name and whether an element holds only one of it. With --element each type also says can_add, from the type's own test, with the reason when it says no.

cfa list_rig_component_types --asset-path /Game/Rigs/CR_X --element hand_l

Add a component to a rig element

The hierarchy panel's Add Component, in the asset. --component-type comes from list_rig_component_types; a type the element does not take is refused with the type's own reason. --content sets members as struct text, the rest keep the defaults. This component is saved with the rig. It is not the same as a component a graph spawns at construction: those live on the running rig only (list_rig_components marks them spawned_by_graph) and must not be saved.

cfa add_rig_component --asset-path /Game/Rigs/CR_X --element hand_l --component-type RigPhysicsBodyComponent

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

Works on a component that is saved in the asset. --content takes struct text and changes only the members in the text; --new-name renames; --new-element moves the component to another element. The reply lists what changed and the content after (the first 600 characters). Read every field with dump_rig_components.

cfa set_rig_component --asset-path /Game/Rigs/CR_X --element hand_l --name PhysicsBody --new-element lowerarm_l

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

The rig editor's space picker. It works on the PREVIEW rig of the open editor (open_asset first), not on the asset: use it to test that a space does what you want. --space <element> makes that element the active parent, --default goes back to the parent the asset gives, --world is world space. The control stays where it is in the world (--keep-global-transform=false lets it jump). A space that would make a cycle is refused with the engine's reason. A compile or a reset puts the control back. To change the asset use edit_rig_control_spaces and set_rig_parent_weight; in Sequencer use add_control_rig_space_key.

cfa switch_rig_control_space --asset-path /Game/Rigs/CR_X --name hand_l_ctrl --world

Copy elements from another rig

The hierarchy panel's copy and paste between two rigs, in one call: the elements come with their settings, shapes and transforms. An element keeps its parent when the target has an element of that name, and goes to the top when it has not. --include-children takes everything below each named element too. A name that is taken in the target gets a number, or --replace-existing replaces the element that has it. Within one rig use duplicate_rig_elements.

cfa copy_rig_elements --asset-path /Game/Rigs/CR_New --from-asset-path /Game/Rigs/CR_Old --names hand_l_ctrl,hand_r_ctrl --type control

Copy one module's settings onto other modules

Copies the config values and variable bindings of one module onto other modules made from the same module asset (the editor's Copy / Paste Module Settings). Use it to tune one arm and give the other arm the same values.

cfa copy_rig_module_settings --asset-path /Game/Rigs/MR_X --module-name Arm_l --to-modules Arm_r

Clear a module connector's binding

Disconnects a module connector from its target(s). --disconnect-sub-modules also clears connectors of nested modules that depended on it.

cfa disconnect_rig_module_connector --asset-path /Game/Rigs/MR_X --connector "Arm_l/Root"

Give a null or a control one more parent

A null or a control can follow more than one parent, each with a weight. This is how space switching is authored: the element keeps its first parent and gets more spaces to follow. The new parent comes in with weight 0 by default, so nothing moves until set_rig_parent_weight (or a space switch) raises it. A bone, a curve, a socket and an animation channel have one parent only: move those with set_rig_element_parent. The reply lists every parent with its weights; get_rig_element shows the same later.

cfa add_rig_element_parent --asset-path /Game/Rigs/CR_X --name hand_ctrl --parent world_space --display-label World

Remove one parent of an element, or all of them

Removes one parent by name, or every parent with --all (the element becomes a top-level element). A name that is not a parent is answered with the real parents.

cfa remove_rig_element_parent --asset-path /Game/Rigs/CR_X --name hand_ctrl --parent world_space

Set how much an element follows one of its parents

Sets the weight of one parent of a null or a control. --weight sets location, rotation and scale together; --location, --rotation and --scale set one channel and keep the others. The weight is stored as the initial weight (what the asset keeps) and as the current one. To make an element follow parent B and not parent A, set B to 1 and A to 0.

cfa set_rig_parent_weight --asset-path /Game/Rigs/CR_X --name hand_ctrl --parent world_space --weight 1

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

A control has a list of available spaces: the extra elements the animator can pick in the space menu in Sequencer. --op add puts an element in the list (with --display-label and, if you want, --index), --op remove takes it out, --op move gives it a new place. A parent of the control is in the menu already and cannot be put in this list. The reply gives the list as the asset now holds it.

cfa edit_rig_control_spaces --asset-path /Game/Rigs/CR_X --name hand_ctrl --op add --space head --display-label Head

Copy hierarchy elements

Copies the named elements with their settings, shapes and transforms (the editor's Duplicate). Each copy gets the same parent and a new unique name. The reply pairs each copy with its source.

cfa duplicate_rig_elements --asset-path /Game/Rigs/CR_X --names hand_l_ctrl,hand_l_offset

Make a mirrored copy of hierarchy elements

Makes a copy of each named element on the other side (the editor's Mirror): the transform, and for a control its offset, limits and shape, are mirrored across --mirror-axis. --search and --replace rename the copies (for example _l to _r, case sensitive). The sources stay as they are. The reply pairs each copy with its source.

cfa mirror_rig_elements --asset-path /Game/Rigs/CR_X --names hand_l_ctrl --search _l --replace _r

Move an element to a new place among its siblings

Sets the place of an element among the elements that have the same parent (or among the top-level elements). 0 is first; a number past the end means last. The reply gives the new place, the old place and the number of siblings.

cfa reorder_rig_element --asset-path /Game/Rigs/CR_X --name hand_ctrl --index 0

Write one metadata entry of a hierarchy element

Metadata is named data stored on an element and read in the graph with the Get Metadata nodes. The type is one of Bool, Float, Int32, Name, Vector, Rotator, Quat, Transform, LinearColor, RigElementKey, or any of them with Array at the end. --value has the JSON shape of the type: true, 1.5, "a_name", {"x":0,"y":0,"z":0}, {"Type":"Bone","Name":"hand_l"}, or a list for an Array type. The element's TAGS are the entry named Tags of type NameArray. A value that does not fit the type is refused and nothing is written. Read the entries back with get_rig_element.

cfa set_rig_element_metadata --asset-path /Game/Rigs/CR_X --name hand_l --type bone --metadata-name Side --metadata-type Name --value '"left"'

Remove metadata of a hierarchy element

Removes one metadata entry by name, or every entry with --all. A name the element does not have is answered with the names it has.

cfa remove_rig_element_metadata --asset-path /Game/Rigs/CR_X --name hand_l --type bone --metadata-name Side

Create a new rig from an export_control_rig file

The other half of export_control_rig. Creates a NEW Control Rig and rebuilds it from the export file in the engine's own order: preview mesh, hierarchy (bones, nulls, controls with settings, shapes, limits and values, curves, sockets), member variables with their defaults, the function library, every top-level graph, then for a module its connectors and module settings, and for a modular rig its modules, connections, config values and bindings. If one stage fails the error names the stage and says if the half-made asset was removed or stays (then delete it with delete_asset). The file must come from the current export_control_rig (it holds the graph documents).

cfa import_control_rig --asset-path /Game/Rigs/CR_Copy --file-path "C:/Project/Saved/CodeFizzEditorAgent/Exports/CR_X_20260101_120000/CR_X.controlrig.json"

Export a complete Control Rig to JSON

Writes a complete JSON description of a Control Rig to Saved/CodeFizzEditorAgent/Exports/<name>_<stamp>/<name>.controlrig.json: every graph (models, functions, collapse sub-graphs) with full nodes/pins/defaults/links, the function library, local + blueprint variables, the compiled execution stack (VM event entries in order), the curve container, and the full hierarchy — bones/nulls/curves/sockets/connectors plus controls with reflection-complete settings, offset and shape transforms (initial + current), and initial/current/minimum/maximum values. Returns a compact summary; pass --inline to also get the document in the response.

cfa export_control_rig --asset-path /Game/Rigs/CR_X