UI

53 tools. Back to the index.

add_list_view

Additive.

Construct a UListView under the widget BP root and add it to the tree.

Parameter	Type	Required	Description
widget_blueprint_name	string	yes	/Game path of the Widget Blueprint
list_view_name	string	yes	FName of the new UListView widget
entry_widget_class	string	no	Optional entry widget class (asset or /Script path)

Returns: { widget_blueprint_name, list_view_name, list_view_class, already_existed, entry_widget_class, widget_added }

add_tile_view

Additive.

Construct a UTileView under the widget BP root and add it to the tree.

Parameter	Type	Required	Description
widget_blueprint_name	string	yes	/Game path of the Widget Blueprint
list_view_name	string	yes	FName of the new UTileView widget
entry_widget_class	string	no	Optional entry widget class

Returns: { widget_blueprint_name, list_view_name, list_view_class, already_existed, entry_widget_class, widget_added }

add_tree_view

Additive.

Construct a UTreeView under the widget BP root (or a named parent panel widget) and add it to the tree. HONEST SCOPE: authoring only, same posture as add_list_view/add_tile_view -- constructs the widget + wires EntryWidgetClass. Populating the tree's actual hierarchy (SetTreeItemsSource + the OnGetItemChildren delegate that supplies each node's children) is OUT OF SCOPE: that delegate is a native TSlateDelegates callback, not reflectively assignable -- wire it in the widget BP graph (native C++/BP override) or drive it live in PIE.

Parameter	Type	Required	Description
widget_blueprint_name	string	yes	/Game path of the Widget Blueprint
widget_name	string	yes	FName of the new UTreeView widget
entry_widget_class	string	no	Optional entry widget class (asset or /Script path)
parent_widget_name	string	no	Optional: name of an existing panel widget (UPanelWidget) in the tree to insert the new UTreeView under. Omitted = same root-insertion behavior as add_list_view/add_tile_view (canvas/panel root, else becomes the tree root).

Returns: { widget_blueprint_name, widget_name, tree_view_class, already_existed, entry_widget_class, parent_widget_name?, widget_added, saved, save_error?, note }

add_viewmodel

Additive.

Append a UMVVMViewModelContext to a Widget BP's MVVM authoring state.

Parameter	Type	Required	Description
widget_blueprint_name	string	yes	/Game path of the Widget Blueprint asset (string)
view_model_class	string	yes	View model class: asset path (/Game/...) or /Script/<Module>.<ClassName>
context_name	string	yes	FName identifying this context (idempotency key)
creation_type	string	no	Optional (default "CreateInstance"): one of "CreateInstance" | "PropertyPath" | "GlobalViewModelCollection" | "Manual" (EMVVMBlueprintViewModelContextCreationType).
source_property_path	string	no	Optional: only used when creation_type="PropertyPath" (required in that case). Sets FMVVMBlueprintViewModelContext::ViewModelPropertyPath.
global_identifier	string	no	Optional: only used when creation_type="GlobalViewModelCollection" (required in that case). Sets FMVVMBlueprintViewModelContext::GlobalViewModelIdentifier.

Returns: { widget_blueprint_name, view_model_class, context_name, creation_type, source_property_path?, global_identifier?, already_existed, view_model_count, has_mvvm_extension }

add_widget_animation

Additive.

Add a UWidgetAnimation (with an inner UMovieScene) to a Widget Blueprint. Mirrors the editor's "New Animation" flow: constructs a UWidgetAnimation on the blueprint, gives it an inner UMovieScene (20fps, 0..5s range), sets the display label, appends to WidgetBP->Animations, then compiles and saves.

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the Widget Blueprint asset
animation_name	string	yes	name/display label for the new animation

Returns: { widget_bp_path: string, animation_name: string, object_name: string, display_name: string, added: bool, already_existed: bool, has_movie_scene: bool, animation_count: int, saved: bool, save_error: string }

add_widget_animation_keyframe

Additive.

Add a keyframe to an existing widget-animation property track's section (call add_widget_animation_track first). Converts time_seconds to an FFrameNumber via the MovieScene's tick resolution, extends the section's range to cover the key if needed, then adds the key on the matching channel(s) via the requested interpolation (AddLinearKey | AddCubicKey | AddConstantKey for float/color's FMovieSceneFloatChannel(s); bool channels have no interpolation concept and always use UpdateOrAddKey).

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the Widget Blueprint asset
animation_name	string	yes	object name OR display label of the target animation
widget_name	string	yes	name of the animated widget
property_path	string	yes	the SAME property_path used in add_widget_animation_track
time_seconds	number	yes	time (seconds, >= 0) at which to place the key
value	any	no	key value: a number for float, a bool for bool, or a [R,G,B,A] (A optional, defaults 1.0) array for color
interpolation	string	no	Optional "linear" (default) | "cubic" | "constant" (float/color only; ignored for bool)

Returns: { widget_bp_path: string, animation_name: string, widget_name: string, property_path: string, track_type: string, time_seconds: float, key_frame: int, keys_added: int, interpolation: string, saved: bool, save_error: string }

add_widget_animation_track

Additive.

Add (or reuse) a MovieScene property track for a widget's property inside a UWidgetAnimation: finds/creates a UMovieScenePossessable bound to the named widget (+ matching FWidgetAnimationBinding), resolves property_path to a top-level reflected property on the widget's class, and adds the matching typed track (UMovieSceneFloatTrack | UMovieSceneColorTrack | UMovieSceneBoolTrack) with a full-playback-range section. track_type="auto" infers from the property's reflected type (FFloatProperty/FDoubleProperty->float; FLinearColor or FSlateColor struct->color; FBoolProperty->bool). Call add_widget_animation_keyframe afterward to place keys. Single-level property_path only (not dotted sub-paths).

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the Widget Blueprint asset
animation_name	string	yes	object name OR display label of the target animation
widget_name	string	yes	name of the widget (in the SAME WidgetBP's tree) to animate
property_path	string	yes	name of a top-level reflected property on the widget's class (e.g. "RenderOpacity", "ColorAndOpacity")
track_type	string	no	Optional "auto" (default) | "float" | "color" | "bool"

Returns: { widget_bp_path: string, animation_name: string, widget_name: string, property_path: string, track_type: string, possessable_guid: string, binding_reused: bool, track_class: string, track_reused: bool, section_class: string, section_created: bool, saved: bool, save_error: string }

add_widget_extended

Additive.

Add an EXTENDED-palette widget to a Widget Blueprint's tree. Same authoring path as add_widget_to_blueprint but supports a wider set of widget types (resolved via /Script/UMG.<Name>), PLUS arbitrary native widget classes and UserWidget (nested Widget Blueprint) instances.

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the Widget Blueprint asset
widget_type	string	yes	one of TextBlock, Button, Image, VerticalBox, CanvasPanel, ProgressBar, Slider, CheckBox, ComboBoxString, ScrollBox, Border, Overlay, SizeBox, WidgetSwitcher, HorizontalBox, EditableTextBox, Spacer, GridPanel, RichTextBlock, EditableText, MultiLineEditableText, ComboBox, SpinBox, ScaleBox, SafeZone, UniformGridPanel, WrapBox, MenuAnchor (the curated names; see list_widget_types), OR any other native widget class path (e.g. /Script/UMG.Throbber, /Script/UMG.ListView), OR a UserWidget-derived Widget Blueprint to embed as a nested instance, by its /Game asset path (e.g. /Game/UI/WBP_HealthBar) or generated-class path (/Game/UI/WBP_HealthBar.WBP_HealthBar_C)
widget_name	string	yes	unique name for the new widget
parent_name	string	no	Optional name of a panel widget to host the new child; defaults to the root widget.

Returns: { widget_bp_path: string, added_widget_name: string, widget_type: string, widget_class: string, parent_name: string, slot_class: string, added: bool, already_existed: bool, saved: bool, save_error: string }

add_widget_property_binding

Destructive.

Bind a widget PROPERTY to a function of the Widget Blueprint -- the Designer's "Bind" dropdown, headless. The property then recomputes every frame from that function instead of holding a fixed value (a health bar's Percent, a label's Text, a panel's Visibility). TWO RULES, both enforced by the ENGINE'S OWN validator (FDelegateEditorBinding::IsBindingValid, the same code the UMG compiler runs -- this tool does not second-guess it): the property is bindable only if its widget declares a companion delegate named "<Property>Delegate" (Text -> TextDelegate), and the function must have a COMPATIBLE SIGNATURE (same return type, NO parameters) and be PURE (BlueprintPure or const), because it is called while painting. A refusal names which of the two failed and, when the property is not bindable at all, lists the ones that are. Create the function first with add_blueprint_function + set its return type; one property can hold only ONE binding, so re-binding the same property REPLACES it (reported in replaced_existing).

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the Widget Blueprint asset
widget_name	string	yes	Name of the widget in the tree whose property gets bound (must be a direct variable of the UserWidget)
property_name	string	yes	Property to bind, e.g. "Text" on a TextBlock, "Percent" on a ProgressBar, "Visibility" on any widget. Must have a companion "<property_name>Delegate" on the widget's class.
function_name	string	yes	Name of the function ON THIS Widget Blueprint that supplies the value. Must be pure and take no parameters, returning the property's type.
save	boolean	no	Compile + save the Widget Blueprint when done (default true). The compile is what turns the editor binding into the runtime one, so a false here leaves the binding authored but not live.

Returns: { widget_bp_path: string, widget_name: string, property_name: string, function_name: string, bound: bool, valid: bool, replaced_existing: bool, member_guid: string, validation_messages: [string], bindable_properties?: [string], saved: bool, save_error: string }

add_widget_to_blueprint

Additive, idempotent.

Add a widget to the tree of a Widget Blueprint asset as the last child of the panel parent_name (default the root, which must then be a panel), register it as a variable, then compile and save the blueprint; nesting a Widget Blueprint that contains this one is an error. Idempotent by name: a widget already called widget_name with the same class is returned as is (already_existed true), and the blueprint is compiled and saved only when it has unsaved changes; a widget of another class under that name is an error. Refused while PIE runs unless force=true; a failed save is an error. add_widget_extended takes the larger palette of list_widget_types.

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the Widget Blueprint asset
widget_type	string	yes	one of TextBlock, Button, Image, VerticalBox, CanvasPanel (the curated basic names; see list_widget_types), OR any native widget class path (e.g. /Script/UMG.Throbber), OR a UserWidget-derived Widget Blueprint to embed as a nested instance, by its /Game asset path (e.g. /Game/UI/WBP_HealthBar) or generated-class path (/Game/UI/WBP_HealthBar.WBP_HealthBar_C)
widget_name	string	yes	unique name for the new widget
parent_name	string	no	Optional name of a panel widget to host the new child; defaults to the root widget.

Returns: { widget_bp_path: string, added_widget_name: string, widget_type: string, widget_class: string, parent_name: string, slot_class: string, added: bool, already_existed: bool, saved: bool, save_error: string }

apply_widget_style_preset

Destructive.

Apply ONE block of style properties to EVERY widget of a Widget Blueprint that matches a filter, in a single pass with ONE compile + ONE save -- the multi-widget companion to set_widget_property's multi-path form. Selection is target_widgets (explicit names, wins over everything) OR target_class (matched with IsA, so subclasses count) AND/OR name_pattern (wildcard). At least one selector is required: to hit every widget in the tree say so explicitly with name_pattern="*". Every value goes through the same honest applier, so the per-widget report distinguishes what landed from what was ignored; dry_run=true resolves the match and reports it WITHOUT writing, which is the cheap way to check a filter before it touches 40 widgets.

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the Widget Blueprint asset
preset	object	no	Dict of {"<property or dotted path>": <value>} applied to each matched widget, e.g. {"WidgetStyle.Normal.TintColor":"#1B1B1BFF"}. Optional when the source_* params are used; when both are given the inline values WIN, so you can say "the theme, but this one in red". A path that does not exist on a given matched widget lands in that widget's ignored[] instead of failing the whole call.
source_bp_path	string	no	THEME MODE: /Game path of a Widget Blueprint holding a REFERENCE widget to copy the style from, instead of writing the values inline. This is what makes one widget the single source of truth rather than scattering the same colour across 40 calls.
source_widget_name	string	no	Name of the reference widget inside source_bp_path. Required with source_bp_path.
source_property_paths	array	no	Which paths to copy off the reference widget, e.g. ["WidgetStyle.Normal.TintColor","WidgetStyle.NormalPadding"]. A path that does not resolve on the REFERENCE is an error, not a silent skip: an incomplete theme that says nothing is worse than a refusal. Use audit_widget_style with the same reference + paths to find what has drifted before fixing it.
target_class	string	no	Class filter matched with IsA: a curated name (Button, TextBlock), a native class path (/Script/UMG.Button) or a Widget Blueprint asset path. Subclasses match too.
name_pattern	string	no	Wildcard on the widget's name (Btn_*, *_Title, or * for every widget). Combined with target_class as AND.
target_widgets	array	no	Explicit widget names. When present, target_class and name_pattern are IGNORED and only these are touched (reported in selector_used).
dry_run	boolean	no	Resolve the match and report it without writing anything (default false).
save	boolean	no	Compile + save the Widget Blueprint when done (default true; a dry run never saves).

Returns: { widget_bp_path: string, selector_used: string, matched: [string], matched_count: int, dry_run: bool, results: [{widget_name, widget_class, applied, ignored, errors, failed_paths, applied_count, all_applied}], widgets_fully_applied: int, widgets_with_failures: int, saved: bool, save_error: string }

bind_widget_to_viewmodel

Destructive.

Append an FMVVMBlueprintViewBinding to a Widget BP's MVVM authoring state, with a REAL SourcePath/DestinationPath (resolved via reflection and written through UMVVMEditorSubsystem, then re-read to verify the write actually stuck).

Parameter	Type	Required	Description
widget_blueprint_name	string	yes	/Game path of the Widget Blueprint asset
source_path	string	yes	"ViewModel.Property" (exactly one dot): ViewModel = an existing viewmodel context name (added via add_viewmodel), Property = a reflected property on that viewmodel's class. Multi-segment ("A.B.C") is NOT supported.
destination_path	string	yes	"Widget.Property" (exactly one dot): Widget = a widget name in this Widget BP's WidgetTree, Property = a reflected property on that widget's class. Multi-segment is NOT supported.
binding_mode	string	no	optional: "OneWay" (default), "TwoWay", "OneTime", "OneWayToSource"

Returns: { widget_blueprint_name, source_path, destination_path, binding_mode, created, binding_count, binding_id, source_path_verified, destination_path_verified, has_mvvm_extension }

click_pie_widget

Destructive.

Fire a LIVE UMG widget's event in the running PIE session (game thread): resolve a UWidget by name among the active viewport UserWidgets (reusing the read_pie_widgets walk) and BROADCAST its named BlueprintAssignable multicast delegate (default OnClicked). Unlike read_pie_widgets (read-only) this MUTATES runtime state -- it runs the exact bound handlers a real click would, including the client->server RPC path, so equip/inventory/craft UI flows can be driven headless instead of by a human (driving them via call_function bypasses that RPC path and yields false negatives). Errors clearly if no Play-In-Editor session is running or the widget/event is not found.

Parameter	Type	Required	Description
widget_name	string	yes	Required. Name of the target UWidget in the live tree (as reported by read_pie_widgets), e.g. "ConfirmButton". Matches a widget inside an active viewport UserWidget's WidgetTree, or a top-level UserWidget by its own name.
event	string	no	Optional (default "OnClicked"): BlueprintAssignable multicast delegate to fire (e.g. "OnClicked", "OnPressed", "OnReleased").
child_name	string	no	Optional: after resolving widget_name, drill into a descendant widget with this name (the resolved widget's own WidgetTree if it is a UserWidget, else a named child in its subtree) and fire the event on THAT widget instead.
player_index	number	no	Optional (default 0): when set, only consider viewport UserWidgets owned by the local player with this index (single-player PIE resolves globally).
world	string	no	Optional world selector: absent/'pie' (default: PlayWorld, else the first PIE context) | 'server' (the PIE world with authority) | 'client' | 'pie:N' | 'game' (alias of 'pie'). In a 2-player PIE session EVERY client has its OWN widgets, so the default may well read the other player's HUD.

Returns: { success: bool, widget_name, resolved_widget, resolved_class, event, is_bound: bool, fired: bool, player_index, child_name?, world: string, world_name: string|null, world_package: string|null, world_type: string|null, net_mode: string|null, pie_instance: number } -- is_bound is false when the delegate exists but has no bound handlers (broadcast is still a safe no-op).

create_common_ui_stack

Additive.

Set the WidgetTree root to a UCommonActivatableWidgetStack (creating one if absent). root_class, when given, picks which UCommonActivatableWidgetStack subclass gets constructed (e.g. a project-authored BP subclass) -- an unresolvable or non-subclass value does not fail the call, it honestly falls back to the base stack class with a note (see root_class_note in the response).

Parameter	Type	Required	Description
widget_blueprint_name	string	yes	/Game path of the Widget Blueprint
root_class	string	no	Optional. Asset path (/Game/...) or /Script/<Module>.<ClassName> of a UCommonActivatableWidgetStack subclass. Omitted = base UCommonActivatableWidgetStack.

Returns: { widget_blueprint_name, root_class?, already_existed, stack_class, root_class_requested, root_class_resolved, root_class_note?, root_changed, root_widget, root_widget_class }

create_widget

Additive.

Create a runtime UUserWidget instance of a concrete UserWidget class in a running PIE world (the default while PIE runs) or the editor world, owned by that world's first local PlayerController when there is one, and optionally AddToViewport it. Nothing is saved, and an unreferenced widget is garbage-collected. In the editor world add_to_viewport never adds (no PlayerController): read added_to_viewport. A taken name gets a unique variant, reported in widget_name; a class that does not load, is abstract or is not a UserWidget is an error. To change the asset use add_widget_to_blueprint; remove_widget searches the same worlds.

Parameter	Type	Required	Description
widget_class_path	string	yes	Full path to widget class, e.g. '/Game/UI/MyWidget.MyWidget_C'
widget_name	string	yes	Name to assign to the created widget instance (a name another widget already has gets a unique variant, which widget_name in the response reports)
add_to_viewport	boolean	no	If true, AddToViewport the widget (optional, default false). It only ever really adds when the target world has a local PlayerController -- check added_to_viewport in the response, and see target_world for when that is possible at all.
target_world	string	no	Optional: "editor" | "pie" | "server" (the PIE world with authority) | "client" | "pie:N" | "game" (alias of "pie"). Defaults to "pie" when a Play-In-Editor session is running, else "editor". IMPORTANT: "editor" NEVER has a PlayerController, because GEditor's world is not a game world, so add_to_viewport can never really add there -- that is reported honestly (added_to_viewport stays false), never simulated. "pie" resolves the running PIE world and its first local PlayerController, so add_to_viewport there performs a REAL AddToViewport().

Returns: { widget_name: string, widget_class_path: string, widget_class_name: string, target_world: string, added_to_viewport: bool, add_to_viewport_note?: string, widget_valid: bool, world_name: string|null, world_package: string|null, world_type: string|null, net_mode: string|null, pie_instance: number }

create_widget_blueprint

Additive.

Create (and save) a new UWidgetBlueprint asset with a CanvasPanel root.

Parameter	Type	Required	Description
package_path	string	yes	/Game folder to create the asset in (e.g. /Game/UI)
name	string	yes	Asset name (no extension)
parent_class	string	no	Parent UUserWidget subclass (default "UUserWidget").

Returns: { name: string, package_path: string, asset_path: string, parent_class: string, created: bool, already_existed: bool, root_created: bool, root_widget: string, root_widget_class: string, saved: bool, save_error: string }

duplicate_widget

Additive.

Duplicate a widget (DuplicateObject<UWidget> outered to the WidgetTree) and add the clone under a target parent panel, copying the source's slot property values onto the new slot when the slot classes match. Refuses (clear error, no partial/broken result) to duplicate a panel widget that currently has children -- UE's object duplication would leave the clone's slots aliasing the SAME original child widgets rather than deep-copying them (see FDuplicateDataWriter); duplicate leaf widgets, or rebuild the panel's children individually with add_widget_extended. Name collisions on new_name are a clear error (not a silent alias of the pre-existing widget at that name).

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the Widget Blueprint asset
widget_name	string	yes	name of the widget to duplicate (must not be a panel widget with children)
new_name	string	yes	unique name for the duplicate
target_parent_name	string	no	Optional name of the panel widget to host the duplicate; defaults to the source widget's own current parent (sibling placement).

Returns: { widget_bp_path: string, source_widget_name: string, new_widget_name: string, widget_class: string, target_parent_name: string, slot_class: string, slot_class_matched_source: bool, slot_properties_copied: int, duplicated: bool, saved: bool, save_error: string }

get_pie_focused_widget

Read-only.

Report which UMG widget currently has FOCUS in the running PIE session -- the assertion that makes gamepad navigation testable instead of eyeballed. Resolves FSlateApplication's focused SWidget and maps it back to the UMG UWidget that created it, by walking up to the owning SObjectWidget and matching cached widgets: the same route the engine's own navigation component uses, and it has to walk up because the widget holding focus is usually an internal SButton, not the one that maps 1:1 to a UWidget. Pair it with inject_key_input route="slate", the only input path that moves focus at all: press Down, read this, assert. Returns has_focus:false as an honest success (not an error) when nothing is focused -- which is itself the finding when a menu opens with no focus and every navigation key then appears to do nothing.

Parameter	Type	Required	Description
user_index	number	no	Optional Slate user index (default 0). Local co-op players are separate Slate users, so player 2 is user 1.

Returns: { has_focus: bool, slate_widget_type: string, widget_name: string, widget_class: string, owning_user_widget: string, owning_user_widget_class: string, resolved_to_umg: bool, note? } -- resolved_to_umg:false together with has_focus:true means something in Slate holds focus but it is not a UMG widget (the viewport, a native Slate panel); slate_widget_type still names it.

get_widget_animations

Read-only.

List the UWidgetAnimations of a Widget Blueprint asset, each with its object name, display_name and has_movie_scene, plus animation_count and the resolved asset_path. Read-only; add_widget_animation creates one and remove_widget_animation accepts either name.

Parameter	Type	Required	Description
widget_bp_path	string	yes	Asset path of the Widget Blueprint, e.g. "/Game/UI/WBP_MainMenu"; it must exist.

Returns: { widget_bp_path: string, asset_path: string, animations: [{name, display_name, has_movie_scene}], animation_count: int }

get_widget_blueprint_tree

Read-only.

Return a Widget Blueprint's widget tree as nested {name, class, children[]} AND, on request, the actual VALUES of its widgets and slots -- which is what makes verifying a style a cheap read instead of a PIE session. Off by default (a bare tree is what name-only callers want); three switches turn it on: property_paths reads exact dotted paths ("WidgetStyle.Normal.TintColor") on every node whether or not they still hold the default -- this is the oracle that closes a set_widget_property; include_properties reports only what DIFFERS from each widget's archetype, i.e. what this Widget Blueprint actually changed, instead of the ~120 inherited properties nobody reads; include_slot adds each widget's UPanelSlot class plus its own non-default values (position, anchors, padding, row/column). Values come back as TYPED JSON, not UE export-text. widget_name dumps one subtree instead of the whole asset.

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the Widget Blueprint asset
widget_name	string	no	Optional: dump only this widget and its descendants instead of the whole tree.
property_paths	array	no	Optional list of property names or dotted paths read on EVERY node, emitted under "properties" even when the value is still the default. A path that does not exist on a given widget is listed in that node's "unresolved_property_paths" (normal: a WidgetStyle has no meaning on a TextBlock), never silently dropped.
include_properties	boolean	no	Emit each widget's editable properties that DIFFER from its archetype, under "non_default_properties" (default false).
include_slot	boolean	no	Emit each widget's UPanelSlot class and its non-default slot values under "slot" (default false).
include_navigation	boolean	no	Emit each widget's six gamepad/keyboard navigation directions under "navigation" (default false). A widget with no authored navigation reports all six as Escape with has_authored_navigation:false -- which is what it will actually do in game, rather than an empty object the caller has to interpret. Author them with set_widget_navigation.
max_depth	number	no	Optional recursion limit (-1 = unlimited, the default). A panel cut off by the limit reports "children_omitted" instead of passing for a leaf.

Returns: { widget_bp_path: string, asset_path: string, widget_count: int, root_widget: string, dumped_root: string, include_properties: bool, include_slot: bool, include_navigation: bool, property_paths: [string], tree: {name, class, properties?, unresolved_property_paths?, non_default_properties?, slot?, children: [...], children_omitted?} }

get_widget_hierarchy

Read-only.

Retrieve the widget hierarchy tree including parent, children, and nested structure information.

Parameter	Type	Required	Description
widget_name	string	yes	Name of the widget to query

Returns: { widget_name: string, hierarchy: { name: string, class: string, depth: number, valid: bool, enabled: bool, visibility: string, size?: { width, height }, position?: { x, y, z }, children: [object], child_count: number }, widget_valid: bool }

get_widget_properties

Read-only.

Retrieve detailed properties and state information for a widget by name.

Parameter	Type	Required	Description
widget_name	string	yes	Name of the widget to query

Returns: { widget_name: string, widget_class: string, widget_valid: bool, widget_visible: bool, visibility: string, size?: { width: number, height: number }, position?: { x: number, y: number, z: number }, rotation?: { pitch: number, yaw: number, roll: number }, scale?: { x: number, y: number, z: number }, parent_widget?: string, parent_class?: string, child_count: number, is_enabled: bool, has_focus: bool }

list_level_widget_components

Read-only.

CALL THIS FIRST to discover valid widget_name values instead of guessing: it enumerates ALL UWidgetComponents on ALL actors of the current EDITOR level, which is the EXACT population that get_widget_properties / set_widget_visibility / get_widget_hierarchy search by widget_name (remove_widget searches it too). It reads GEditor's world and never a running PIE session (use read_pie_widgets for that), and it lists every widget component on an actor, not just the first. WARNING: THIS POPULATION IS NOT WIDGET BLUEPRINTS, and that is the trap the name does not warn you about: these are world-space UWidgetComponents hosted on actors. To author the CONTENT of a Widget Blueprint asset -- its tree, styles or layout -- you want get_widget_blueprint_tree / set_widget_property / set_widget_slot_properties instead. In particular ANCHORS live on a UCanvasPanelSlot inside a Widget Blueprint's tree and have no meaning at all on a level UWidgetComponent: set them with set_widget_slot_properties(widget_bp_path, widget_name, anchors=[min_x,min_y,max_x,max_y]).

Parameter	Type	Required	Description
actor_name_filter	string	no	Optional substring filter on the owning actor's name (Contains match)

Returns: { components: [{ actor_name: string, widget_component_name: string, widget_name: string|null, widget_class: string|null }], component_count: number, actor_name_filter: string|null }

list_widget_property_bindings

Read-only.

List the UMG PROPERTY BINDINGS of a Widget Blueprint -- the "Bind" dropdown next to a property in the Designer's details panel, which makes that property recompute every frame by calling a function instead of holding a fixed value. These live in UWidgetBlueprint::Bindings, NOT in the widget tree and NOT in the event graph, so no other reader sees them; and UWidgetBlueprint::Bindings is NOT exposed to Python either (get_editor_property("bindings") throws), so this is the only headless way to read them. Each entry is re-validated live with the engine's own FDelegateEditorBinding::IsBindingValid, so a binding whose function was renamed or made non-pure comes back valid:false WITH the compiler's reason -- that is the difference between "there is a binding" and "there is a binding that works".

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the Widget Blueprint asset
include_bindable_properties	boolean	no	Also list, per widget in the tree, which properties ACCEPT a binding at all (default false). A property is bindable only if its widget declares a companion delegate named "<Property>Delegate" -- this saves guessing.

Returns: { widget_bp_path: string, binding_count: int, bindings: [{ widget_name, property_name, function_name, kind, member_guid, source_property, valid, validation_messages: [string] }], bindable_properties?: {widget_name: [string]} }

list_widget_types

Read-only.

List the CURATED widget_type names accepted by add_widget_to_blueprint (family="basic") / add_widget_extended (family="extended", the default -- a strict superset of basic), with each entry's resolved /Script/UMG.<Name> class path and whether LoadObject actually resolves it in this build (should always be true; reported for honesty rather than assumed). This list is a convenience shortlist, NOT the full set of accepted values -- both tools also accept any native widget class path (/Script/Module.ClassName) and any UserWidget-derived Widget Blueprint's /Game asset path (embeds a nested instance); see custom_class_note in the response.

Parameter	Type	Required	Description
family	string	no	Optional "basic" | "extended" (default "extended")

Returns: { family: string, widget_types: [{ widget_type: string, class_path: string, resolvable: bool }], count: int, custom_class_note: string }

play_widget_animation

Destructive.

Play a widget animation. REAL playback (UUserWidget::PlayAnimation) when a live PIE instance of this WidgetBP is found in the viewport's active UUserWidgets; falls back to an honest headless gate (played:false, headless:true, requires_pie:true) when no PIE session is running or no live instance is found.

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the Widget Blueprint asset
animation_name	string	yes	object name OR display label of the animation to play
start_at_time	number	no	Optional float seconds to start playback at (default 0).
num_loops	number	no	Optional int number of loops (default 1).
play_mode	string	no	Optional Forward | Reverse | PingPong (default Forward).
playback_speed	number	no	Optional float speed multiplier (default 1.0).
restore_state	boolean	no	Optional bool: restore the pre-animation state on finish (default false).
world	string	no	Optional world selector: absent/'pie' (default: PlayWorld, else the first PIE context) | 'server' (the PIE world with authority) | 'client' | 'pie:N' | 'game' (alias of 'pie'). In a 2-player PIE session EVERY client has its OWN widgets, so the default may well read the other player's HUD.

Returns: { widget_bp_path: string, animation_name: string, animation_exists: bool, played: bool, headless: bool, requires_pie: bool, note: string, saved: bool, live_widget_name?: string, live_animation_name?: string, world: string, world_name: string|null, world_package: string|null, world_type: string|null, net_mode: string|null, pie_instance: number }

pop_common_ui_widget

Destructive.

Pop the ACTIVE screen off a live CommonUI stack, or clear the whole stack -- the inverse of push_common_ui_widget and the other half of driving a menu state machine headless (open, go deeper, come back, assert what is on top). WARNING: RUNTIME ONLY, same as the push: with no PIE session there is nothing on any stack. Popping an empty stack is an honest success with popped:false, not an error.

Parameter	Type	Required	Description
stack_widget_name	string	yes	Name of the live activatable container in the running session.
clear_all	boolean	no	Remove EVERY widget instead of just the active one (default false).
player_index	number	no	Optional local player index whose viewport widgets are searched (default 0).
world	string	no	Optional world selector: absent/'pie' | 'server' | 'client' | 'pie:N'.

Returns: { stack_widget_name, popped: bool, popped_widget: string, cleared_all: bool, widget_count: int, active_widget: string } -- widget_count and active_widget are read AFTER the operation; popped:false with widget_count:0 means the stack was already empty.

push_common_ui_widget

Additive.

Push a screen onto a LIVE CommonUI activatable stack in the running PIE session -- the operation that lets a menu state machine be driven to a specific state and then asserted. create_common_ui_stack only puts the stack in place; its contents are populated at runtime with AddWidget, which this calls headless, so "open the pause menu, then the options page, now check the back button" is reproducible. WARNING: RUNTIME ONLY: the container's widget list and its widget pool are Transient, so with no PIE session there is genuinely nothing to push onto and this says so rather than pretending. The pushed widget is activated by the stack itself; read the result with get_common_ui_stack or read_pie_widgets, and move focus into it with set_pie_widget_focus.

Parameter	Type	Required	Description
stack_widget_name	string	yes	Name of the live UCommonActivatableWidgetStack (or any activatable container) in the running session. Resolved like click_pie_widget, nested Widget Blueprints included.
widget_class	string	yes	The UCommonActivatableWidget class to push: a /Game Widget Blueprint path, its generated-class path, or a native class path.
player_index	number	no	Optional local player index whose viewport widgets are searched (default 0).
world	string	no	Optional world selector: absent/'pie' | 'server' | 'client' | 'pie:N'.

Returns: { stack_widget_name, pushed_class, pushed_widget: string, widget_count: int, active_widget: string } -- widget_count and active_widget are read off the stack AFTER the push, so they are evidence rather than an echo.

read_pie_widgets

Read-only.

Read LIVE UMG from the running PIE session (game thread): enumerate the active UUserWidgets added to the viewport and walk each widget tree, emitting name/class plus optional visibility/hover/text/value/geometry as a parent/child tree. Reads only game-thread-safe widget-tree state (never the render thread). Errors clearly if no Play-In-Editor session is running. DESCENDS INTO NESTED WIDGET BLUEPRINTS: an AAA screen is a Widget Blueprint composed of Widget Blueprints, so everything interesting sits one level below the first. Cycles are handled with a visited set plus max_depth, and a subtree that IS cut says so in subtree_omitted instead of looking like a leaf. Rich text is read too (URichTextBlock does not derive from UTextBlock). Not implemented: include_bindings, which is accepted and flagged in bindings_note.

Parameter	Type	Required	Description
root_filter	string	no	Optional case-sensitive substring; only top-level UserWidgets whose object name contains it are returned.
include_text	boolean	no	Optional bool (default true): include UTextBlock text.
include_visibility	boolean	no	Optional bool (default true): include visibility, is_hovered and has_keyboard_focus per widget. has_keyboard_focus is what tells you whether a navigation key will do anything at all: with nothing focused every key is a no-op, which reads exactly like broken navigation.
include_bindings	boolean	no	Optional bool (default false): NOT implemented in this subset; sets bindings_note when true.
include_values	boolean	no	Optional bool (default false): include is_enabled + widget-type-specific value (Slider.value / ProgressBar.percent / CheckBox.is_checked / ComboBoxString.selected_option).
include_geometry	boolean	no	Optional bool (default false): include GetCachedGeometry()-derived absolute_position/absolute_size, render_opacity, and render_transform.
max_depth	number	no	Optional recursion limit (-1 = unlimited, the default). Counts every level including the descent into a nested Widget Blueprint's own tree. A subtree cut by the limit reports subtree_omitted rather than passing for a leaf.
world	string	no	Optional world selector: absent/'pie' (default: PlayWorld, else the first PIE context) | 'server' (the PIE world with authority) | 'client' | 'pie:N' | 'game' (alias of 'pie'). In a 2-player PIE session EVERY client has its OWN widgets, so the default may well read the other player's HUD.

Returns: { widgets: [{ widget_name, class, is_any_animation_playing, visibility?, is_hovered?, children: [{ widget_name, class, visibility?, is_hovered?, text?, is_enabled?, value?, percent?, is_checked?, selected_option?, geometry?, children: [...] }] }], widget_count: int, scanned_viewport_widgets: int, include_text: bool, include_visibility: bool, include_bindings: bool, include_values: bool, include_geometry: bool, bindings_note?: string, world: string, world_name: string|null, world_package: string|null, world_type: string|null, net_mode: string|null, pie_instance: number }

remove_viewmodel

Destructive, idempotent.

Remove a UMVVMViewModelContext (by context name) from a Widget BP's MVVM authoring state. Inverse of add_viewmodel; idempotent (already-absent is an honest success).

Parameter	Type	Required	Description
widget_blueprint_name	string	yes	/Game path of the Widget Blueprint asset (string)
context_name	string	yes	FName identifying the context to remove (idempotency key)

Returns: { widget_blueprint_name, context_name, already_existed, removed, view_model_count, has_mvvm_extension, saved, save_error? }

remove_widget

Destructive.

Detach a runtime UserWidget, found by object name, from the viewport or panel holding it with RemoveFromParent. It searches the worlds create_widget uses: the one target_world names, or without it the running PIE world first and then the editor world; in each, the first widget hosted by a level UWidgetComponent, then any other UserWidget of that world. The object is not deleted, no asset changes and there is no undo. was_in_viewport and had_parent are measured before the call: both false means nothing was detached, as for a component-hosted widget. It never edits a Widget Blueprint asset.

Parameter	Type	Required	Description
widget_name	string	yes	Object name of the runtime widget to detach (case-insensitive), as list_level_widget_components or create_widget report it
target_world	string	no	Optional world to search, with the values create_widget takes (editor, pie, server, client, pie:N, game). Omitted: the PIE world while PIE runs, then the editor world.

Returns: { widget_name: string, target_world: string, was_in_viewport: bool, had_parent: bool, world_name: string|null, world_package: string|null, world_type: string|null, net_mode: string|null, pie_instance: number }

remove_widget_animation

Destructive.

Remove a UWidgetAnimation from a Widget Blueprint. Inverse of add_widget_animation: finds the animation by object name or display label, removes it from WidgetBP->Animations, unregisters it as a blueprint variable (OnVariableRemoved), then compiles and saves. If no such animation exists it is an honest no-op (removed:false, already_existed:false, no save).

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the Widget Blueprint asset
animation_name	string	yes	object name OR display label of the animation to remove

Returns: { widget_bp_path: string, animation_name: string, object_name: string, removed: bool, already_existed: bool, animation_count: int, saved: bool, save_error: string }

remove_widget_property_binding

Destructive, idempotent.

Remove a UMG property binding (the Designer's "Bind" dropdown set back to none), so the property goes back to holding its authored fixed value. Inverse of add_widget_property_binding and idempotent: a property that was not bound is an honest success with removed:false, never an error.

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the Widget Blueprint asset
widget_name	string	yes	Name of the widget whose binding to drop
property_name	string	yes	The bound property, e.g. "Text". Matching is on widget_name + property_name, which is exactly how UMG identifies a binding (one binding per property, max).
save	boolean	no	Compile + save the Widget Blueprint when done (default true).

Returns: { widget_bp_path: string, widget_name: string, property_name: string, removed: bool, already_absent: bool, remaining_binding_count: int, saved: bool, save_error: string }

rename_widget

Destructive.

Rename a widget in a Widget Blueprint's tree (WidgetTree membership, blueprint variable map, bindings, and animation bindings all updated in one call -- the same path as the Designer's F2).

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the Widget Blueprint asset
old_name	string	yes	current name of the widget in the tree
new_name	string	yes	desired new name

Returns: { widget_bp_path: string, old_name: string, new_name: string, resolved_name: string, renamed: bool, saved: bool, save_error: string }

render_widget_preview

Destructive.

Render a Widget Blueprint to a PNG on disk WITHOUT running the game: builds the widget with the editor's own designer flags, draws it through FWidgetRenderer into a render target and writes the file. This is what turns "does this style look right?" from a PIE session someone has to watch into a static read plus one image to LOOK at. HONEST SCOPE: it is a DESIGN preview, the same thing the UMG Designer shows -- not the live HUD. Anything that only exists while the game runs (text filled in NativeConstruct, property bindings, ViewModel data, anything behind an IsDesignTime() guard) renders at its default/empty value. Use read_pie_widgets or capture_pie_screenshot for the running session. Returns rendered:false with a reason (never a blank image) when the editor has no RHI (-nullrhi/headless), because FWidgetRenderer cannot draw there.

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the Widget Blueprint asset to render
output_path	string	no	Optional output file. A bare name lands under <ProjectSaved>/MCP/WidgetPreviews/, an absolute path is used verbatim, and .png is appended when missing. Defaults to the asset's name.
width	number	no	Optional render width in pixels. Omit BOTH width and height to render at the widget's own desired size (a Slate prepass measures it).
height	number	no	Optional render height in pixels. Omit BOTH width and height to render at the widget's own desired size.
scale	number	no	Optional draw scale applied by the renderer (default 1.0), the equivalent of DPI scaling in the Designer.
opaque_background	boolean	no	Optional (default false). Force every pixel's alpha to 255 so the PNG is not transparent where the widget did not paint -- the same trick capture_viewport uses. Leave false to keep real transparency.

Returns: { widget_bp_path: string, rendered: bool, file_path: string, width: int, height: int, scale: number, drew_at_desired_size: bool, byte_size: int, designer_flags: string, preview_note: string, error?: string }

reorder_widget_child

Destructive.

Change a widget's index among its parent panel's children via UPanelWidget::ShiftChild (clamps new_index internally; safe with any int). For a CanvasPanel parent, visual stacking is governed by each child's CanvasPanelSlot ZOrder (set_widget_slot_properties z_order), NOT child index -- the index shift is still applied and reported honestly, with a note.

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the Widget Blueprint asset
widget_name	string	yes	name of the widget to reorder
new_index	number	yes	desired index among its parent's children (clamped to [0, child_count])

Returns: { widget_bp_path: string, widget_name: string, parent_name: string, old_index: int, requested_index: int, resolved_index: int, child_count: int, reordered: bool, parent_is_canvas_panel: bool, note?: string, saved: bool, save_error: string }

reparent_widget

Destructive.

Move a widget to a new parent panel (optionally at a specific child index), via FWidgetBlueprintOperationUtils::MoveWidget -- the same primitive backing the Designer's drag-and-drop reparent. Validates the new parent is a panel widget and refuses to create a cycle. Optional slot_properties are applied to the widget's NEW slot afterward via the shared reflection setter (e.g. {"Row":1,"Column":2} for a GridSlot). THIS IS ALSO HOW YOU FILL A NAMED SLOT: a UNamedSlot is a UContentWidget (hence a panel), so add one with add_widget_extended widget_type="NamedSlot" and reparent the content into it -- there is no separate SetContentForSlot tool and none is needed (it answers reparented:true, new_slot_class:PanelSlot).

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the Widget Blueprint asset
widget_name	string	yes	name of the widget to move
new_parent_name	string	yes	name of the panel widget to become the new parent
target_index	number	no	Optional int child index to insert at (default: append at the end)
slot_properties	object	no	Optional object of {PropertyName: value} applied to the resulting slot via reflection (best-effort; per-field errors are reported, not fatal)

Returns: { widget_bp_path: string, widget_name: string, old_parent_name: string, new_parent_name: string, new_slot_class: string, resolved_child_index: int, reparented: bool, slot_properties_applied: int, slot_property_errors?: [string], saved: bool, save_error: string }

scaffold_menu_screen

Additive.

Build a styled menu screen: create or reuse the Widget Blueprint at package_path/name with a centred panel, optional title and one button per entry bound to an event-graph OnClicked handler, then compile and save. Re-runs reuse widgets and bindings. Returns contrast_ratio_normal_text; the default colors pass audit_widget_accessibility. Layout is not measured (long labels can clip) and text is inline, not String Table.

Parameter	Type	Required	Description
package_path	string	yes	/Game folder for the new Widget Blueprint (e.g. /Game/MyGame/UI).
name	string	yes	Asset name, e.g. WBP_OptionsMenu.
entries	array	yes	REQUIRED, the buttons top to bottom. Each item is either a plain string (the label) or an object {label, handler_name?}. handler_name names the generated event-graph function; omitted, it becomes On<Label>Clicked. Order is preserved.
title	string	no	Optional heading text above the buttons. Omitted or empty = no title widget at all (not an empty one).
parent_class	string	no	Parent UUserWidget subclass (default "UUserWidget"). Pass a CommonUI activatable class here to scaffold a screen for a CommonUI stack.
background	boolean	no	Draw the background panel (default true). false leaves the buttons floating on nothing -- which is what makes contrast unjudgeable, so it also drops contrast_ratio_normal_text from the payload.
panel_color	string	no	Background panel colour. "#RRGGBBAA", [r,g,b,a] (LINEAR 0..1) or {R,G,B,A}. Default is a near-black panel.
button_color	string	no	Button resting colour, same formats. If you override this, you own the contrast: the returned ratio tells you what you got.
text_color	string	no	Label colour for title and buttons, same formats. Default white.
title_font_size	number	no	Title text size in Slate font points, truncated to a whole number; default 36. Unused when title is empty.
button_font_size	number	no	Button label size in Slate font points, truncated to a whole number; default 20. It also sets the contrast floor checked (3:1 at 18 or more, else 4.5:1); under 12 is what audit_widget_accessibility flags as small_text.
panel_width	number	no	Panel width in pixels (default 480).
panel_height	number	no	Panel height in pixels (default 560).
bind_events	boolean	no	Wire each button's OnClicked to a handler in the event graph (default true). false builds the visuals only.
theme_source_bp	string	no	Optional /Game path of a Widget Blueprint holding a reference Button whose style is copied onto every generated button INSTEAD of the built-in defaults (same idea as apply_widget_style_preset's theme mode: one widget is the single source of truth).
theme_source_widget	string	no	Name of the reference Button inside theme_source_bp. Required with it.
save	boolean	no	Compile + save when done (default true).

Returns: { widget_bp_path, asset_path, created, already_existed, root_widget, panel_widget, box_widget, title_widget, entries: [{label, button_widget, text_widget, handler_name, bound, already_bound, error}], entry_count, buttons_bound, colors: {panel, button, text}, contrast_ratio_normal_text, contrast_required, contrast_passes, contrast_note, theme_source, compiled, saved, save_error }

set_box_slot_properties

Destructive, idempotent.

Configure a widget's box-family slot layout (alignment/padding/size). Applies when the widget is parented under a HorizontalBox/VerticalBox/Overlay/Border/SizeBox/ScrollBox; dispatches by the concrete slot type. Size only applies to Horizontal/Vertical/ScrollBox slots -- on the others it is returned as an honest note. For a CanvasPanel child use set_widget_slot_properties; for a GridPanel child use set_grid_slot_properties.

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the Widget Blueprint asset
widget_name	string	yes	name of the child widget whose box slot to edit
horizontal_alignment	string	no	Optional alignment: Fill | Left | Center | Right
vertical_alignment	string	no	Optional alignment: Fill | Top | Center | Bottom
padding	array	no	Optional [Left, Top, Right, Bottom] floats (also accepts [uniform] or [horizontal, vertical]).
size_rule	string	no	Optional Fill | Auto (Horizontal/Vertical/ScrollBox slots only).
size_value	number	no	Optional float fill weight (used with size_rule = Fill; default 1.0).

Returns: { widget_bp_path: string, widget_name: string, slot_type: string, settings_applied: object, applied_count: int, notes: [string], saved: bool, save_error: string }

set_grid_slot_properties

Destructive, idempotent.

Configure a widget's UGridSlot layout (row/column/spans/alignment/padding/layer/nudge). Applies when the widget is parented under a GridPanel (create one with add_widget_extended widget_type="GridPanel"). Setting the same values again is idempotent.

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the Widget Blueprint asset
widget_name	string	yes	name of the child widget whose grid slot to edit
row	number	no	Optional int row index of the cell
column	number	no	Optional int column index of the cell
row_span	number	no	Optional int number of rows this slot spans
column_span	number	no	Optional int number of columns this slot spans
horizontal_alignment	string	no	Optional alignment: Fill | Left | Center | Right
vertical_alignment	string	no	Optional alignment: Fill | Top | Center | Bottom
padding	array	no	Optional [Left, Top, Right, Bottom] floats.
layer	number	no	Optional int draw/hit-test layer offset (positive draws on top).
nudge	array	no	Optional [X, Y] content offset.

Returns: { widget_bp_path: string, widget_name: string, slot_type: string, settings_applied: object, applied_count: int, saved: bool, save_error: string }

set_named_slot_content

Destructive, idempotent.

Put a widget into a NAMED SLOT of a NESTED Widget Blueprint instance -- the "template screen with holes" pattern. reparent_widget already fills a UNamedSlot that belongs to your own tree (it is a UContentWidget, so it is just a panel), but the slot of an embedded instance is not a panel in your tree at all: it is an entry in that instance's NamedSlotBindings, and no other tool writes it. WARNING: the engine's SetContentForSlot returns nothing and SILENTLY DROPS the binding when the slot name does not exist, so this re-reads it with GetContentForSlot afterwards and reports the RE-READ, never the call. List what a given instance offers with available_slots in the response, or pass no slot_name at all to just enumerate them.

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the OUTER Widget Blueprint (the one that owns both the nested instance and the content).
host_widget_name	string	yes	Name of the nested Widget Blueprint instance in the outer tree -- the widget that OWNS the slot.
slot_name	string	yes	Name of the named slot to fill. Omit to only enumerate what the host offers (nothing is written, available_slots is still returned).
content_widget_name	string	no	Name of the widget in the OUTER tree to place in the slot. It must already exist there (add_widget_extended creates it). Omit together with clear=true to empty the slot.
clear	boolean	no	Empty the slot instead of filling it (default false). Mutually exclusive with content_widget_name.
save	boolean	no	Compile + save the Widget Blueprint when done (default true).

Returns: { widget_bp_path, host_widget_name, host_class, available_slots: [string], slot_name, content_widget_name, filled: bool, verified_content: string, saved, save_error } -- verified_content is what GetContentForSlot returns AFTER the write: empty when the engine dropped the binding, which is the only way to tell that from a success.

set_pie_list_view_items

Destructive, idempotent.

Populate a LIVE UListView/UTileView in the running PIE session. Resolves widget_name (optionally drilling into child_name) among the active viewport UserWidgets using the same walk click_pie_widget uses, resolves each entry in items[] to a UObject* (an actor name/label in the PIE world, else a /Game asset path via FSoftObjectPath::TryLoad), then calls SetListItems (or AddItems when append=true). Companion to add_list_view/add_tile_view, which only construct an EMPTY view.

Parameter	Type	Required	Description
widget_name	string	yes	Required. Name of the target UListView/UTileView in the live tree (as reported by read_pie_widgets), resolved the same way click_pie_widget resolves widget_name.
items	array	yes	Required array of strings. Each entry is either an actor name/label to resolve in the PIE world, or a /Game asset path to load via FSoftObjectPath::TryLoad.
child_name	string	no	Optional: after resolving widget_name, drill into a descendant widget with this name and populate THAT widget instead.
player_index	number	no	Optional (default 0): restrict widget resolution to viewport UserWidgets owned by this local player index (single-player PIE resolves globally).
append	boolean	no	Optional (default false). false = SetListItems (replaces the current item list). true = AddItems (appends).
refresh	boolean	no	Optional (default true). Accepted for API symmetry: UListView::SetListItems/AddItems call UListViewBase::RequestRefresh() UNCONDITIONALLY, so refresh=false cannot honestly suppress it -- see refresh_note in the response rather than a silent no-op.
world	string	no	Optional world selector: absent/'pie' (default) | 'server' | 'client' | 'pie:N' | 'game' (alias of 'pie'). In a 2-player PIE session each client owns its own widgets.

Returns: { success, widget_name, resolved_widget, resolved_class, child_name?, player_index, requested_items, resolved_count, unresolved_items[], append, refresh, refresh_note, item_count_after, world: string, world_name: string|null, world_package: string|null, world_type: string|null, net_mode: string|null, pie_instance: number }

set_pie_widget_focus

Destructive, idempotent.

Give keyboard/gamepad FOCUS to a live UMG widget in the running PIE session, so navigation has somewhere to start from. Menus routinely open with nothing focused, and then every navigation key does nothing -- which reads exactly like broken navigation and sends you to debug rules that were fine. Resolves the widget the same way click_pie_widget does (widget_name, optionally drilling in with child_name, nested Widget Blueprints included), then calls UWidget::SetKeyboardFocus. Verify with get_pie_focused_widget and drive from there with inject_key_input route="slate".

Parameter	Type	Required	Description
widget_name	string	yes	Name of a live UserWidget added to the viewport, or of a widget inside one.
child_name	string	no	Optional: after resolving widget_name, drill into this descendant by name (nested Widget Blueprints included).
player_index	number	no	Optional local player index whose viewport widgets are searched (default 0).
world	string	no	Optional world selector, same rules as read_pie_widgets: absent/'pie' | 'server' | 'client' | 'pie:N'.

Returns: { focused: bool, widget_name: string, widget_class: string, has_keyboard_focus: bool } -- has_keyboard_focus is RE-READ off the widget after the call, so it is evidence and not an echo: false means Slate refused the focus, and the usual cause is that the widget is not focusable (check IsFocusable and its Visibility -- a HitTestInvisible widget cannot take focus).

set_pie_widget_value

Destructive, idempotent.

Set a LIVE PIE input widget's REAL value (companion to click_pie_widget, which only broadcasts a delegate with zero-init params and never touches Slider/CheckBox/EditableTextBox/ComboBoxString state first). Resolves the widget exactly like click_pie_widget (same widget_name/child_name/player_index rules), then calls the widget's real setter: USlider::SetValue, UCheckBox::SetIsChecked, UEditableTextBox::SetText/UEditableText::SetText, UComboBoxString::SetSelectedOption, or UProgressBar::SetPercent. fire_event genuinely gates a manual OnCheckStateChanged/OnTextChanged(+OnTextCommitted) broadcast for CheckBox/EditableText(Box); Slider/ComboBoxString auto-broadcast on the engine side whenever the value actually changes (fire_event cannot suppress that -- see event_fired_note); ProgressBar has no change event at all. Errors clearly if no PIE session is running, the widget is not found, or its class is not one of the supported input types.

Parameter	Type	Required	Description
widget_name	string	yes	Required. Name of the target UWidget in the live tree (as reported by read_pie_widgets).
value	object	yes	Required object: {"type":"float"|"bool"|"string", "value": <matching JSON type>}.
child_name	string	no	Optional: drill into a descendant widget with this name after resolving widget_name.
player_index	number	no	Optional (default 0): filter to viewport UserWidgets owned by this local player index.
fire_event	boolean	no	Optional bool (default true): broadcast the widget's change event where the engine does not already do so unconditionally (CheckBox / EditableTextBox / EditableText).
commit_type	string	no	Optional "Default" | "OnEnter" | "OnUserMovedFocus": when present (EditableTextBox/EditableText only, and fire_event is true), also broadcasts OnTextCommitted with this commit type.
world	string	no	Optional world selector: absent/'pie' (default: PlayWorld, else the first PIE context) | 'server' (the PIE world with authority) | 'client' | 'pie:N' | 'game' (alias of 'pie'). In a 2-player PIE session EVERY client has its OWN widgets, so the default may well read the other player's HUD.

Returns: { widget_name, resolved_widget, resolved_class, value_type, value, set: bool, event_fired: bool, player_index, child_name?, event_fired_note?, world: string, world_name: string|null, world_package: string|null, world_type: string|null, net_mode: string|null, pie_instance: number }

set_slot_properties

Destructive, idempotent.

Set ANY property of a widget's UPanelSlot BY REFLECTION, whatever the concrete slot class is -- including the 9 of UMG's 17 slot types that no shortcut covers (UButtonSlot, which is every widget inside a Button; UUniformGridSlot, UWrapBoxSlot, UStackBoxSlot, UWidgetSwitcherSlot, USafeZoneSlot, UScaleBoxSlot, UBackgroundBlurSlot, UWindowTitleBarAreaSlot) and any slot type a future engine version adds. Accepts dotted paths into nested slot structs ("Padding.Left", "Size.SizeRule") and reports field by field what landed, same honest contract as set_widget_property: the oracle is applied[]/ignored[]/errors[], not success. For the common cases prefer the validated shortcuts, which also normalise formats this does not guess: set_widget_slot_properties (CanvasPanel anchors/offsets/z-order), set_box_slot_properties (HorizontalBox/VerticalBox/Overlay/Border/SizeBox/ScrollBox alignment+padding+size) and set_grid_slot_properties (GridPanel row/column/spans).

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the Widget Blueprint asset
widget_name	string	yes	name of the widget whose slot to edit (its PARENT panel decides the slot class; read it from get_widget_blueprint_tree include_slot=true)
properties	object	yes	{"<property or dotted path>": <value>, ...} written onto the slot object, e.g. {"Padding":[8,4,8,4],"HorizontalAlignment":"HAlign_Center"}. Enums accept the short name; FMargin accepts a scalar, [h,v] or [l,t,r,b].
save	boolean	no	Compile + save the Widget Blueprint when done (default true).

Returns: { widget_bp_path: string, widget_name: string, parent_name: string, slot_class: string, requested_paths: [string], applied: [string], ignored: [string], errors: [{path, error}], failed_paths: [string], applied_count: int, all_applied: bool, current_values: object, saved: bool, save_error: string }

set_viewmodel_field

Destructive, idempotent.

Instantiate a UMVVMViewModelBase on a UUserWidget instance and set it via UMVVMBlueprintLibrary::SetViewModelByClass.

Parameter	Type	Required	Description
widget_instance_name	string	yes	Label (Actor label or asset path) used to find an in-world UUserWidget
view_model_class	string	yes	VM class: asset path or /Script/<Module>.<ClassName>
context_name	string	yes	FName of the target context on the widget

Returns: { widget_instance_name, view_model_class, context_name, set, instance_class }

set_widget_drag_drop

Destructive, idempotent.

Honest gap report: there is no UWidget UPROPERTY that exposes DragDropOperationClass, and OnDragDetected/OnDrop are DECLARE_DYNAMIC delegates (not reflectively assignable). The drag/drop behavior must be configured in the widget BP graph.

Parameter	Type	Required	Description
widget_blueprint_name	string	yes	/Game path of the Widget Blueprint
widget_name	string	yes	FName of the target widget inside the tree
operation_class	string	no	/Script/...DragDropOperation or subclass path

Returns: { widget_blueprint_name, widget_name, operation_class, set: false, has_drag_drop_property: false, note }

set_widget_navigation

Destructive, idempotent.

Author a widget's GAMEPAD/KEYBOARD navigation rules -- what gets focus when the player pushes up, down, left, right, Tab or Shift+Tab off this widget. Without this a menu cannot be driven with a pad, and it is NOT reachable through set_widget_property: UWidget::Navigation is an Instanced SUBOBJECT that starts null, so there is no asset path a reflection setter could point at and a dotted path fails on a null segment. Follows the editor's own flow, including the two details that matter: the subobject is created RF_Transactional with template flags propagated, and if all six directions end up on Escape the subobject is DISCARDED (that is what tells "no navigation authored" apart from "navigation authored that happens to be the default", and it is what the Designer does). Read the result back with get_widget_blueprint_tree include_navigation=true.

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the Widget Blueprint asset
widget_name	string	yes	Name of the widget in the tree whose navigation to author
rules	object	no	Dict of {direction: rule}. Direction is Up|Down|Left|Right|Next|Previous (Next/Previous are Tab/Shift+Tab). The value is either a rule name string ("Wrap", "Stop", "Escape") or an object {"rule":"Explicit","widget_to_focus":"Btn_Confirm"} when the rule needs a target. Rules: Escape (default -- let the search continue outward), Stop (movement dies here), Wrap (cycle inside the container), Explicit (jump to widget_to_focus).
all_directions	string	no	Optional rule name applied to ALL SIX directions before rules is processed, so you can say "Stop everywhere, except Down" in one call. Explicit is refused here: it would need six different targets.
save	boolean	no	Compile + save the Widget Blueprint when done (default true).

Returns: { widget_bp_path, widget_name, applied: [{direction, rule, widget_to_focus}], current_navigation: {Up:{rule,widget_to_focus}, ...}, navigation_discarded: bool, saved, save_error } -- navigation_discarded:true means every direction ended on Escape so the subobject was dropped, exactly as the Designer does; current_navigation is then all-Escape.

set_widget_property

Destructive, idempotent.

Set ONE or MANY reflected properties on a widget of a Widget Blueprint, addressing NESTED STYLE FIELDS by dotted path ("WidgetStyle.Normal.TintColor", "WidgetStyle.Hovered.OutlineSettings.CornerRadii") and reporting FIELD BY FIELD what actually landed. Two calling shapes over one write path: property_name+value writes a single path; properties writes a whole map with ONE Modify + ONE compile + ONE save (a FButtonStyle is ~30 leaf fields -- one call, not 30 recompiles). WARNING: The oracle is applied[]/ignored[]/errors[], NOT success: a JSON key that matches no reflected field lands in ignored[] and all_applied goes false instead of the silent no-op the engine's converter reports as success. Read the result back with get_widget_blueprint_tree(property_paths=[...]).

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the Widget Blueprint asset
widget_name	string	yes	name of the widget in the tree (get_widget_blueprint_tree lists them)
property_name	string	no	Single reflected property name ("Text") OR a dotted path into nested structs ("WidgetStyle.Normal.TintColor"); array indices are supported ("Items[0].Label"). Requires value. Omit when using properties.
value	any	no	New value for property_name: string, number, bool, JSON object (struct, applied field by field) or JSON array. Colors accept {"R":1,"G":0,"B":0,"A":1}, [r,g,b,a] or "#RRGGBBAA"; FMargin accepts a scalar, [h,v] or [l,t,r,b]; an FSlateBrush accepts a texture/material path string; enums accept the short name ("Box").
properties	object	no	Batch form: {"<dotted path>": <value>, ...}. Every path is written against the SAME widget under one Modify/compile/save. Combinable with property_name+value (both end up in the same map).
save	boolean	no	Compile + save the Widget Blueprint when done (default true). Pass false to chain several calls and save once at the end -- the asset stays dirty in memory until something saves it.

Returns: { widget_bp_path: string, widget_name: string, widget_class: string, requested_paths: [string], applied: [string], ignored: [string], errors: [{path, error}], failed_paths: [string], applied_count: int, all_applied: bool, current_values: object, saved: bool, save_error: string }

set_widget_slot_properties

Destructive, idempotent.

Set the CanvasPanelSlot layout of a widget inside a CanvasPanel of a Widget Blueprint asset -- anchors, offsets, position, size, z_order and auto_size, only those passed -- then compile and save the blueprint; the reply reads the whole slot back. position and size write the same fields as offsets (Left/Top and Right/Bottom) and are applied after it, so they win when both are given. A widget not under a CanvasPanel, or a call with none of the six fields, is an error. Refused while PIE runs unless force=true. For other slot types use set_box_slot_properties, set_grid_slot_properties or set_slot_properties.

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the Widget Blueprint asset
widget_name	string	yes	name of the widget whose canvas slot to edit
anchors	array	no	Optional [MinX, MinY, MaxX, MaxY] anchor floats.
offsets	array	no	Optional [Left, Top, Right, Bottom] offset floats.
position	array	no	Optional [X, Y] position.
size	array	no	Optional [X, Y] size.
z_order	number	no	Optional int draw/hit-test order (higher draws on top); use with reorder_widget_child's note for CanvasPanel stacking.
auto_size	boolean	no	Optional bool: when true, the slot sizes itself to the widget's desired size instead of size.

Returns: { widget_bp_path: string, widget_name: string, anchors_set: bool, offsets_set: bool, position_set: bool, size_set: bool, z_order_set: bool, auto_size_set: bool, current_anchors: [float], current_offsets: [float], current_position: [float], current_size: [float], current_z_order: int, current_auto_size: bool, saved: bool, save_error: string }

set_widget_visibility

Destructive, idempotent.

Set widget visibility state to one of: Visible, Collapsed, Hidden, HitTestInvisible, SelfHitTestInvisible.

Parameter	Type	Required	Description
widget_name	string	yes	Name of the widget to modify
visibility	string	yes	Target visibility state: Visible, Collapsed, Hidden, HitTestInvisible, or SelfHitTestInvisible

Returns: { widget_name: string, visibility_set: bool, previous_visibility: string, requested_visibility: string, actual_visibility: string, widget_valid: bool }

stop_widget_animation

Destructive.

Stop a widget animation. REAL stop (UUserWidget::StopAnimation) when a live PIE instance of this WidgetBP is found in the viewport's active UUserWidgets: stopped is true when the animation was playing before the call and is not after it; one that was not playing (stopped or paused) succeeds with stopped:false and a note, and one still playing after the call is an error. Falls back to an honest headless gate (stopped:false, headless:true, requires_pie:true) otherwise.

Parameter	Type	Required	Description
widget_bp_path	string	yes	/Game path of the Widget Blueprint asset
animation_name	string	yes	object name OR display label of the animation to stop
world	string	no	Optional world selector: absent/'pie' (default: PlayWorld, else the first PIE context) | 'server' (the PIE world with authority) | 'client' | 'pie:N' | 'game' (alias of 'pie'). In a 2-player PIE session EVERY client has its OWN widgets, so the default may well read the other player's HUD.

Returns: { widget_bp_path: string, animation_name: string, animation_exists: bool, stopped: bool, headless: bool, requires_pie: bool, note: string, saved: bool, live_widget_name?: string, live_animation_name?: string, world: string, world_name: string|null, world_package: string|null, world_type: string|null, net_mode: string|null, pie_instance: number }

unbind_widget_from_viewmodel

Destructive, idempotent.

Remove an FMVVMBlueprintViewBinding from a Widget BP's MVVM authoring state, by index (primary) or binding GUID. Inverse of bind_widget_to_viewmodel; idempotent (already-absent is an honest success).

Parameter	Type	Required	Description
widget_blueprint_name	string	yes	/Game path of the Widget Blueprint asset
binding_index	number	no	int index of the binding to remove (primary identifier; one of binding_index / binding_id required)
binding_id	string	no	optional GUID string of the binding to remove (alternative to binding_index)

Returns: { widget_blueprint_name, binding_index?, binding_id?, already_existed, removed, binding_count, has_mvvm_extension, saved, save_error? }