Fix: Editor Utility Widget Not Appearing in Unreal

Editor Utility Widgets are one of Unreal Engine’s most useful tools for building custom editor interfaces—asset management panels, batch processing tools, debug dashboards. But they have a frustrating failure mode: you create the widget, set up the UI, hit play, and nothing happens. No error, no window, no feedback. The widget simply doesn’t appear.

Check the Parent Class

The single most common cause of invisible Editor Utility Widgets is inheriting from the wrong class. When you create a new Widget Blueprint in the Content Browser, Unreal defaults the parent class to UserWidget. An Editor Utility Widget must inherit from EditorUtilityWidget instead.

Open your widget blueprint and click the “Class Settings” button in the toolbar. Look at the “Parent Class” field. If it says UserWidget, that’s your problem. You cannot simply reparent an existing widget blueprint to EditorUtilityWidget in all cases—depending on your engine version, the reparent may silently fail or lose widget bindings.

The safest approach is to create the widget correctly from the start. In the Content Browser, right-click and choose Editor Utilities → Editor Utility Widget. This creates a blueprint with the correct parent class already set. If you have an existing UserWidget with complex UI that you want to convert, create a new Editor Utility Widget and copy your widget hierarchy over using the designer view.

Running and Registering the Widget

Unlike regular UMG widgets, Editor Utility Widgets don’t appear automatically. You need to explicitly run them. Right-click the widget asset in the Content Browser, select Asset Actions → Run Editor Utility Widget. This opens the widget in a new editor tab.

If the “Run Editor Utility Widget” option doesn’t appear in the context menu, the asset’s class is not recognized as an editor utility. Double-check the parent class as described above. Also verify that the Blutility plugin is enabled in your project settings under Edit → Plugins.

For C++ editor modules that need to spawn a widget programmatically, register a tab spawner in your module’s startup:

// In your editor module's StartupModule()
void FMyEditorModule::StartupModule()
{
    FGlobalTabmanager::Get()->RegisterNomadTabSpawner(
        TEXT("MyCustomTool"),
        FOnSpawnTab::CreateRaw(this, &FMyEditorModule::SpawnToolTab))
        .SetDisplayName(FText::FromString("My Custom Tool"))
        .SetMenuType(ETabSpawnerMenuType::Hidden);
}

TSharedRef<SDockTab> FMyEditorModule::SpawnToolTab(const FSpawnTabArgs& Args)
{
    // Load and create the Editor Utility Widget
    UEditorUtilityWidgetBlueprint* WidgetBP = LoadObject<UEditorUtilityWidgetBlueprint>(
        nullptr,
        TEXT("/Game/EditorTools/MyWidget.MyWidget"));

    UEditorUtilitySubsystem* Subsystem =
        GEditor->GetEditorSubsystem<UEditorUtilitySubsystem>();
    Subsystem->SpawnAndRegisterTab(WidgetBP);

    // Return a dock tab (the subsystem handles the actual widget)
    return SNew(SDockTab).TabRole(ETabRole::NomadTab);
}

void FMyEditorModule::ShutdownModule()
{
    FGlobalTabmanager::Get()->UnregisterNomadTabSpawner(TEXT("MyCustomTool"));
}

Forgetting to unregister the tab spawner in ShutdownModule is a common source of crashes when the editor shuts down or when hot-reloading modules.

Module Dependency Issues

If your Editor Utility Widget uses a custom C++ base class or references types from other modules, you need the correct dependencies in your .Build.cs file. Missing dependencies don’t always produce compiler errors—sometimes the module loads but the widget class silently fails to resolve.

At minimum, your editor module should include these dependencies:

// MyEditorModule.Build.cs
PublicDependencyModuleNames.AddRange(new string[]
{
    "Core",
    "CoreUObject",
    "Engine",
    "Slate",
    "SlateCore",
    "UMG",
    "UMGEditor",
    "Blutility",
    "UnrealEd"
});

The Blutility module provides the EditorUtilityWidget base class. UMGEditor provides the editor-side widget infrastructure. If either is missing, your widget may compile but fail to register as an editor utility. Also ensure your module is listed with Type = ModuleType.Editor in your .uproject file. A runtime module cannot load editor-only dependencies.

Troubleshooting Widget Visibility

If the widget runs but appears blank or shows incorrect content, check these common issues. First, verify that your widget’s root element has a non-zero size. Editor Utility Widgets don’t automatically fill their tab—set the root Canvas Panel or Size Box to “Fill” in the designer. Second, check for construction script errors by looking at the Output Log when you run the widget. Blueprint errors during Construct or PreConstruct will silently abort widget creation.

If your widget previously appeared but stopped showing after an engine upgrade, the internal widget registration may be stale. Delete the Saved/Config directory in your project (or at minimum the EditorPerProjectUserSettings.ini file) and restart the editor. Unreal caches tab layouts and widget registrations, and stale entries can prevent widgets from spawning.

For widgets that appear in Editor builds but not in Development Editor builds, check your build configuration. Some modules may be conditionally compiled out depending on the build target. Use #if WITH_EDITOR guards around editor utility code and ensure the module loading phase is set to PostEngineInit in your .uproject descriptor.

Editor Utility Widgets are powerful once they’re working—the setup just has a few gotchas that aren’t well documented.