Garbage Collection

Use IsValid(Obj) — it checks the pointer is non-null and the object is not pending kill or garbage. For a TWeakObjectPtr, call .IsValid(). A plain non-null check is not enough, since the pointer may dangle.

The root set is the UObjects the garbage collector treats as always reachable, such as rooted objects and key engine objects. GC starts there and keeps anything reachable from it; unreachable objects are destroyed.

A strong reference (UPROPERTY() raw pointer or TObjectPtr) keeps the target alive and is auto-nulled if it dies. A weak reference (TWeakObjectPtr) never keeps it alive and reports invalidity, so you must check before use.

TWeakObjectPtr is a non-owning pointer to a UObject that does not prevent garbage collection. Use it to reference an object you do not own, then check IsValid() — after the target dies it reports invalid, not dangling.

AddToRoot() adds a UObject directly to the GC root set, so it survives until you call RemoveFromRoot(). Abusing it creates permanent leaks: rooted objects and everything they reference are never collected.

Two UObjects holding strong UPROPERTY() pointers to each other form a cycle. Unlike reference counting, UE's mark-and-sweep GC still collects the cycle if it is unreachable from the root set, so it is not leaked.

Storing a UObject* without UPROPERTY() (the GC can't null it), caching a raw pointer across frames, or using an Actor after Destroy(). Non-UObject classes holding raw UObject* are another frequent source.

Destroy() marks the Actor for removal — it leaves the world, but memory is freed later by the GC, not instantly. delete frees memory at once; calling it on a UObject corrupts GC state, so never delete a UObject.

The GC is a periodic mark-and-sweep tracer. Starting from a root set, it follows UPROPERTY() references to mark all reachable UObjects; anything unreachable is marked pending kill and destroyed. It runs on a timer, not per allocation.

Keep it reachable from the root set: store it in a UPROPERTY(), add it to a TArray<TObjectPtr<>> member, or call AddToRoot() to make it a root directly. An object with no strong reference path is collected.

No. A UPROPERTY() strong pointer keeps the target alive only while the owning object is itself reachable. It also doesn't apply to weak UPROPERTY() members like TWeakObjectPtr, which never keep anything alive.

Use it when you want to reference an object without controlling its lifetime — caches, observers, or back-pointers to an owner. It avoids circular-reference leaks and lets you safely detect when the target has been destroyed.

GC only manages UObject-derived types (Actors, components, UObjects). Memory from raw new, malloc, or non-UObject structs like FString is invisible to it — you must free that yourself or use a smart pointer.

Every UObject has an Outer — the object that owns it, set at creation via NewObject. The Outer chain defines scope and naming; if the Outer is collected, its inner objects lose reachability and are collected too.

Read the callstack to find the dereferenced pointer and check whether it is a UPROPERTY(). A non-reflected pointer dangling after GC is the usual cause: the collector neither keeps the object alive nor nulls the pointer, so if (ptr) still passes on freed memory. Fix it by adding UPROPERTY() or using TWeakObjectPtr with an IsValid guard.

A GC pass traverses the whole reachable object graph, so cost scales with UObject count. A large graph can cause a visible frame hitch. UE mitigates this with incremental and clustered GC and tunable timing cvars.