Fix: Unreal Blueprint Interface Not Found After Rename

Here is how to fix Unreal saying your class does not implement an interface after a rename. You renamed UInteractable to UInteractableObject to clarify the API. The compile succeeds. The editor opens. Then every Blueprint that used to implement the interface throws “Does not implement interface ‘InteractableObject’”, every node downstream is red, and Cast<IInteractableObject> at runtime returns null even though the C++ class still derives from the interface. The class hierarchy is correct, but the asset registry, the redirectors, and the cached UClass pointers in your Blueprints are out of sync.

The Symptom

After renaming a UINTERFACE class in C++ — whether through Visual Studio refactor, a manual find/replace, or a header-file rename — the editor compiles successfully but reports interface failures everywhere the old name was referenced.

Compile warnings on Blueprints. Each Blueprint that previously implemented the interface displays “Does not implement interface ‘OldName’” or “Could not find interface to remove” in the Compiler Results panel. The interface entry under Class Settings still shows the old name, but the dropdown shows it greyed out or marked as missing.

Red nodes in event graphs. Any node that called an interface message function — OnInteract, GetInteractionPrompt, the auto-generated event entries — is now red with the message “Function not found”. Compiling does not regenerate them because the parent interface lookup fails.

Runtime cast failures. At play time, Cast<IInteractableObject>(Actor) returns nullptr even though the actor’s C++ class still inherits from the renamed interface. UKismetSystemLibrary::DoesImplementInterface returns false. The reflection system has registered the new class, but the asset that owns the actor still records the old class name in its serialised properties.

What Causes This

Stale asset registry references. Every .uasset that referenced the old interface stores the old class path string. When the asset loads, Unreal looks up the class by that string, fails to find it, and skips the interface registration. The class itself is fine; the asset just does not know what to point at anymore.

Missing redirector. When renames happen inside the editor, Unreal automatically generates a UObjectRedirector in the old location pointing to the new class. When renames happen outside the editor — a manual rename in Visual Studio, a Git move, a header refactor — no redirector is created. The asset registry has no breadcrumb from old name to new name.

UCLASS metadata cached in the editor. The editor caches UClass pointers on Blueprint nodes and in the Class Defaults. Renaming the C++ class invalidates the pointer but the cache is not flushed until the Blueprint is recompiled with explicit interface re-assignment.

Hot reload does not handle interface renames. Live Coding and Hot Reload patch function bodies but do not migrate asset references. UINTERFACE renames are particularly fragile because the IInterface and UInterface halves both need to be re-registered. Hot reload registers the new class as a sibling rather than replacing the old one, leaving the asset registry pointing at a class that no longer exists in the active module.

The Fix

Step 1: Cold rebuild with regenerated project files. Close the editor entirely — not just the project, the whole UnrealEditor process. Right-click the .uproject file and choose Generate Visual Studio Project Files. Open the solution and do a full Rebuild of the editor target, not an incremental Build. This guarantees the new UINTERFACE is the only one registered when the editor starts.

// Define both halves of the renamed interface explicitly
UINTERFACE(MinimalAPI, BlueprintType)
class UInteractableObject : public UInterface
{
    GENERATED_BODY()
};

class MYGAME_API IInteractableObject
{
    GENERATED_BODY()

public:
    UFUNCTION(BlueprintNativeEvent, BlueprintCallable,
        Category = "Interaction")
    void OnInteract(AActor* Instigator);

    // Provide a default native impl so BPs without override compile
    virtual void OnInteract_Implementation(AActor* Instigator)
    {
        UE_LOG(LogTemp, Verbose,
            TEXT("Default OnInteract on %s"),
            *GetNameSafe(Instigator));
    }
};

The MinimalAPI specifier on the U-prefixed class and the explicit _Implementation body matter here. If either is missing, the Blueprint reflection fails to register the interface as available for implementation, and the rename will appear to have worked at compile time but silently fail in the editor.

Step 2: Run the FixupRedirects commandlet. From a terminal at the project root, run the resave commandlet with the redirect-fixup flag. This loads every package, follows any redirectors, and resaves each asset with the new class path baked in directly.

// In your project's Build.cs, expose a helper for tooling
void AInteractionDebugger::VerifyAllImplementers()
{
    int32 Found = 0;
    for (TActorIterator<AActor> It(GetWorld()); It; ++It)
    {
        AActor* Actor = *It;
        if (Actor->GetClass()->ImplementsInterface(
            UInteractableObject::StaticClass()))
        {
            ++Found;
            UE_LOG(LogTemp, Log,
                TEXT("OK: %s implements IInteractableObject"),
                *Actor->GetName());
        }
    }

    UE_LOG(LogTemp, Log,
        TEXT("Verified %d implementers"), Found);
}

Call VerifyAllImplementers from a console command after running FixupRedirects. If the count matches what you expect, the rename has propagated through the asset registry. If the count is zero, the redirectors did not resolve and you need to manually re-add the interface on the affected Blueprints.

When the Asset Registry Is Permanently Stuck

Sometimes the redirector commandlet cannot find a path because the old UINTERFACE no longer exists in any module — you renamed it before generating a redirector. In that case the only reliable path is manual re-assignment. Open each affected Blueprint, navigate to Class Settings, locate the missing interface entry (it will be highlighted with a warning icon), remove it, then add the new interface name from the dropdown. Save, recompile, and the cached UClass pointer rebinds to the live class.

For C++ classes that implement the interface, the fix is automatic once you rebuild from a cold start. The GENERATED_BODY() macro re-registers the interface implementation list during reflection generation. The only caveat is that any Blueprint subclasses of those C++ classes still need to be opened and resaved to refresh their inherited interface list.

Preventing This in the Future

Rename UINTERFACE classes from inside the editor when possible. Right-click the C++ class in the Content Browser and choose Rename. The editor generates a redirector automatically and updates the asset registry in the same operation. If you must rename in source control, leave a forwarding typedef behind for one release cycle so existing assets continue to load while you migrate them.

“A UINTERFACE rename is not just a code change — it is an asset migration. Treat it like a database schema change: write a migration step, run it, verify it, and only then delete the old name.”

Related Issues

If your interface compiles but Blueprint message calls do nothing at runtime, see Blueprint Interface Message Not Firing for the dispatch and override checklist. If renames cause widespread asset corruption beyond interfaces, check Asset Registry Stale References for full registry rebuild steps.

Always rename UINTERFACE classes from the editor — redirectors are easier to fix than missing ones.