diff --git a/core/object/class_db.cpp b/core/object/class_db.cpp
index bf1bd0de93ad..43ebbddc606e 100644
--- a/core/object/class_db.cpp
+++ b/core/object/class_db.cpp
@@ -1091,6 +1091,14 @@ void ClassDB::add_property(const StringName &p_class, const PropertyInfo &p_pinf
 	OBJTYPE_WLOCK
 
 	type->property_list.push_back(p_pinfo);
+	if (p_pinfo.type == Variant::OBJECT) {
+		type->resource_properties.push_back(p_pinfo.name);
+	} else if (p_pinfo.type == Variant::ARRAY) {
+		type->array_properties.push_back(p_pinfo.name);
+	} else if (p_pinfo.type == Variant::DICTIONARY) {
+		type->dict_properties.push_back(p_pinfo.name);
+	}
+
 	type->property_map[p_pinfo.name] = p_pinfo;
 #ifdef DEBUG_METHODS_ENABLED
 	if (mb_get) {
@@ -1852,4 +1860,45 @@ void ClassDB::cleanup() {
 	native_structs.clear();
 }
 
-//
+void ClassDB::tag_collect_pass(Object *p_object, uint32_t p_pass, bool p_containers) {
+	ClassInfo *check = classes.getptr(p_object->get_class_name());
+	while (check) {
+		for (uint32_t i = 0; i < check->resource_properties.size(); i++) {
+			Ref<Resource> res = p_object->get(check->resource_properties[i]);
+			if (res.is_valid()) {
+				res->tag_collect_pass(p_pass, p_containers);
+			}
+		}
+		if (p_containers) {
+			for (uint32_t i = 0; i < check->dict_properties.size(); i++) {
+				Dictionary dict = p_object->get(check->dict_properties[i]);
+				dict.tag_collect_pass(p_pass, p_containers);
+			}
+
+			for (uint32_t i = 0; i < check->array_properties.size(); i++) {
+				Array arr = p_object->get(check->array_properties[i]);
+				arr.tag_collect_pass(p_pass, p_containers);
+			}
+		}
+		check = check->inherits_ptr;
+	}
+}
+
+void ClassDB::unlink_resources(Object *p_object, bool p_containers) {
+	ClassInfo *check = classes.getptr(p_object->get_class_name());
+	while (check) {
+		for (uint32_t i = 0; i < check->resource_properties.size(); i++) {
+			p_object->set(check->resource_properties[i], Ref<Resource>());
+		}
+		if (p_containers) {
+			for (uint32_t i = 0; i < check->dict_properties.size(); i++) {
+				p_object->set(check->dict_properties[i], Dictionary());
+			}
+
+			for (uint32_t i = 0; i < check->array_properties.size(); i++) {
+				p_object->set(check->array_properties[i], Array());
+			}
+		}
+		check = check->inherits_ptr;
+	}
+}
diff --git a/core/object/class_db.h b/core/object/class_db.h
index 7a4ee1afa451..15ca37e035c5 100644
--- a/core/object/class_db.h
+++ b/core/object/class_db.h
@@ -116,6 +116,12 @@ class ClassDB {
 		HashMap<StringName, MethodInfo> signal_map;
 		List<PropertyInfo> property_list;
 		HashMap<StringName, PropertyInfo> property_map;
+
+		// For tagging
+		LocalVector<StringName> resource_properties;
+		LocalVector<StringName> array_properties;
+		LocalVector<StringName> dict_properties;
+
 #ifdef DEBUG_METHODS_ENABLED
 		List<StringName> constant_order;
 		List<StringName> method_order;
@@ -450,6 +456,9 @@ class ClassDB {
 	static void get_native_struct_list(List<StringName> *r_names);
 	static String get_native_struct_code(const StringName &p_name);
 	static uint64_t get_native_struct_size(const StringName &p_name); // Used for asserting
+
+	static void tag_collect_pass(Object *object, uint32_t p_pass, bool p_containers);
+	static void unlink_resources(Object *p_object, bool p_containers);
 };
 
 #define BIND_ENUM_CONSTANT(m_constant) \
diff --git a/core/object/object.cpp b/core/object/object.cpp
index 05a6ac6cee89..a83e7c42310f 100644
--- a/core/object/object.cpp
+++ b/core/object/object.cpp
@@ -857,20 +857,25 @@ void Object::notification(int p_notification, bool p_reversed) {
 }
 
 String Object::to_string() {
+	String id = itos(get_instance_id());
 	if (script_instance) {
 		bool valid;
 		String ret = script_instance->to_string(&valid);
 		if (valid) {
 			return ret;
 		}
+		if (script_instance->get_script().is_valid()) {
+			id = script_instance->get_script()->get_script_name();
+		}
 	}
+
 	if (_extension && _extension->to_string) {
 		String ret;
 		GDExtensionBool is_valid;
 		_extension->to_string(_extension_instance, &is_valid, &ret);
 		return ret;
 	}
-	return "<" + get_class() + "#" + itos(get_instance_id()) + ">";
+	return "<" + get_class() + "#" + id + ">";
 }
 
 void Object::set_script_and_instance(const Variant &p_script, ScriptInstance *p_instance) {
@@ -2068,6 +2073,34 @@ void ObjectDB::debug_objects(DebugFunc p_func) {
 	spin_lock.unlock();
 }
 
+void Object::tag_collect_pass(uint32_t p_pass, bool p_collect_containers) {
+	if (collect_pass == p_pass) {
+		return; // Already collected.
+	}
+
+	collect_pass = p_pass; // Mark beforehand due to recursion.
+
+	if (script_instance) {
+		script_instance->tag_collect_pass(p_pass, p_collect_containers);
+		Ref<Script> scr = script;
+		if (scr.is_valid()) {
+			scr->tag_collect_pass(p_pass, p_collect_containers);
+		}
+	}
+
+	ClassDB::tag_collect_pass(this, p_pass, p_collect_containers);
+
+	_tag_collect_pass_customv(p_pass, p_collect_containers);
+
+	for (const KeyValue<StringName, Variant> &K : metadata) {
+		K.value.tag_collect_pass(p_pass, p_collect_containers);
+	}
+}
+
+void Object::unlink_resources(bool p_collect_containers) {
+	ClassDB::unlink_resources(this, p_collect_containers);
+}
+
 void Object::get_argument_options(const StringName &p_function, int p_idx, List<String> *r_options) const {
 	if (p_idx == 0) {
 		if (p_function == "connect" || p_function == "is_connected" || p_function == "disconnect" || p_function == "emit_signal" || p_function == "has_signal") {
@@ -2243,3 +2276,20 @@ void ObjectDB::cleanup() {
 		memfree(object_slots);
 	}
 }
+
+void ObjectDB::fetch_unliked_objects(uint32_t p_collect_pass, List<ObjectID> &r_unlinked) {
+	spin_lock.lock();
+	for (uint32_t i = 0, count = slot_count; i < slot_max && count != 0; i++) {
+		if (object_slots[i].validator) {
+			if (object_slots[i].object->get_collect_pass() != p_collect_pass) {
+				uint64_t id = object_slots[i].validator;
+				id <<= OBJECTDB_SLOT_MAX_COUNT_BITS;
+				id |= uint64_t(i);
+
+				r_unlinked.push_back(ObjectID(id));
+			}
+			count--;
+		}
+	}
+	spin_lock.unlock();
+}
diff --git a/core/object/object.h b/core/object/object.h
index d697f14b7e8c..42cbb81a16c8 100644
--- a/core/object/object.h
+++ b/core/object/object.h
@@ -524,6 +524,15 @@ protected:
 			_validate_property(p_property);                                                                                                      \
 		}                                                                                                                                        \
 	}                                                                                                                                            \
+	_FORCE_INLINE_ void (Object::*_get_tag_collect_pass_custom() const)(uint32_t p_pass, bool p_containers) const {                              \
+		return (void(Object::*)(uint32_t, bool) const) & m_class::_tag_collect_pass_custom;                                                      \
+	}                                                                                                                                            \
+	virtual void _tag_collect_pass_customv(uint32_t p_pass, bool p_containers) const override {                                                  \
+		m_inherits::_tag_collect_pass_customv(p_pass, p_containers);                                                                             \
+		if (m_class::_get_tag_collect_pass_custom() != m_inherits::_get_tag_collect_pass_custom()) {                                             \
+			_tag_collect_pass_custom(p_pass, p_containers);                                                                                      \
+		}                                                                                                                                        \
+	}                                                                                                                                            \
 	_FORCE_INLINE_ bool (Object::*_get_property_can_revert() const)(const StringName &p_name) const {                                            \
 		return (bool(Object::*)(const StringName &) const) & m_class::_property_can_revert;                                                      \
 	}                                                                                                                                            \
@@ -634,6 +643,7 @@ class Object {
 	uint32_t _edited_version = 0;
 	HashSet<String> editor_section_folding;
 #endif
+	uint32_t collect_pass = 0;
 	ScriptInstance *script_instance = nullptr;
 	Variant script; // Reference does not exist yet, store it in a Variant.
 	HashMap<StringName, Variant> metadata;
@@ -693,6 +703,7 @@ class Object {
 	virtual bool _getv(const StringName &p_name, Variant &r_property) const { return false; };
 	virtual void _get_property_listv(List<PropertyInfo> *p_list, bool p_reversed) const {};
 	virtual void _validate_propertyv(PropertyInfo &p_property) const {};
+	virtual void _tag_collect_pass_customv(uint32_t p_pass, bool p_containers) const {};
 	virtual bool _property_can_revertv(const StringName &p_name) const { return false; };
 	virtual bool _property_get_revertv(const StringName &p_name, Variant &r_property) const { return false; };
 	virtual void _notificationv(int p_notification, bool p_reversed) {}
@@ -703,6 +714,7 @@ class Object {
 	bool _get(const StringName &p_name, Variant &r_property) const { return false; };
 	void _get_property_list(List<PropertyInfo> *p_list) const {};
 	void _validate_property(PropertyInfo &p_property) const {};
+	void _tag_collect_pass_custom(uint32_t p_pass, bool p_containers) const {};
 	bool _property_can_revert(const StringName &p_name) const { return false; };
 	bool _property_get_revert(const StringName &p_name, Variant &r_property) const { return false; };
 	void _notification(int p_notification) {}
@@ -725,6 +737,9 @@ class Object {
 	_FORCE_INLINE_ void (Object::*_get_validate_property() const)(PropertyInfo &p_property) const {
 		return &Object::_validate_property;
 	}
+	_FORCE_INLINE_ void (Object::*_get_tag_collect_pass_custom() const)(uint32_t p_pass, bool p_containers) const {
+		return &Object::_tag_collect_pass_custom;
+	}
 	_FORCE_INLINE_ bool (Object::*_get_property_can_revert() const)(const StringName &p_name) const {
 		return &Object::_property_can_revert;
 	}
@@ -985,6 +1000,10 @@ class Object {
 
 	void cancel_free();
 
+	void tag_collect_pass(uint32_t p_pass, bool p_collect_containers = false);
+	_FORCE_INLINE_ uint32_t get_collect_pass() const { return collect_pass; }
+	virtual void unlink_resources(bool p_collect_containers = false);
+
 	Object();
 	virtual ~Object();
 };
@@ -1047,6 +1066,9 @@ class ObjectDB {
 
 		return object;
 	}
+
+	static void fetch_unliked_objects(uint32_t p_collect_pass, List<ObjectID> &r_unlinked);
+
 	static void debug_objects(DebugFunc p_func);
 	static int get_object_count();
 };
diff --git a/core/object/script_instance.h b/core/object/script_instance.h
index df978a25ea22..33166cde02bc 100644
--- a/core/object/script_instance.h
+++ b/core/object/script_instance.h
@@ -91,6 +91,8 @@ class ScriptInstance {
 
 	virtual const Variant get_rpc_config() const;
 
+	virtual void tag_collect_pass(uint32_t p_pass, bool p_collect_containers = false) {}
+
 	virtual ScriptLanguage *get_language() = 0;
 	virtual ~ScriptInstance();
 };
diff --git a/core/object/script_language.cpp b/core/object/script_language.cpp
index e72506256a0e..7b751a22e736 100644
--- a/core/object/script_language.cpp
+++ b/core/object/script_language.cpp
@@ -46,6 +46,17 @@ bool ScriptServer::scripting_enabled = true;
 bool ScriptServer::reload_scripts_on_save = false;
 ScriptEditRequestFunction ScriptServer::edit_request_func = nullptr;
 
+String Script::get_script_name() const {
+	if (get_global_name() != StringName()) {
+		return get_global_name();
+	} else if (!get_path().is_empty()) {
+		return get_path().get_file();
+	} else if (!get_name().is_empty()) {
+		return get_name(); // Resource name.
+	}
+	return get_class();
+}
+
 void Script::_notification(int p_what) {
 	switch (p_what) {
 		case NOTIFICATION_POSTINITIALIZE: {
@@ -747,6 +758,19 @@ Variant PlaceHolderScriptInstance::property_get_fallback(const StringName &p_nam
 	return Variant();
 }
 
+void PlaceHolderScriptInstance::tag_collect_pass(uint32_t p_pass, bool p_collect_containers) {
+	if (collect_pass == p_pass) {
+		return;
+	}
+
+	collect_pass = p_pass; // Tag beforehand due to recursion.
+
+	for (const KeyValue<StringName, Variant> &E : values) {
+		const Variant &v = E.value;
+		v.tag_collect_pass(p_pass, p_collect_containers);
+	}
+}
+
 PlaceHolderScriptInstance::PlaceHolderScriptInstance(ScriptLanguage *p_language, Ref<Script> p_script, Object *p_owner) :
 		owner(p_owner),
 		language(p_language),
diff --git a/core/object/script_language.h b/core/object/script_language.h
index 85e64c8d62bd..b1316fda17d1 100644
--- a/core/object/script_language.h
+++ b/core/object/script_language.h
@@ -126,6 +126,7 @@ class Script : public Resource {
 public:
 	virtual bool can_instantiate() const = 0;
 
+	virtual String get_script_name() const;
 	virtual Ref<Script> get_base_script() const = 0; //for script inheritance
 	virtual StringName get_global_name() const = 0;
 	virtual bool inherits_script(const Ref<Script> &p_script) const = 0;
@@ -409,6 +410,7 @@ class PlaceHolderScriptInstance : public ScriptInstance {
 	HashMap<StringName, Variant> constants;
 	ScriptLanguage *language = nullptr;
 	Ref<Script> script;
+	uint32_t collect_pass = 0;
 
 public:
 	virtual bool set(const StringName &p_name, const Variant &p_value) override;
@@ -444,6 +446,8 @@ class PlaceHolderScriptInstance : public ScriptInstance {
 
 	virtual const Variant get_rpc_config() const override { return Variant(); }
 
+	virtual void tag_collect_pass(uint32_t p_pass, bool p_collect_containers = false) override;
+
 	PlaceHolderScriptInstance(ScriptLanguage *p_language, Ref<Script> p_script, Object *p_owner);
 	~PlaceHolderScriptInstance();
 };
diff --git a/core/variant/array.cpp b/core/variant/array.cpp
index ab0315ae3456..b4af5b6fea90 100644
--- a/core/variant/array.cpp
+++ b/core/variant/array.cpp
@@ -47,8 +47,28 @@ class ArrayPrivate {
 	Vector<Variant> array;
 	Variant *read_only = nullptr; // If enabled, a pointer is used to a temporary value that is used to return read-only values.
 	ContainerTypeValidate typed;
+	uint32_t collect_pass = 0;
 };
 
+void Array::tag_collect_pass(uint32_t p_pass, bool p_collect_containers) const {
+	if (_p->collect_pass == p_pass) {
+		return;
+	}
+
+	_p->collect_pass = p_pass; // Mark beforehand due to recursion.
+
+	if (_p->typed.type != Variant::OBJECT && _p->typed.type != Variant::DICTIONARY && _p->typed.type != Variant::ARRAY && _p->typed.type != Variant::NIL) {
+		// None of these types will contain objects, so do not do anything here.
+		return;
+	}
+
+	int len = _p->array.size();
+	const Variant *arr = _p->array.ptr();
+	for (int i = 0; i < len; i++) {
+		arr[i].tag_collect_pass(p_pass, p_collect_containers);
+	}
+}
+
 void Array::_ref(const Array &p_from) const {
 	ArrayPrivate *_fp = p_from._p;
 
diff --git a/core/variant/array.h b/core/variant/array.h
index 8b1f8c067816..e4921d3f41b1 100644
--- a/core/variant/array.h
+++ b/core/variant/array.h
@@ -129,6 +129,8 @@ class Array {
 	void make_read_only();
 	bool is_read_only() const;
 
+	void tag_collect_pass(uint32_t p_pass, bool p_collect_containers = false) const;
+
 	Array(const Array &p_base, uint32_t p_type, const StringName &p_class_name, const Variant &p_script);
 	Array(const Array &p_from);
 	Array();
diff --git a/core/variant/dictionary.cpp b/core/variant/dictionary.cpp
index 141ce25fa6e2..7663472bc932 100644
--- a/core/variant/dictionary.cpp
+++ b/core/variant/dictionary.cpp
@@ -43,8 +43,26 @@ struct DictionaryPrivate {
 	SafeRefCount refcount;
 	Variant *read_only = nullptr; // If enabled, a pointer is used to a temporary value that is used to return read-only values.
 	HashMap<Variant, Variant, VariantHasher, StringLikeVariantComparator> variant_map;
+	uint32_t collect_pass = 0;
 };
 
+void Dictionary::tag_collect_pass(uint32_t p_pass, bool p_collect_containers) const {
+	if (_p->collect_pass == p_pass) {
+		return;
+	}
+
+	/* Add typed dictionary check here eventually */
+
+	_p->collect_pass = p_pass; // Mark beforehand due to recursion.
+
+	for (const KeyValue<Variant, Variant> &E : _p->variant_map) {
+		for (int i = 0; i < 2; i++) {
+			const Variant &v = i == 0 ? E.key : E.value;
+			v.tag_collect_pass(p_pass, p_collect_containers);
+		}
+	}
+}
+
 void Dictionary::get_key_list(List<Variant> *p_keys) const {
 	if (_p->variant_map.is_empty()) {
 		return;
diff --git a/core/variant/dictionary.h b/core/variant/dictionary.h
index 8935d35ed910..cec81ddf5bc9 100644
--- a/core/variant/dictionary.h
+++ b/core/variant/dictionary.h
@@ -91,6 +91,8 @@ class Dictionary {
 
 	const void *id() const;
 
+	void tag_collect_pass(uint32_t p_pass, bool p_collect_containers) const;
+
 	Dictionary(const Dictionary &p_from);
 	Dictionary();
 	~Dictionary();
diff --git a/core/variant/variant.cpp b/core/variant/variant.cpp
index 4c0212075b0d..84bdb52aca93 100644
--- a/core/variant/variant.cpp
+++ b/core/variant/variant.cpp
@@ -3708,6 +3708,13 @@ String Variant::get_callable_error_text(const Callable &p_callable, const Varian
 	}
 }
 
+void Variant::_tag_collect_pass_object(uint32_t p_pass, bool p_collect_containers) const {
+	Object *instance = ObjectDB::get_instance(_get_obj().id);
+	if (instance) {
+		instance->tag_collect_pass(p_pass, p_collect_containers);
+	}
+}
+
 void Variant::register_types() {
 	_register_variant_operators();
 	_register_variant_methods();
diff --git a/core/variant/variant.h b/core/variant/variant.h
index 480f21df987b..27b9fb904579 100644
--- a/core/variant/variant.h
+++ b/core/variant/variant.h
@@ -326,6 +326,8 @@ class Variant {
 	Variant(const Variant *) {}
 	Variant(const Variant **) {}
 
+	void _tag_collect_pass_object(uint32_t p_pass, bool p_collect_containers) const;
+
 public:
 	_FORCE_INLINE_ Type get_type() const {
 		return type;
@@ -783,6 +785,18 @@ class Variant {
 	static void register_types();
 	static void unregister_types();
 
+	_FORCE_INLINE_ void tag_collect_pass(uint32_t p_pass, bool p_collect_containers = false) const {
+		if (type == OBJECT) {
+			_tag_collect_pass_object(p_pass, p_collect_containers);
+		} else if (p_collect_containers) {
+			if (type == ARRAY) {
+				reinterpret_cast<const Array *>(_data._mem)->tag_collect_pass(p_pass, p_collect_containers);
+			} else if (type == DICTIONARY) {
+				reinterpret_cast<const Dictionary *>(_data._mem)->tag_collect_pass(p_pass, p_collect_containers);
+			}
+		}
+	}
+
 	Variant(const Variant &p_variant);
 	_FORCE_INLINE_ Variant() {}
 	_FORCE_INLINE_ ~Variant() {
diff --git a/modules/gdscript/gdscript.cpp b/modules/gdscript/gdscript.cpp
index 76dcb02af880..66dfcc65ac9c 100644
--- a/modules/gdscript/gdscript.cpp
+++ b/modules/gdscript/gdscript.cpp
@@ -1306,6 +1306,24 @@ void GDScript::_get_dependencies(RBSet<GDScript *> &p_dependencies, const GDScri
 	}
 }
 
+void GDScript::_tag_collect_pass_custom(uint32_t p_pass, bool p_containers) const {
+	for (int i = 0; i < static_variables.size(); i++) {
+		static_variables[i].tag_collect_pass(p_pass, p_containers);
+	}
+
+	for (const KeyValue<StringName, Variant> &K : constants) {
+		K.value.tag_collect_pass(p_pass, p_containers);
+	}
+
+	for (const KeyValue<StringName, Ref<GDScript>> &SC : subclasses) {
+		SC.value->tag_collect_pass(p_pass, p_containers);
+	}
+
+	for (const KeyValue<StringName, GDScriptFunction *> &F : member_functions) {
+		F.value->tag_collect_pass(p_pass, p_containers);
+	}
+}
+
 GDScript::GDScript() :
 		script_list(this) {
 	{
@@ -1358,6 +1376,13 @@ void GDScript::_save_orphaned_subclasses(ClearData *p_clear_data) {
 	}
 }
 
+String GDScript::get_script_name() const {
+	if (get_local_name() != StringName()) {
+		return get_local_name();
+	}
+	return get_fully_qualified_name().get_file();
+}
+
 #ifdef DEBUG_ENABLED
 String GDScript::debug_get_script_name(const Ref<Script> &p_script) {
 	if (p_script.is_valid()) {
@@ -1973,6 +1998,21 @@ const Variant GDScriptInstance::get_rpc_config() const {
 	return script->get_rpc_config();
 }
 
+void GDScriptInstance::tag_collect_pass(uint32_t p_pass, bool p_collect_containers) {
+	if (collect_pass == p_pass) {
+		return;
+	}
+
+	collect_pass = p_pass; // Set beforehand due to recursion.
+
+	int mb_count = members.size();
+	const Variant *mb = members.ptr();
+
+	for (int i = 0; i < mb_count; i++) {
+		mb[i].tag_collect_pass(p_pass, p_collect_containers);
+	}
+}
+
 void GDScriptInstance::reload_members() {
 #ifdef DEBUG_ENABLED
 
diff --git a/modules/gdscript/gdscript.h b/modules/gdscript/gdscript.h
index 2a71c2742925..4cd7bf1a85b9 100644
--- a/modules/gdscript/gdscript.h
+++ b/modules/gdscript/gdscript.h
@@ -228,6 +228,8 @@ class GDScript : public Script {
 	static String debug_get_script_name(const Ref<Script> &p_script);
 #endif
 
+	virtual String get_script_name() const override;
+
 	_FORCE_INLINE_ StringName get_local_name() const { return local_name; }
 
 	void clear(GDScript::ClearData *p_clear_data = nullptr);
@@ -327,6 +329,8 @@ class GDScript : public Script {
 	virtual bool is_placeholder_fallback_enabled() const override { return placeholder_fallback_enabled; }
 #endif
 
+	void _tag_collect_pass_custom(uint32_t p_pass, bool p_containers) const;
+
 	GDScript();
 	~GDScript();
 };
@@ -349,6 +353,8 @@ class GDScriptInstance : public ScriptInstance {
 	Vector<Variant> members;
 	bool base_ref_counted;
 
+	uint32_t collect_pass = 0;
+
 	SelfList<GDScriptFunctionState>::List pending_func_states;
 
 public:
@@ -382,6 +388,8 @@ class GDScriptInstance : public ScriptInstance {
 
 	virtual const Variant get_rpc_config() const;
 
+	virtual void tag_collect_pass(uint32_t p_pass, bool p_collect_containers = false);
+
 	GDScriptInstance();
 	~GDScriptInstance();
 };
diff --git a/modules/gdscript/gdscript_function.h b/modules/gdscript/gdscript_function.h
index c9b543fbb934..d8ba5eb2154e 100644
--- a/modules/gdscript/gdscript_function.h
+++ b/modules/gdscript/gdscript_function.h
@@ -514,6 +514,12 @@ class GDScriptFunction {
 	void disassemble(const Vector<String> &p_code_lines) const;
 #endif
 
+	void tag_collect_pass(uint32_t p_pass, bool p_containers) {
+		for (int i = 0; i < constants.size(); i++) {
+			constants[i].tag_collect_pass(p_pass, p_containers);
+		}
+	}
+
 	GDScriptFunction();
 	~GDScriptFunction();
 };
diff --git a/scene/main/node.cpp b/scene/main/node.cpp
index 41056c86e8bf..9fedf1aa0685 100644
--- a/scene/main/node.cpp
+++ b/scene/main/node.cpp
@@ -51,6 +51,12 @@ int Node::orphan_node_count = 0;
 
 thread_local Node *Node::current_process_thread_group = nullptr;
 
+void Node::_tag_collect_pass_custom(uint32_t p_pass, bool p_containers) const {
+	for (const KeyValue<StringName, Node *> &K : data.children) {
+		K.value->tag_collect_pass(p_pass, p_containers);
+	}
+}
+
 void Node::_notification(int p_notification) {
 	switch (p_notification) {
 		case NOTIFICATION_PROCESS: {
diff --git a/scene/main/node.h b/scene/main/node.h
index cd1c31d784ce..241bf2174068 100644
--- a/scene/main/node.h
+++ b/scene/main/node.h
@@ -283,6 +283,7 @@ class Node : public Object {
 	void _block() { data.blocked++; }
 	void _unblock() { data.blocked--; }
 
+	void _tag_collect_pass_custom(uint32_t p_pass, bool p_containers) const;
 	void _notification(int p_notification);
 
 	virtual void add_child_notify(Node *p_child);
diff --git a/scene/main/scene_tree.cpp b/scene/main/scene_tree.cpp
index a28c2053beb9..e8a4dea1cf64 100644
--- a/scene/main/scene_tree.cpp
+++ b/scene/main/scene_tree.cpp
@@ -895,6 +895,59 @@ bool SceneTree::is_paused() const {
 	return paused;
 }
 
+int SceneTree::break_reference_cycles(bool p_scripts_only, bool p_collect_containers, bool p_verbose) {
+	static uint32_t pass = 1;
+	pass++;
+	tag_collect_pass(pass, p_collect_containers);
+
+	List<Engine::Singleton> singletons;
+	Engine::get_singleton()->get_singletons(&singletons);
+	for (const Engine::Singleton &S : singletons) {
+		S.ptr->tag_collect_pass(pass, p_collect_containers);
+	}
+	if (root) {
+		root->tag_collect_pass(pass, p_collect_containers);
+	}
+
+	List<ObjectID> collect_unlinked;
+	ObjectDB::fetch_unliked_objects(pass, collect_unlinked);
+
+	int unlinked_total = 0;
+
+	while (collect_unlinked.size()) {
+		Object *obj = ObjectDB::get_instance(collect_unlinked.front()->get());
+		if (obj) {
+			bool unlinked = false;
+			if (obj->get_script_instance()) {
+				if (p_verbose) {
+					print_line("Breaking cycle on: ", obj->to_string());
+				}
+
+				Ref<RefCounted> ref;
+				if (obj->is_ref_counted()) {
+					ref = Ref<RefCounted>(Object::cast_to<RefCounted>(obj)); // Keep a reference while breaking the link as this can cause a crash otherwise.
+				}
+				obj->set_script(Ref<Script>());
+				ref.unref();
+				unlinked = true;
+			}
+
+			if (!p_scripts_only) {
+				obj->unlink_resources(p_collect_containers);
+				unlinked = true;
+			}
+
+			if (unlinked) {
+				unlinked_total++;
+			}
+		}
+
+		collect_unlinked.pop_front();
+	}
+
+	return unlinked_total;
+}
+
 void SceneTree::_process_group(ProcessGroup *p_group, bool p_physics) {
 	// When reading this function, keep in mind that this code must work in a way where
 	// if any node is removed, this needs to continue working.
@@ -1632,6 +1685,8 @@ void SceneTree::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_multiplayer_poll_enabled", "enabled"), &SceneTree::set_multiplayer_poll_enabled);
 	ClassDB::bind_method(D_METHOD("is_multiplayer_poll_enabled"), &SceneTree::is_multiplayer_poll_enabled);
 
+	ClassDB::bind_method(D_METHOD("break_reference_cycles", "scripts_only", "collect_containers", "verbose"), &SceneTree::break_reference_cycles, DEFVAL(true), DEFVAL(false), DEFVAL(false));
+
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "auto_accept_quit"), "set_auto_accept_quit", "is_auto_accept_quit");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "quit_on_go_back"), "set_quit_on_go_back", "is_quit_on_go_back");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "debug_collisions_hint"), "set_debug_collisions_hint", "is_debugging_collisions_hint");
diff --git a/scene/main/scene_tree.h b/scene/main/scene_tree.h
index e1597d3890a2..3c23fb5605f1 100644
--- a/scene/main/scene_tree.h
+++ b/scene/main/scene_tree.h
@@ -335,6 +335,8 @@ class SceneTree : public MainLoop {
 	bool is_node_being_edited(const Node *p_node) const { return false; }
 #endif
 
+	int break_reference_cycles(bool p_scripts_only = true, bool p_collect_containers = false, bool p_verbose = false);
+
 	void set_pause(bool p_enabled);
 	bool is_paused() const;
 
diff --git a/servers/audio_server.cpp b/servers/audio_server.cpp
index f1848b0b9456..bd00fef867fc 100644
--- a/servers/audio_server.cpp
+++ b/servers/audio_server.cpp
@@ -1676,6 +1676,17 @@ void AudioServer::set_enable_tagging_used_audio_streams(bool p_enable) {
 	tag_used_audio_streams = p_enable;
 }
 
+void AudioServer::_tag_collect_pass_custom(uint32_t p_pass, bool p_containers) const {
+	for (int i = 0; i < buses.size(); i++) {
+		Bus *bus = buses[i];
+		for (int j = 0; j < bus->effects.size(); j++) {
+			if (bus->effects[j].effect.is_valid()) {
+				bus->effects[j].effect->tag_collect_pass(p_pass, p_containers);
+			}
+		}
+	}
+}
+
 void AudioServer::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_bus_count", "amount"), &AudioServer::set_bus_count);
 	ClassDB::bind_method(D_METHOD("get_bus_count"), &AudioServer::get_bus_count);
diff --git a/servers/audio_server.h b/servers/audio_server.h
index 9ffa95bc00e4..3e66432e98ee 100644
--- a/servers/audio_server.h
+++ b/servers/audio_server.h
@@ -299,6 +299,7 @@ class AudioServer : public Object {
 	void _driver_process(int p_frames, int32_t *p_buffer);
 
 protected:
+	void _tag_collect_pass_custom(uint32_t p_pass, bool p_containers) const;
 	static void _bind_methods();
 
 public: