Live Coding vs Hot Reload for structural C++ changes

Question

When iterating on C++ base classes in Unreal Engine, choosing between Live Coding and Hot Reload impacts how the engine handles memory state. While both methods aim to update logic without a full editor restart, their internal mechanisms for binary-swapping differ significantly.
Live Coding utilizes a separate compilation process to patch functions in the running memory, which generally preserves the current state of the game world. However, it struggles with structural shifts such as deleting virtual functions or modifying the class hierarchy. Hot Reload attempts to swap binaries within the editor process but is frequently associated with memory corruption when header file structures are altered.
The trade-off becomes critical when a project requires moving beyond simple function body updates to changes that affect the class's layout.

What specific types of header modifications, such as deleting virtual functions or adding members, will Live Coding fail to resolve without a manual editor restart?
  To what extent does Hot Reload provide better stability for structural changes compared to Live Coding during iterative development?

Tasadduq Burney · Answer

Answer
Live Coding cannot apply header changes that alter a UClass or UObject memory layout; these modifications require a manual editor restart to take effect. Hot Reload does not provide better stability for structural changes—in modern versions of Unreal Engine, it is deprecated and carries a higher risk of memory corruption and editor crashes than Live Coding. For iterative development, use Live Coding for function-body updates and perform a full restart for any structural layout changes.

Confirmed Facts

Live Coding Limitations: It cannot safely patch in-memory objects when the class layout changes. Supported updates are limited to function body changes within an existing layout.
  Restart-Required Modifications: The following header changes will fail to resolve via Live Coding:
    
      Adding or removing UPROPERTY members.
      Changing member types, order, or alignment.
      Modifying the inheritance hierarchy.
      Adding, removing, or changing the signature of virtual functions.
      Changing the underlying type or size of an enum.

Hot Reload Status: Hot Reload is deprecated in modern Unreal Engine. It is prone to stale vtables and memory corruption when headers are altered, making it less reliable than Live Coding for structural iteration.

Likely Explanation
Live Coding compiles changed modules in a separate process and patches the running memory. While this preserves the game world state for logic changes, it cannot rebuild the physical layout of objects already allocated in memory. Hot Reload attempts to swap binaries within the editor process itself, which often leaves existing objects pointing to outdated memory layouts, leading to instability.

Recommended Workflow

Categorize the Change: Determine if the edit is "code-only" (logic inside a function) or "layout-affecting" (changes to members, inheritance, or virtual tables).
  Apply Logic Changes: Use Live Coding for code-only updates.
  Apply Structural Changes: Close the editor, compile via your IDE or build tool, and restart the editor.
  Avoid Hot Reload: Do not rely on Hot Reload for structural iteration in modern engine versions.

Assumption: This behavior is consistent across Unreal Engine 4.x and 5.x, though specific supported change sets may vary by minor version. Note that changes to UPROPERTY specifiers can be layout-affecting even if the C++ member type remains the same.

Missing Diagnostic Detail: To refine this recommendation, please provide the specific Unreal Engine version (e.g., 5.3) and confirm if both Live Coding and Hot Reload are currently enabled in your project settings.

Live Coding vs Hot Reload for structural C++ changes

1 answer

Answer

Confirmed Facts

Likely Explanation

Recommended Workflow

Your perspective belongs here.

1 question comment