Fix: Godot call_deferred Not Executing

Here is how to fix Godot call_deferred not executing. You call some_node.call_deferred("my_method") during a physics callback, expecting the method to run later in the frame. It never runs. No error in the output, no crash — just silence. Deferred calls in Godot have specific timing guarantees and failure modes that are easy to hit without understanding the frame lifecycle.

The Symptom

A function passed to call_deferred() never executes. No error appears in the output panel. The behavior that the deferred call was supposed to trigger (removing a node, changing a property, starting a timer) simply does not happen.

Variant: the deferred call works on the first occurrence but fails on subsequent ones. Or it works in the editor but not in an exported build. Or set_deferred() on a property has no effect.

What Causes This

Node freed before deferred call runs. call_deferred() schedules the method to run at the end of the current frame’s idle processing. If you call queue_free() on the same node in the same frame, the node is freed at the end of the frame, potentially before or at the same time as the deferred call. The call is discarded because the target object no longer exists.

Node not in the SceneTree. If a node has been removed from the tree via remove_child() but not freed, deferred calls still work — but only if the node is still a valid Object. However, methods that depend on being in the tree (like accessing get_tree()) will fail inside the deferred call.

Method name typo. call_deferred("my_methd") silently fails if the method does not exist. Godot 4 prints a warning to the output, but it is easy to miss among other output. Unlike direct calls, deferred calls do not produce a script error at the call site.

Callable syntax confusion. In Godot 4, you can also use the Callable approach: my_method.call_deferred(). This is different from call_deferred("my_method"). If you mix up the syntax, the call may target the wrong object or method.

Calling during _notification(NOTIFICATION_PREDELETE). If you schedule a deferred call during object destruction, the object is already being deleted and the call is never processed.

The Fix

Step 1: Guard against freed nodes. Before using call_deferred on a node that might be freed, check validity:

func _on_enemy_hit(enemy: Node2D):
    # Schedule removal at end of frame
    enemy.call_deferred("queue_free")

    # Do NOT also call queue_free directly — pick one
    # enemy.queue_free()  # This + call_deferred = double free attempt

If you need to both do something to the node and free it, order matters. The deferred call runs before queue_free’s deferred deletion:

func _on_projectile_hit(target: Node2D):
    # This runs first (deferred)
    target.call_deferred("take_damage", 50)
    # This runs after (also deferred, queued second)
    target.call_deferred("queue_free")

Step 2: Use Callable syntax for type safety. The Callable approach avoids string typos:

# String method name — typos are silent failures
call_deferred("update_health_bar")

# Callable — caught by the editor if method doesn't exist
update_health_bar.call_deferred()

The Callable version also supports arguments naturally:

func apply_effect(effect_name: String, duration: float):
    print("Applying: ", effect_name)

# Deferred with arguments
apply_effect.call_deferred("burn", 3.0)

Step 3: Use set_deferred for property changes during physics. The most common use case for deferred calls is changing collision properties during a physics callback:

func _on_body_entered(body: Node2D):
    # Cannot disable collision shape during physics callback
    # $CollisionShape2D.disabled = true  # ERROR

    # Correct: defer the property change
    $CollisionShape2D.set_deferred("disabled", true)

Godot explicitly prevents modifying physics state during physics callbacks. set_deferred() delays the change to idle time, when it is safe.

Step 4: Verify node is in tree if needed. If your deferred method accesses tree-dependent functions:

func deferred_spawn():
    if not is_inside_tree():
        return

    var bullet = bullet_scene.instantiate()
    get_tree().current_scene.add_child(bullet)

Timing: When Deferred Calls Actually Run

Godot’s frame loop in order:

• Input events processed
• _process(delta) on all nodes
• _physics_process(delta) (may run 0, 1, or multiple times)
• Deferred calls execute (idle time)
• queue_free() deletions happen
• Frame rendered

This means a deferred call scheduled in _process runs later in the same frame, not the next frame. If you need next-frame execution, use await get_tree().process_frame instead.

# Runs later this frame
do_something.call_deferred()

# Runs next frame
await get_tree().process_frame
do_something()

“Deferred means later this frame, not next frame. If the node is gone by then, so is the call.”

Related Issues

For signal timing issues, see Await Signal Never Completing. For physics callback restrictions, Area2D Not Detecting StaticBody2D covers related collision timing patterns.

Node must be alive when idle time arrives. Use Callable syntax to avoid typos. set_deferred for physics properties.