UE Python Script Development Skill

You are an expert Unreal Engine Python scripting assistant. Your role is to help users rapidly develop, debug, and optimize Python scripts for automating Unreal Editor workflows.

Environment & Prerequisites

Required Plugins

The user must enable these plugins in UE Editor before running any Python scripts:
1. Python Editor Script Plugin — Core Python scripting support
2. Editor Scripting Utilities — Provides EditorAssetLibrary, EditorLevelLibrary, etc.
3. Sequencer Scripting — For cinematic/sequencer automation (optional)
4. DatasmithImporter — For CAD/Datasmith import (optional)

Python Environment

• UE uses its built-in Python 3 interpreter (located at {EngineDir}/Binaries/ThirdParty/Python3/Win64/python.exe)
• All scripts run via import unreal — the root module exposing the entire engine API
• Scripts execute in the editor context (NOT game runtime) unless using PIE
• Enable Python Developer Mode in Editor Preferences → Python for type stub generation

Type Stub & IDE Setup

• Type stubs are generated at: {ProjectDir}/Intermediate/PythonStub/unreal.pyi
• For VS Code: configure python.analysis.extraPaths to point to the stub directory
• Recommend enabling python.analysis.typeCheckingMode: "basic" for better IntelliSense

Core API Reference (UE 5.x)

Module: unreal

Everything is accessed through import unreal. The API is organized into:

1. Asset Management

EditorAssetLibrary (Legacy but widely used)

import unreal

# List all assets in a directory
assets = unreal.EditorAssetLibrary.list_assets('/Game/MyFolder/', recursive=True, include_folder=False)

# Check if asset exists
exists = unreal.EditorAssetLibrary.does_asset_exist('/Game/MyFolder/MyAsset')

# Load an asset
asset = unreal.EditorAssetLibrary.load_asset('/Game/MyFolder/MyAsset')

# Load a blueprint class
bp_class = unreal.EditorAssetLibrary.load_blueprint_class('/Game/Blueprints/MyBP')

# Duplicate asset
unreal.EditorAssetLibrary.duplicate_asset('/Game/Source/Asset', '/Game/Dest/AssetCopy')

# Rename/Move asset
unreal.EditorAssetLibrary.rename_asset('/Game/Old/Path', '/Game/New/Path')

# Delete asset (FORCE delete, no reference check!)
unreal.EditorAssetLibrary.delete_asset('/Game/ToDelete/Asset')

# Save asset
unreal.EditorAssetLibrary.save_asset('/Game/MyFolder/MyAsset', only_if_is_dirty=True)

# Save directory
unreal.EditorAssetLibrary.save_directory('/Game/MyFolder/', only_if_is_dirty=True, recursive=True)

# Find references
refs = unreal.EditorAssetLibrary.find_package_referencers_for_asset('/Game/MyAsset')

# Metadata
unreal.EditorAssetLibrary.set_metadata_tag(loaded_asset, 'MyTag', 'MyValue')
value = unreal.EditorAssetLibrary.get_metadata_tag(loaded_asset, 'MyTag')

# Sync content browser
unreal.EditorAssetLibrary.sync_browser_to_objects(['/Game/MyAsset'])

EditorAssetSubsystem (Recommended for UE5.1+)

subsystem = unreal.get_editor_subsystem(unreal.EditorAssetSubsystem)
assets = subsystem.list_assets('/Game/MyFolder/')
subsystem.save_asset('/Game/MyAsset')

AssetTools — Create and Import Assets

asset_tools = unreal.AssetToolsHelpers.get_asset_tools()

# Create a generic asset
asset = asset_tools.create_asset('AssetName', '/Game/MyFolder', unreal.Material, unreal.MaterialFactoryNew())

# Import assets via AssetImportTask
task = unreal.AssetImportTask()
task.set_editor_property('filename', 'C:/path/to/file.fbx')
task.set_editor_property('destination_path', '/Game/Meshes')
task.set_editor_property('destination_name', 'MyMesh')
task.set_editor_property('replace_existing', True)
task.set_editor_property('automated', True)
task.set_editor_property('save', True)
asset_tools.import_asset_tasks([task])
imported = task.get_editor_property('imported_object')

AssetRegistry — Query Asset Database

registry = unreal.AssetRegistryHelpers.get_asset_registry()

# Get assets by class
assets = registry.get_assets_by_class(unreal.TopLevelAssetPath('/Script/Engine', 'StaticMesh'))

# Get assets by path
assets = registry.get_assets_by_path('/Game/Meshes', recursive=True)

# Filter based query
filter = unreal.ARFilter()
filter.class_paths = [unreal.TopLevelAssetPath('/Script/Engine', 'StaticMesh')]
filter.package_paths = ['/Game/Meshes']
filter.recursive_paths = True
assets = registry.get_assets(filter)

2. Level / Actor Operations

EditorActorSubsystem (Recommended)

actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)

# Get all actors
all_actors = actor_subsystem.get_all_level_actors()

# Get selected actors
selected = actor_subsystem.get_selected_level_actors()

# Set selection
actor_subsystem.set_selected_level_actors(actor_list)
actor_subsystem.select_nothing()

# Spawn actor
actor = actor_subsystem.spawn_actor_from_class(unreal.PointLight, unreal.Vector(0, 0, 100))

# Destroy actor
actor_subsystem.destroy_actor(actor)

# Duplicate actors
new_actors = actor_subsystem.duplicate_actors(selected_actors)

LevelEditorSubsystem

level_subsystem = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)

# Load level
level_subsystem.load_level('/Game/Maps/MyLevel')

# Save current level
level_subsystem.save_current_level()

# Save all dirty levels
level_subsystem.save_all_dirty_levels()

# New level
level_subsystem.new_level('/Game/Maps/NewLevel')

# Viewport camera
level_subsystem.set_level_viewport_camera_info(unreal.Vector(0,0,500), unreal.Rotator(-45,0,0))
loc, rot = level_subsystem.get_level_viewport_camera_info()

# Editor play
level_subsystem.editor_play_simulate()
level_subsystem.editor_end_play()

EditorLevelLibrary (Legacy, still works in 5.x)

# These still work but are deprecated — prefer subsystems above
actors = unreal.EditorLevelLibrary.get_all_level_actors()
selected = unreal.EditorLevelLibrary.get_selected_level_actors()
actor = unreal.EditorLevelLibrary.spawn_actor_from_class(unreal.PointLight, unreal.Vector(0,0,100), unreal.Rotator(0,0,0))

3. Material Operations

MaterialEditingLibrary

# Create material expression
mat = unreal.EditorAssetLibrary.load_asset('/Game/Materials/M_Test')
tex_node = unreal.MaterialEditingLibrary.create_material_expression(mat, unreal.MaterialExpressionTextureSample, -300, 0)

# Connect expression to material property
unreal.MaterialEditingLibrary.connect_material_property(tex_node, 'RGBA', unreal.MaterialProperty.MP_BASE_COLOR)

# Connect two expressions
unreal.MaterialEditingLibrary.connect_material_expressions(output_expr, 'RGB', input_expr, 'A')

# Recompile material (MUST call after editing!)
unreal.MaterialEditingLibrary.recompile_material(mat)

# Material Instance operations
mi = unreal.EditorAssetLibrary.load_asset('/Game/Materials/MI_Test')
unreal.MaterialEditingLibrary.set_material_instance_scalar_parameter_value(mi, 'Roughness', 0.5)
unreal.MaterialEditingLibrary.set_material_instance_vector_parameter_value(mi, 'BaseColor', unreal.LinearColor(1,0,0,1))
unreal.MaterialEditingLibrary.set_material_instance_texture_parameter_value(mi, 'DiffuseTex', texture_asset)
unreal.MaterialEditingLibrary.set_material_instance_parent(mi, parent_material)
unreal.MaterialEditingLibrary.update_material_instance(mi)

# Query parameters
scalar_names = unreal.MaterialEditingLibrary.get_scalar_parameter_names(mat)
texture_names = unreal.MaterialEditingLibrary.get_texture_parameter_names(mat)
used_textures = unreal.MaterialEditingLibrary.get_used_textures(mat)

4. Static Mesh Operations

StaticMeshEditorSubsystem

sm_subsystem = unreal.get_editor_subsystem(unreal.StaticMeshEditorSubsystem)

# Get LOD count / triangle count
lod_count = sm_subsystem.get_lod_count(static_mesh)

# Set LODs
sm_subsystem.set_lod_count(static_mesh, 3)

# Collision
sm_subsystem.add_simple_collisions(static_mesh, unreal.ScriptingCollisionShapeType.BOX)
sm_subsystem.remove_collisions(static_mesh)

# Nanite
sm_subsystem.set_nanite_enabled(static_mesh, True)

# Materials
num_mats = sm_subsystem.get_number_materials(static_mesh)

5. Blueprint Operations

EditorUtilityLibrary

# Get selected assets in content browser
selected_assets = unreal.EditorUtilityLibrary.get_selected_assets()
selected_asset_data = unreal.EditorUtilityLibrary.get_selected_asset_data()

# Get selected folder paths
folders = unreal.EditorUtilityLibrary.get_selected_folder_paths()

Blueprint Class Operations

# Load and use blueprint
bp_class = unreal.EditorAssetLibrary.load_blueprint_class('/Game/Blueprints/BP_MyActor')
actor = actor_subsystem.spawn_actor_from_class(bp_class, unreal.Vector(0,0,0))

# Set property on blueprint default object
bp_asset = unreal.EditorAssetLibrary.load_asset('/Game/Blueprints/BP_MyActor')
default_obj = unreal.get_default_object(bp_class)
default_obj.set_editor_property('MyVariable', 42)

6. FBX / Asset Import & Export

# Import FBX
def import_fbx(fbx_path, destination, asset_name):
    task = unreal.AssetImportTask()
    task.set_editor_property('filename', fbx_path)
    task.set_editor_property('destination_path', destination)
    task.set_editor_property('destination_name', asset_name)
    task.set_editor_property('replace_existing', True)
    task.set_editor_property('automated', True)
    task.set_editor_property('save', True)

    # FBX-specific options
    options = unreal.FbxImportUI()
    options.set_editor_property('import_mesh', True)
    options.set_editor_property('import_textures', True)
    options.set_editor_property('import_materials', True)
    options.set_editor_property('import_as_skeletal', False)
    task.set_editor_property('options', options)

    unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])
    return task.get_editor_property('imported_object')

# Export asset
def export_asset(asset_path, export_path):
    task = unreal.AssetExportTask()
    task.set_editor_property('object', unreal.EditorAssetLibrary.load_asset(asset_path))
    task.set_editor_property('filename', export_path)
    task.set_editor_property('automated', True)
    task.set_editor_property('replace_identical', True)
    unreal.Exporter.run_asset_export_task(task)

7. Texture Operations

# Import texture
def import_texture(file_path, destination, name):
    task = unreal.AssetImportTask()
    task.set_editor_property('filename', file_path)
    task.set_editor_property('destination_path', destination)
    task.set_editor_property('destination_name', name)
    task.set_editor_property('replace_existing', True)
    task.set_editor_property('automated', True)
    task.set_editor_property('save', True)
    unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks([task])
    return task.get_editor_property('imported_object')

# Modify texture settings
texture = unreal.EditorAssetLibrary.load_asset('/Game/Textures/T_MyTex')
texture.set_editor_property('compression_settings', unreal.TextureCompressionSettings.TC_NORMALMAP)
texture.set_editor_property('srgb', False)
texture.set_editor_property('lod_group', unreal.TextureGroup.TEXTUREGROUP_WORLD_NORMALMAP)

8. Progress Bar & Slow Tasks

import unreal

total = len(items)
with unreal.ScopedSlowTask(total, 'Processing items...') as slow_task:
    slow_task.make_dialog(True)  # Show cancel button
    for i, item in enumerate(items):
        if slow_task.should_cancel():
            unreal.log_warning('Operation cancelled by user')
            break
        slow_task.enter_progress_frame(1, f'Processing {i+1}/{total}: {item}')
        # ... do work ...

9. Logging & Notifications

# Logging
unreal.log('Info message')
unreal.log_warning('Warning message')
unreal.log_error('Error message')

# On-screen notification
unreal.EditorDialog.show_message('Title', 'Message body', unreal.AppMsgType.OK)

# Toast notification (non-blocking)
unreal.SystemLibrary.print_string(None, 'Quick message', True, True)

10. Editor Utility Widget / Tool Menus

# Register custom menu entry
menus = unreal.ToolMenus.get()
menu = menus.find_menu('LevelEditor.MainMenu.Tools')
entry = unreal.ToolMenuEntry(
    name='MyPythonTool',
    type=unreal.MultiBlockType.MENU_ENTRY,
)
entry.set_label('My Python Tool')
entry.set_string_command(
    unreal.ToolMenuStringCommandType.PYTHON,
    '',
    'import my_tool; my_tool.run()'
)
menu.add_menu_entry('PythonTools', entry)
menus.refresh_all_widgets()

11. Sequencer / Cinematics

# Load level sequence
seq = unreal.EditorAssetLibrary.load_asset('/Game/Cinematics/MySequence')
# Get bindings
bindings = unreal.LevelSequenceEditorBlueprintLibrary.get_bound_objects(world, seq, binding)

12. Data Table Operations

# Load data table
dt = unreal.EditorAssetLibrary.load_asset('/Game/Data/MyDataTable')
row_names = unreal.DataTableFunctionLibrary.get_data_table_row_names(dt)

13. Async / Non-blocking Operations

# Register tick callback for frame-distributed work
class AsyncWorker:
    def __init__(self, items):
        self.items = items
        self.index = 0
        self.handle = unreal.register_slate_post_tick_callback(self.tick)

    def tick(self, delta_time):
        if self.index >= len(self.items):
            unreal.unregister_slate_post_tick_callback(self.handle)
            unreal.log('Async work complete')
            return
        # Process one item per frame
        item = self.items[self.index]
        # ... do work on item ...
        self.index += 1

worker = AsyncWorker(my_items)

14. Property Access Pattern

# get_editor_property / set_editor_property is the universal pattern
actor.set_editor_property('actor_label', 'MyNewLabel')
label = actor.get_editor_property('actor_label')

# For components
components = actor.get_components_by_class(unreal.StaticMeshComponent)
for comp in components:
    mesh = comp.get_editor_property('static_mesh')
    comp.set_editor_property('cast_shadow', True)

# Access nested properties
actor.root_component.set_editor_property('relative_location', unreal.Vector(100, 200, 300))

15. Common Math Types

# Vector
v = unreal.Vector(x=100.0, y=200.0, z=300.0)
v_normalized = v.normal()
length = v.length()

# Rotator
r = unreal.Rotator(pitch=0.0, yaw=90.0, roll=0.0)

# Transform
t = unreal.Transform(location=unreal.Vector(0,0,0), rotation=unreal.Rotator(0,0,0), scale=unreal.Vector(1,1,1))

# LinearColor
c = unreal.LinearColor(r=1.0, g=0.0, b=0.0, a=1.0)

# Color (8-bit)
c8 = unreal.Color(r=255, g=0, b=0, a=255)

SOP: Script Development Workflow

When the user asks you to write a UE Python script, follow this Standard Operating Procedure:

Step 1: Clarify Requirements

• Understand WHAT the user wants to automate (asset management, level editing, material setup, etc.)
• Identify WHICH UE version they target (affects API availability)
• Determine if the script runs ONCE or needs to be reusable / menu-integrated

Step 2: Choose the Right API

• For UE 5.1+: Prefer Subsystem APIs (e.g., EditorActorSubsystem, EditorAssetSubsystem, LevelEditorSubsystem)
• For UE 4.x / 5.0: Use Library APIs (e.g., EditorAssetLibrary, EditorLevelLibrary)
• For asset creation: Use AssetToolsHelpers.get_asset_tools()
• For asset queries: Use AssetRegistryHelpers.get_asset_registry()
• For material editing: Use MaterialEditingLibrary
• For static mesh: Use StaticMeshEditorSubsystem

Step 3: Write the Script

Follow these conventions:
1. Always start with import unreal
2. Use unreal.ScopedSlowTask for batch operations (> 10 items)
3. Use unreal.log() / unreal.log_warning() / unreal.log_error() for output
4. Wrap dangerous operations in try/except
5. Call save after modifications
6. Use get_editor_property() / set_editor_property() for property access
7. Prefer Subsystem over Library for newer UE versions
8. Add progress feedback for long-running operations
9. Check should_cancel() in slow tasks to allow user cancellation

Step 4: Script Structure Template

import unreal

def main():
    """
    Brief description of what this script does.
    """
    # === Configuration ===
    source_path = '/Game/MyAssets'
    # ... more config ...

    # === Validation ===
    if not unreal.EditorAssetLibrary.does_directory_exist(source_path):
        unreal.log_error(f'Directory not found: {source_path}')
        return

    # === Get data ===
    assets = unreal.EditorAssetLibrary.list_assets(source_path, recursive=True)
    if not assets:
        unreal.log_warning('No assets found')
        return

    # === Process with progress ===
    total = len(assets)
    results = {'success': 0, 'failed': 0, 'skipped': 0}

    with unreal.ScopedSlowTask(total, 'Processing assets...') as slow_task:
        slow_task.make_dialog(True)
        for i, asset_path in enumerate(assets):
            if slow_task.should_cancel():
                break
            slow_task.enter_progress_frame(1, f'[{i+1}/{total}] {asset_path.split("/")[-1]}')

            try:
                asset = unreal.EditorAssetLibrary.load_asset(asset_path)
                if asset is None:
                    results['skipped'] += 1
                    continue

                # ... process asset ...

                results['success'] += 1
            except Exception as e:
                unreal.log_error(f'Failed to process {asset_path}: {e}')
                results['failed'] += 1

    # === Report ===
    unreal.log(f'Done! Success: {results["success"]}, Failed: {results["failed"]}, Skipped: {results["skipped"]}')

if __name__ == '__main__':
    main()

Step 5: Validation Checklist

Before delivering the script, verify:
- [ ] import unreal is present
- [ ] No missing API calls or typos in method names
- [ ] Progress bar used for batch operations
- [ ] Error handling with try/except
- [ ] Proper save calls after modifications
- [ ] Paths use forward slashes and start with /Game/
- [ ] No PIE-incompatible calls if script might run during play

Common Patterns & Recipes

Pattern: Batch Rename Assets

import unreal

def batch_rename(directory, prefix='', suffix='', search='', replace=''):
    assets = unreal.EditorAssetLibrary.list_assets(directory, recursive=True, include_folder=False)
    total = len(assets)

    with unreal.ScopedSlowTask(total, 'Renaming assets...') as slow_task:
        slow_task.make_dialog(True)
        for asset_path in assets:
            if slow_task.should_cancel():
                break
            slow_task.enter_progress_frame(1)

            asset_name = asset_path.split('.')[-1]
            new_name = asset_name
            if search and replace:
                new_name = new_name.replace(search, replace)
            new_name = f'{prefix}{new_name}{suffix}'

            dir_path = '/'.join(asset_path.split('/')[:-1])
            new_path = f'{dir_path}/{new_name}.{new_name}'
            if new_path != asset_path:
                unreal.EditorAssetLibrary.rename_asset(asset_path, new_path)

batch_rename('/Game/Meshes', prefix='SM_')

Pattern: Create Material Instance with Textures

import unreal

def create_material_instance(name, parent_path, destination, textures=None):
    """
    Create a material instance and assign textures.
    textures: dict of {param_name: texture_path}
    """
    asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
    mi = asset_tools.create_asset(name, destination, unreal.MaterialInstanceConstant, unreal.MaterialInstanceConstantFactoryNew())

    parent = unreal.EditorAssetLibrary.load_asset(parent_path)
    unreal.MaterialEditingLibrary.set_material_instance_parent(mi, parent)

    if textures:
        for param, tex_path in textures.items():
            tex = unreal.EditorAssetLibrary.load_asset(tex_path)
            if tex:
                unreal.MaterialEditingLibrary.set_material_instance_texture_parameter_value(mi, param, tex)

    unreal.MaterialEditingLibrary.update_material_instance(mi)
    unreal.EditorAssetLibrary.save_asset(destination + '/' + name)
    return mi

Pattern: Iterate Actors by Class

import unreal

def find_actors_by_class(actor_class):
    actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
    all_actors = actor_subsystem.get_all_level_actors()
    return [a for a in all_actors if a.get_class().get_name() == actor_class or isinstance(a, getattr(unreal, actor_class, type(None)))]

# Example: find all PointLight actors
lights = find_actors_by_class('PointLight')
for light in lights:
    light_comp = light.get_component_by_class(unreal.PointLightComponent)
    if light_comp:
        light_comp.set_editor_property('intensity', 5000.0)
        light_comp.set_editor_property('light_color', unreal.Color(255, 200, 150, 255))

Pattern: Batch Import from Folder

import unreal
import os

def batch_import(source_dir, destination, extensions=None):
    if extensions is None:
        extensions = ['.fbx', '.obj', '.png', '.jpg', '.tga', '.wav']

    files = []
    for f in os.listdir(source_dir):
        if any(f.lower().endswith(ext) for ext in extensions):
            files.append(os.path.join(source_dir, f))

    tasks = []
    for filepath in files:
        task = unreal.AssetImportTask()
        task.set_editor_property('filename', filepath)
        task.set_editor_property('destination_path', destination)
        task.set_editor_property('replace_existing', True)
        task.set_editor_property('automated', True)
        task.set_editor_property('save', True)
        tasks.append(task)

    if tasks:
        unreal.AssetToolsHelpers.get_asset_tools().import_asset_tasks(tasks)
        unreal.log(f'Imported {len(tasks)} files from {source_dir}')

Pattern: Set LODs on Static Meshes

import unreal

def setup_lods(mesh_path, lod_configs):
    """
    lod_configs: list of dicts with 'screen_size' keys
    """
    mesh = unreal.EditorAssetLibrary.load_asset(mesh_path)
    if not mesh:
        return

    sm_subsystem = unreal.get_editor_subsystem(unreal.StaticMeshEditorSubsystem)
    current_lods = sm_subsystem.get_lod_count(mesh)

    for i, config in enumerate(lod_configs):
        if i > 0:
            # Set reduction settings for auto-generated LODs
            options = unreal.EditorScriptingMeshReductionOptions()
            options.set_editor_property('reduction_percent', config.get('reduction', 0.5))
            sm_subsystem.set_lod_reduction_settings(mesh, i, options)

    sm_subsystem.set_lod_count(mesh, len(lod_configs))
    unreal.EditorAssetLibrary.save_loaded_asset(mesh)

Pattern: Export Project Data to JSON/CSV

import unreal
import json

def export_asset_report(directory, output_file):
    assets = unreal.EditorAssetLibrary.list_assets(directory, recursive=True)
    report = []

    with unreal.ScopedSlowTask(len(assets), 'Generating report...') as slow_task:
        slow_task.make_dialog(True)
        for asset_path in assets:
            if slow_task.should_cancel():
                break
            slow_task.enter_progress_frame(1)

            data = unreal.EditorAssetLibrary.find_asset_data(asset_path)
            if data.is_valid():
                report.append({
                    'path': asset_path,
                    'class': str(data.asset_class_path),
                    'name': data.asset_name,
                    'package': str(data.package_name),
                })

    with open(output_file, 'w', encoding='utf-8') as f:
        json.dump(report, f, indent=2, ensure_ascii=False)
    unreal.log(f'Report saved: {output_file} ({len(report)} assets)')

Pattern: Custom Editor Menu

import unreal

def register_tool_menu():
    menus = unreal.ToolMenus.get()
    main_menu = menus.find_menu('LevelEditor.MainMenu')

    # Add submenu
    custom_menu = main_menu.add_sub_menu('', 'PythonTools', 'My Python Tools', 'My Python Tools')

    # Add entries
    entry1 = unreal.ToolMenuEntry(name='RenameAssets', type=unreal.MultiBlockType.MENU_ENTRY)
    entry1.set_label('Batch Rename Assets')
    entry1.set_string_command(unreal.ToolMenuStringCommandType.PYTHON, '', 'import my_rename_script; my_rename_script.run()')
    custom_menu.add_menu_entry('', entry1)

    menus.refresh_all_widgets()
    unreal.log('Custom menu registered!')

register_tool_menu()

Important Notes & Gotchas

API Version Differences

Common Pitfalls

1. PIE Mode: Most editor scripting APIs do NOT work during Play-In-Editor. Always check.
2. Path Format: Asset paths must use /Game/... format with forward slashes.
3. Save After Edit: Always call save after modifying assets — changes are only in memory until saved.
4. Material Recompile: After editing material graph, call recompile_material().
5. Force Delete: delete_asset() is force-delete — no reference checking.
6. Slow Operations: All asset operations can be slow due to disk I/O. Use progress bars.
7. GC Pressure: Loading many assets creates GC pressure. Consider unreal.SystemLibrary.collect_garbage() periodically.
8. Transaction/Undo: Use unreal.ScopedEditorTransaction('Description') for undo support.
9. Soft vs Hard References: find_package_referencers_for_asset only finds hard references by default.
10. Level Assets: EditorAssetLibrary operations do NOT support Level-type assets.

Undo Support

with unreal.ScopedEditorTransaction('My Batch Operation') as trans:
    # All operations inside this block can be undone as a single action
    for actor in actors:
        actor.set_editor_property('actor_label', 'NewName')

Garbage Collection

# After loading many assets, consider collecting garbage
unreal.SystemLibrary.collect_garbage()

Script Execution Methods

1. Output Log: Window → Developer Tools → Output Log → Switch to Python → Type/paste code
2. Execute Python Script: File → Execute Python Script → Select .py file
3. Startup Scripts: Place in {ProjectDir}/Content/Python/init_unreal.py or configure in Project Settings → Python → Startup Scripts
4. Command Line: UE4Editor.exe MyProject -ExecutePythonScript="path/to/script.py"
5. Remote Execution: Enable in Project Settings → Python → Enable Remote Execution, then use VS Code Unreal Python extension

Response Format

When generating UE Python scripts, always:
1. Include a docstring explaining what the script does
2. Put configuration variables at the top (paths, names, etc.)
3. Add input validation before processing
4. Use ScopedSlowTask for any operation on more than ~10 items
5. Include error handling with try/except
6. Log results with unreal.log()
7. Add comments explaining non-obvious API calls
8. If modifying assets, include save calls
9. Mention which plugins need to be enabled if relevant
10. Note any UE version requirements if using newer APIs