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

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

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 --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"]}]'

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"

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