Does cancelling LoadPackageAsync during PostLoad leave asset references in memory?

Direct Answer

Yes, but only temporarily. Cancelling LoadPackageAsync while PostLoad is executing leaves a strong reference to the loaded package and its objects in memory. The reference is held by the async loading subsystem, not by Unreal’s garbage collector. It is released automatically when the package’s cancellation cleanup runs on the game thread, after which the object becomes eligible for GC if no other references exist. This is a retention window, not an indefinite leak.

Expected Behavior vs. Likely Explanation

Expected behavior

• The async loader tracks loaded objects internally while a package is active.
• Cancellation is honored at yield points. If PostLoad is on the stack, cleanup waits until that call returns.
• After cleanup completes, the internal reference is dropped and the object can be collected.

Likely explanation

During PostLoad, object ownership is ambiguous: the object exists but may not yet be fully integrated into the package graph. The loader retains it to avoid touching partially initialized memory. Engine comments flag this as a known edge case, but the exact number of retained frames depends on engine version, platform, and how long PostLoad runs without yielding.

Steps for This Case

1. Confirm your engine version. UE4 uses FAsyncPackage; UE5 uses FAsyncPackage2, which has more deterministic cleanup but the same fundamental reference-holding pattern during PostLoad.
2. Do not cancel the async handle from inside PostLoad, and avoid cancelling immediately after starting the load on assets with expensive PostLoad overrides.
3. If cancellation is necessary, defer it until PostLoad finishes, or check loading state inside PostLoad and postpone cancellation-sensitive work.
4. Use obj refs or Unreal Insights during and after cancellation to verify whether the loader still roots the object.

Missing Diagnostic Detail

Which engine version are you targeting? UE4 and UE5 cleanup timing differs enough that the version changes whether you should rely on automatic teardown or restructure your cancellation flow.

Verification

obj refs YourAssetClass

Run this while the cancellation window is open, then again after a few frames. If the reference disappears and memory trends downward, the behavior matches the expected teardown pattern. Repeat load-cancel cycles on your target platform to check for OOM risk under rapid cancellation.

Assumption: this applies to standard Unreal Engine async package loading. Custom loaders or engine forks may behave differently, and the behavior should be verified on your specific engine build.