I asked ChatGPT.

Me

In the Godot game engine, do nodes get garbage-collected?

ChatGPT

Each node in Godot keeps track of how many references are pointing to it. When the reference count drops to zero, meaning no other objects are referencing it, the node is automatically freed, and its memory is reclaimed. This process is known as automatic memory management through reference counting.

Me

But I thought that nodes in Godot are not reference-counted.

ChatGPT

Nodes are not reference-counted like objects in some other programming languages. Instead, they are managed using a mechanism called "reference ownership." Nodes can be owned by other nodes, and when a node is no longer owned by any other node (i.e., it is not part of the scene tree or owned by any other objects), it is considered for deallocation by the Godot engine. However, the engine does not use traditional reference counting for this purpose.

  • xyz replied to this.

    A node is not memory managed in any way except for deletion when its parent is deleted. You can easily cause memory leaks with nodes. Here's a quick example to try:

    extends Node
func _process(delta):
	for i in 100:
		Node.new()

    And here's the result:

    I could try this myself to get the answer, but what happens if you create a lot of detached nodes like that, and then stop creating them? Will they persist?

    • xyz replied to this.

      DaveTheCoder Why would engine care to hunt them down only when you stop creating them? Of course they will persist.

        DaveTheCoder There you go:

        extends Node
var itotal = 0
func _process(delta):
	if itotal < 1000000:
		for i in 1000:
			Node.new()
		itotal += 1000

          duane It was paraphrasing the documentation. Maybe that's the problem.

          Well, it did a very bad job with paraphrasing because the documentation states almost the opposite. Plus its output is not logically consistent. The first paragraph contradicts the following one.

              xyz

              Yes, it was using the generic word, node, in the first case, and the specific term, Node in the second, which no one should be expected to spot. I didn't see it myself until I read it again.

                Anyway to answer the OP directly @Sabir - queue_free() will purge the node and all of its children from memory as soon as the current frame processing is finished. free() will do it immediately. In fact queue_free() is just a deferred call to free(). And that call will vanish the object from ram 100% guaranteed. After that, all references to the node still held in your code will become invalid and using them will throw an exception.

                If you think something is not getting deleted while it should, use Godot's profiler to check if there are indeed some leaks. But you can rest assured that any leaks you may have are not caused by queue_free() somehow refusing to delete the nodes.

                xyz DaveTheCoder LOL 😃 Almost everything it "said" is not true.

                Never forget that a whole new generation of developers is getting raised by ChatGPT and will use it every opportunity they get which isn't a scary prospect at all. 😅

                • xyz replied to this.

                    Toxe I tend to rant about it from time to time but I get a lot of backlash, typically from people who have no clue about how LLMs operate. For reasons unbeknownst to me they fiercely defend the bot using all sorts of mental gymnastics. But seeing the severity of GPT's rambling, as shown in Dave's interaction, I think I better shut up. As a famous eastern philosopher used to say - never interfere when your enemy is busy making mistakes.
                    😛