Merge pull request #80284 from dsnopek/gdextension-hot-reload

Implement reloading of GDExtensions

core/config/engine.h

@@ -82,6 +82,7 @@ private:
 
 	bool editor_hint = false;
 	bool project_manager_hint = false;
+	bool extension_reloading = false;
 
 	static Engine *singleton;
 
@@ -140,12 +141,18 @@ public:
 
 	_FORCE_INLINE_ void set_project_manager_hint(bool p_enabled) { project_manager_hint = p_enabled; }
 	_FORCE_INLINE_ bool is_project_manager_hint() const { return project_manager_hint; }
+
+	_FORCE_INLINE_ void set_extension_reloading_enabled(bool p_enabled) { extension_reloading = p_enabled; }
+	_FORCE_INLINE_ bool is_extension_reloading_enabled() const { return extension_reloading; }
 #else
 	_FORCE_INLINE_ void set_editor_hint(bool p_enabled) {}
 	_FORCE_INLINE_ bool is_editor_hint() const { return false; }
 
 	_FORCE_INLINE_ void set_project_manager_hint(bool p_enabled) {}
 	_FORCE_INLINE_ bool is_project_manager_hint() const { return false; }
+
+	_FORCE_INLINE_ void set_extension_reloading_enabled(bool p_enabled) {}
+	_FORCE_INLINE_ bool is_extension_reloading_enabled() const { return false; }
 #endif
 
 	Dictionary get_version_info() const;

core/extension/gdextension.cpp

@@ -162,6 +162,14 @@ class GDExtensionMethodBind : public MethodBind {
 	List<PropertyInfo> arguments_info;
 	List<GodotTypeInfo::Metadata> arguments_metadata;
 
+#ifdef TOOLS_ENABLED
+	friend class GDExtension;
+
+	StringName name;
+	bool is_reloading = false;
+	bool valid = true;
+#endif
+
 protected:
 	virtual Variant::Type _gen_argument_type(int p_arg) const override {
 		if (p_arg < 0) {
@@ -179,6 +187,10 @@ protected:
 	}
 
 public:
+#ifdef TOOLS_ENABLED
+	virtual bool is_valid() const override { return valid; }
+#endif
+
 #ifdef DEBUG_METHODS_ENABLED
 	virtual GodotTypeInfo::Metadata get_argument_meta(int p_arg) const override {
 		if (p_arg < 0) {
@@ -190,6 +202,9 @@ public:
 #endif
 
 	virtual Variant call(Object *p_object, const Variant **p_args, int p_arg_count, Callable::CallError &r_error) const override {
+#ifdef TOOLS_ENABLED
+		ERR_FAIL_COND_V_MSG(!valid, Variant(), vformat("Cannot call invalid GDExtension method bind '%s'. It's probably cached - you may need to restart Godot.", name));
+#endif
 		Variant ret;
 		GDExtensionClassInstancePtr extension_instance = is_static() ? nullptr : p_object->_get_extension_instance();
 		GDExtensionCallError ce{ GDEXTENSION_CALL_OK, 0, 0 };
@@ -200,6 +215,9 @@ public:
 		return ret;
 	}
 	virtual void validated_call(Object *p_object, const Variant **p_args, Variant *r_ret) const override {
+#ifdef TOOLS_ENABLED
+		ERR_FAIL_COND_MSG(!valid, vformat("Cannot call invalid GDExtension method bind '%s'. It's probably cached - you may need to restart Godot.", name));
+#endif
 		ERR_FAIL_COND_MSG(vararg, "Validated methods don't have ptrcall support. This is most likely an engine bug.");
 		GDExtensionClassInstancePtr extension_instance = is_static() ? nullptr : p_object->_get_extension_instance();
 
@@ -234,6 +252,9 @@ public:
 	}
 
 	virtual void ptrcall(Object *p_object, const void **p_args, void *r_ret) const override {
+#ifdef TOOLS_ENABLED
+		ERR_FAIL_COND_MSG(!valid, vformat("Cannot call invalid GDExtension method bind '%s'. It's probably cached - you may need to restart Godot.", name));
+#endif
 		ERR_FAIL_COND_MSG(vararg, "Vararg methods don't have ptrcall support. This is most likely an engine bug.");
 		GDExtensionClassInstancePtr extension_instance = p_object->_get_extension_instance();
 		ptrcall_func(method_userdata, extension_instance, reinterpret_cast<GDExtensionConstTypePtr *>(p_args), (GDExtensionTypePtr)r_ret);
@@ -243,7 +264,43 @@ public:
 		return false;
 	}
 
-	explicit GDExtensionMethodBind(const GDExtensionClassMethodInfo *p_method_info) {
+#ifdef TOOLS_ENABLED
+	bool try_update(const GDExtensionClassMethodInfo *p_method_info) {
+		if (is_static() != (bool)(p_method_info->method_flags & GDEXTENSION_METHOD_FLAG_STATIC)) {
+			return false;
+		}
+
+		if (vararg != (bool)(p_method_info->method_flags & GDEXTENSION_METHOD_FLAG_VARARG)) {
+			return false;
+		}
+
+		if (has_return() != (bool)p_method_info->has_return_value) {
+			return false;
+		}
+
+		if (has_return() && return_value_info.type != (Variant::Type)p_method_info->return_value_info->type) {
+			return false;
+		}
+
+		if (argument_count != p_method_info->argument_count) {
+			return false;
+		}
+
+		for (uint32_t i = 0; i < p_method_info->argument_count; i++) {
+			if (arguments_info[i].type != (Variant::Type)p_method_info->arguments_info[i].type) {
+				return false;
+			}
+		}
+
+		update(p_method_info);
+		return true;
+	}
+#endif
+
+	void update(const GDExtensionClassMethodInfo *p_method_info) {
+#ifdef TOOLS_ENABLED
+		name = *reinterpret_cast<StringName *>(p_method_info->name);
+#endif
 		method_userdata = p_method_info->method_userdata;
 		call_func = p_method_info->call_func;
 		validated_call_func = nullptr;
@@ -255,6 +312,8 @@ public:
 			return_value_metadata = GodotTypeInfo::Metadata(p_method_info->return_value_metadata);
 		}
 
+		arguments_info.clear();
+		arguments_metadata.clear();
 		for (uint32_t i = 0; i < p_method_info->argument_count; i++) {
 			arguments_info.push_back(PropertyInfo(p_method_info->arguments_info[i]));
 			arguments_metadata.push_back(GodotTypeInfo::Metadata(p_method_info->arguments_metadata[i]));
@@ -279,6 +338,10 @@ public:
 
 		set_default_arguments(defargs);
 	}
+
+	explicit GDExtensionMethodBind(const GDExtensionClassMethodInfo *p_method_info) {
+		update(p_method_info);
+	}
 };
 
 #ifndef DISABLE_DEPRECATED
@@ -300,6 +363,7 @@ void GDExtension::_register_extension_class(GDExtensionClassLibraryPtr p_library
 		p_extension_funcs->unreference_func, // GDExtensionClassUnreference unreference_func;
 		p_extension_funcs->create_instance_func, // GDExtensionClassCreateInstance create_instance_func; /* this one is mandatory */
 		p_extension_funcs->free_instance_func, // GDExtensionClassFreeInstance free_instance_func; /* this one is mandatory */
+		nullptr, // GDExtensionClassRecreateInstance recreate_instance_func;
 		p_extension_funcs->get_virtual_func, // GDExtensionClassGetVirtual get_virtual_func;
 		nullptr, // GDExtensionClassGetVirtualCallData get_virtual_call_data_func;
 		nullptr, // GDExtensionClassCallVirtualWithData call_virtual_func;
@@ -341,15 +405,33 @@ void GDExtension::_register_extension_class_internal(GDExtensionClassLibraryPtr
 		ERR_FAIL_MSG("Attempt to register an extension class '" + String(class_name) + "' using non-existing parent class '" + String(parent_class_name) + "'");
 	}
 
+#ifdef TOOLS_ENABLED
+	Extension *extension = nullptr;
+	if (self->is_reloading && self->extension_classes.has(class_name)) {
+		extension = &self->extension_classes[class_name];
+		if (!parent_extension && parent_class_name != extension->gdextension.parent_class_name) {
+			ERR_FAIL_MSG(vformat("GDExtension class '%s' attempt to change parent type from '%s' to '%s' on hot reload. Restart Godot for this change to take effect.", class_name, extension->gdextension.parent_class_name, parent_class_name));
+		}
+		extension->is_reloading = false;
+	} else {
+		self->extension_classes[class_name] = Extension();
+		extension = &self->extension_classes[class_name];
+	}
+#else
 	self->extension_classes[class_name] = Extension();
-
 	Extension *extension = &self->extension_classes[class_name];
+#endif
 
 	if (parent_extension) {
 		extension->gdextension.parent = &parent_extension->gdextension;
 		parent_extension->gdextension.children.push_back(&extension->gdextension);
 	}
 
+	if (self->reloadable && p_extension_funcs->recreate_instance_func == nullptr) {
+		ERR_PRINT(vformat("Extension marked as reloadable, but attempted to register class '%s' which doesn't support reloading. Perhaps your language binding don't support it? Reloading disabled for this extension.", class_name));
+		self->reloadable = false;
+	}
+
 	extension->gdextension.library = self;
 	extension->gdextension.parent_class_name = parent_class_name;
 	extension->gdextension.class_name = class_name;
@@ -376,11 +458,25 @@ void GDExtension::_register_extension_class_internal(GDExtensionClassLibraryPtr
 	extension->gdextension.class_userdata = p_extension_funcs->class_userdata;
 	extension->gdextension.create_instance = p_extension_funcs->create_instance_func;
 	extension->gdextension.free_instance = p_extension_funcs->free_instance_func;
+	extension->gdextension.recreate_instance = p_extension_funcs->recreate_instance_func;
 	extension->gdextension.get_virtual = p_extension_funcs->get_virtual_func;
 	extension->gdextension.get_virtual_call_data = p_extension_funcs->get_virtual_call_data_func;
 	extension->gdextension.call_virtual_with_data = p_extension_funcs->call_virtual_with_data_func;
 	extension->gdextension.get_rid = p_extension_funcs->get_rid_func;
 
+	extension->gdextension.reloadable = self->reloadable;
+#ifdef TOOLS_ENABLED
+	if (extension->gdextension.reloadable) {
+		extension->gdextension.tracking_userdata = extension;
+		extension->gdextension.track_instance = &GDExtension::_track_instance;
+		extension->gdextension.untrack_instance = &GDExtension::_untrack_instance;
+	} else {
+		extension->gdextension.tracking_userdata = nullptr;
+		extension->gdextension.track_instance = nullptr;
+		extension->gdextension.untrack_instance = nullptr;
+	}
+#endif
+
 	ClassDB::register_extension_class(&extension->gdextension);
 }
 
@@ -391,10 +487,39 @@ void GDExtension::_register_extension_class_method(GDExtensionClassLibraryPtr p_
 	StringName method_name = *reinterpret_cast<const StringName *>(p_method_info->name);
 	ERR_FAIL_COND_MSG(!self->extension_classes.has(class_name), "Attempt to register extension method '" + String(method_name) + "' for unexisting class '" + class_name + "'.");
 
-	//Extension *extension = &self->extension_classes[class_name];
+#ifdef TOOLS_ENABLED
+	Extension *extension = &self->extension_classes[class_name];
+	GDExtensionMethodBind *method = nullptr;
 
+	// If the extension is still marked as reloading, that means it failed to register again.
+	if (extension->is_reloading) {
+		return;
+	}
+
+	if (self->is_reloading && extension->methods.has(method_name)) {
+		method = extension->methods[method_name];
+
+		// Try to update the method bind. If it doesn't work (because it's incompatible) then
+		// mark as invalid and create a new one.
+		if (!method->is_reloading || !method->try_update(p_method_info)) {
+			method->valid = false;
+			self->invalid_methods.push_back(method);
+
+			method = nullptr;
+		}
+	}
+
+	if (method == nullptr) {
+		method = memnew(GDExtensionMethodBind(p_method_info));
+		method->set_instance_class(class_name);
+		extension->methods[method_name] = method;
+	} else {
+		method->is_reloading = false;
+	}
+#else
 	GDExtensionMethodBind *method = memnew(GDExtensionMethodBind(p_method_info));
 	method->set_instance_class(class_name);
+#endif
 
 	ClassDB::bind_method_custom(class_name, method);
 }
@@ -406,6 +531,14 @@ void GDExtension::_register_extension_class_integer_constant(GDExtensionClassLib
 	StringName constant_name = *reinterpret_cast<const StringName *>(p_constant_name);
 	ERR_FAIL_COND_MSG(!self->extension_classes.has(class_name), "Attempt to register extension constant '" + constant_name + "' for unexisting class '" + class_name + "'.");
 
+#ifdef TOOLS_ENABLED
+	// If the extension is still marked as reloading, that means it failed to register again.
+	Extension *extension = &self->extension_classes[class_name];
+	if (extension->is_reloading) {
+		return;
+	}
+#endif
+
 	ClassDB::bind_integer_constant(class_name, enum_name, constant_name, p_constant_value, p_is_bitfield);
 }
 
@@ -422,6 +555,14 @@ void GDExtension::_register_extension_class_property_indexed(GDExtensionClassLib
 	String property_name = *reinterpret_cast<const StringName *>(p_info->name);
 	ERR_FAIL_COND_MSG(!self->extension_classes.has(class_name), "Attempt to register extension class property '" + property_name + "' for unexisting class '" + class_name + "'.");
 
+#ifdef TOOLS_ENABLED
+	// If the extension is still marked as reloading, that means it failed to register again.
+	Extension *extension = &self->extension_classes[class_name];
+	if (extension->is_reloading) {
+		return;
+	}
+#endif
+
 	PropertyInfo pinfo(*p_info);
 
 	ClassDB::add_property(class_name, pinfo, setter, getter, p_index);
@@ -435,6 +576,14 @@ void GDExtension::_register_extension_class_property_group(GDExtensionClassLibra
 	String prefix = *reinterpret_cast<const String *>(p_prefix);
 	ERR_FAIL_COND_MSG(!self->extension_classes.has(class_name), "Attempt to register extension class property group '" + group_name + "' for unexisting class '" + class_name + "'.");
 
+#ifdef TOOLS_ENABLED
+	// If the extension is still marked as reloading, that means it failed to register again.
+	Extension *extension = &self->extension_classes[class_name];
+	if (extension->is_reloading) {
+		return;
+	}
+#endif
+
 	ClassDB::add_property_group(class_name, group_name, prefix);
 }
 
@@ -446,6 +595,14 @@ void GDExtension::_register_extension_class_property_subgroup(GDExtensionClassLi
 	String prefix = *reinterpret_cast<const String *>(p_prefix);
 	ERR_FAIL_COND_MSG(!self->extension_classes.has(class_name), "Attempt to register extension class property subgroup '" + subgroup_name + "' for unexisting class '" + class_name + "'.");
 
+#ifdef TOOLS_ENABLED
+	// If the extension is still marked as reloading, that means it failed to register again.
+	Extension *extension = &self->extension_classes[class_name];
+	if (extension->is_reloading) {
+		return;
+	}
+#endif
+
 	ClassDB::add_property_subgroup(class_name, subgroup_name, prefix);
 }
 
@@ -456,6 +613,14 @@ void GDExtension::_register_extension_class_signal(GDExtensionClassLibraryPtr p_
 	StringName signal_name = *reinterpret_cast<const StringName *>(p_signal_name);
 	ERR_FAIL_COND_MSG(!self->extension_classes.has(class_name), "Attempt to register extension class signal '" + signal_name + "' for unexisting class '" + class_name + "'.");
 
+#ifdef TOOLS_ENABLED
+	// If the extension is still marked as reloading, that means it failed to register again.
+	Extension *extension = &self->extension_classes[class_name];
+	if (extension->is_reloading) {
+		return;
+	}
+#endif
+
 	MethodInfo s;
 	s.name = signal_name;
 	for (int i = 0; i < p_argument_count; i++) {
@@ -470,14 +635,32 @@ void GDExtension::_unregister_extension_class(GDExtensionClassLibraryPtr p_libra
 
 	StringName class_name = *reinterpret_cast<const StringName *>(p_class_name);
 	ERR_FAIL_COND_MSG(!self->extension_classes.has(class_name), "Attempt to unregister unexisting extension class '" + class_name + "'.");
+
 	Extension *ext = &self->extension_classes[class_name];
+#ifdef TOOLS_ENABLED
+	if (ext->is_reloading) {
+		self->_clear_extension(ext);
+	}
+#endif
 	ERR_FAIL_COND_MSG(ext->gdextension.children.size(), "Attempt to unregister class '" + class_name + "' while other extension classes inherit from it.");
 
+#ifdef TOOLS_ENABLED
+	ClassDB::unregister_extension_class(class_name, !ext->is_reloading);
+#else
 	ClassDB::unregister_extension_class(class_name);
+#endif
+
 	if (ext->gdextension.parent != nullptr) {
 		ext->gdextension.parent->children.erase(&ext->gdextension);
 	}
+
+#ifdef TOOLS_ENABLED
+	if (!ext->is_reloading) {
+		self->extension_classes.erase(class_name);
+	}
+#else
 	self->extension_classes.erase(class_name);
+#endif
 }
 
 void GDExtension::_get_library_path(GDExtensionClassLibraryPtr p_library, GDExtensionUninitializedStringPtr r_path) {
@@ -540,6 +723,11 @@ void GDExtension::close_library() {
 #endif
 
 	library = nullptr;
+	class_icon_paths.clear();
+
+#ifdef TOOLS_ENABLED
+	instance_bindings.clear();
+#endif
 }
 
 bool GDExtension::is_library_open() const {
@@ -590,6 +778,12 @@ GDExtension::~GDExtension() {
 	if (library != nullptr) {
 		close_library();
 	}
+#ifdef TOOLS_ENABLED
+	// If we have any invalid method binds still laying around, we can finally free them!
+	for (GDExtensionMethodBind *E : invalid_methods) {
+		memdelete(E);
+	}
+#endif
 }
 
 void GDExtension::initialize_gdextensions() {
@@ -610,27 +804,22 @@ void GDExtension::initialize_gdextensions() {
 	register_interface_function("get_library_path", (GDExtensionInterfaceFunctionPtr)&GDExtension::_get_library_path);
 }
 
-Ref<Resource> GDExtensionResourceLoader::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, CacheMode p_cache_mode) {
+Error GDExtensionResourceLoader::load_gdextension_resource(const String &p_path, Ref<GDExtension> &p_extension) {
+	ERR_FAIL_COND_V_MSG(p_extension.is_valid() && p_extension->is_library_open(), ERR_ALREADY_IN_USE, "Cannot load GDExtension resource into already opened library.");
+
 	Ref<ConfigFile> config;
 	config.instantiate();
 
 	Error err = config->load(p_path);
 
-	if (r_error) {
-		*r_error = err;
-	}
-
 	if (err != OK) {
 		ERR_PRINT("Error loading GDExtension configuration file: " + p_path);
-		return Ref<Resource>();
+		return err;
 	}
 
 	if (!config->has_section_key("configuration", "entry_symbol")) {
-		if (r_error) {
-			*r_error = ERR_INVALID_DATA;
-		}
 		ERR_PRINT("GDExtension configuration file must contain a \"configuration/entry_symbol\" key: " + p_path);
-		return Ref<Resource>();
+		return ERR_INVALID_DATA;
 	}
 
 	String entry_symbol = config->get_value("configuration", "entry_symbol");
@@ -648,19 +837,13 @@ Ref<Resource> GDExtensionResourceLoader::load(const String &p_path, const String
 			}
 		}
 	} else {
-		if (r_error) {
-			*r_error = ERR_INVALID_DATA;
-		}
 		ERR_PRINT("GDExtension configuration file must contain a \"configuration/compatibility_minimum\" key: " + p_path);
-		return Ref<Resource>();
+		return ERR_INVALID_DATA;
 	}
 
 	if (compatibility_minimum[0] < 4 || (compatibility_minimum[0] == 4 && compatibility_minimum[1] == 0)) {
-		if (r_error) {
-			*r_error = ERR_INVALID_DATA;
-		}
 		ERR_PRINT(vformat("GDExtension's compatibility_minimum (%d.%d.%d) must be at least 4.1.0: %s", compatibility_minimum[0], compatibility_minimum[1], compatibility_minimum[2], p_path));
-		return Ref<Resource>();
+		return ERR_INVALID_DATA;
 	}
 
 	bool compatible = true;
@@ -673,42 +856,42 @@ Ref<Resource> GDExtensionResourceLoader::load(const String &p_path, const String
 		compatible = VERSION_PATCH >= compatibility_minimum[2];
 	}
 	if (!compatible) {
-		if (r_error) {
-			*r_error = ERR_INVALID_DATA;
-		}
 		ERR_PRINT(vformat("GDExtension only compatible with Godot version %d.%d.%d or later: %s", compatibility_minimum[0], compatibility_minimum[1], compatibility_minimum[2], p_path));
-		return Ref<Resource>();
+		return ERR_INVALID_DATA;
 	}
 
 	String library_path = GDExtension::find_extension_library(p_path, config, [](String p_feature) { return OS::get_singleton()->has_feature(p_feature); });
 
 	if (library_path.is_empty()) {
-		if (r_error) {
-			*r_error = ERR_FILE_NOT_FOUND;
-		}
 		const String os_arch = OS::get_singleton()->get_name().to_lower() + "." + Engine::get_singleton()->get_architecture_name();
 		ERR_PRINT(vformat("No GDExtension library found for current OS and architecture (%s) in configuration file: %s", os_arch, p_path));
-		return Ref<Resource>();
+		return ERR_FILE_NOT_FOUND;
 	}
 
 	if (!library_path.is_resource_file() && !library_path.is_absolute_path()) {
 		library_path = p_path.get_base_dir().path_join(library_path);
 	}
 
-	Ref<GDExtension> lib;
-	lib.instantiate();
-	String abs_path = ProjectSettings::get_singleton()->globalize_path(library_path);
+	if (p_extension.is_null()) {
+		p_extension.instantiate();
+	}
 
+#ifdef TOOLS_ENABLED
+	p_extension->set_reloadable(config->get_value("configuration", "reloadable", false) && Engine::get_singleton()->is_extension_reloading_enabled());
+
+	p_extension->update_last_modified_time(MAX(
+			FileAccess::get_modified_time(library_path),
+			FileAccess::get_modified_time(p_path)));
+#endif
+
+	String abs_path = ProjectSettings::get_singleton()->globalize_path(library_path);
 #if defined(WINDOWS_ENABLED) && defined(TOOLS_ENABLED)
 	// If running on the editor on Windows, we copy the library and open the copy.
 	// This is so the original file isn't locked and can be updated by a compiler.
 	if (Engine::get_singleton()->is_editor_hint()) {
 		if (!FileAccess::exists(abs_path)) {
-			if (r_error) {
-				*r_error = ERR_FILE_NOT_FOUND;
-			}
 			ERR_PRINT("GDExtension library not found: " + library_path);
-			return Ref<Resource>();
+			return ERR_FILE_NOT_FOUND;
 		}
 
 		// Copy the file to the same directory as the original with a prefix in the name.
@@ -722,36 +905,29 @@ Ref<Resource> GDExtensionResourceLoader::load(const String &p_path, const String
 
 		Error copy_err = DirAccess::copy_absolute(abs_path, copy_path);
 		if (copy_err) {
-			if (r_error) {
-				*r_error = ERR_CANT_CREATE;
-			}
 			ERR_PRINT("Error copying GDExtension library: " + library_path);
-			return Ref<Resource>();
+			return ERR_CANT_CREATE;
 		}
 		FileAccess::set_hidden_attribute(copy_path, true);
 
 		// Save the copied path so it can be deleted later.
-		lib->set_temp_library_path(copy_path);
+		p_extension->set_temp_library_path(copy_path);
 
 		// Use the copy to open the library.
 		abs_path = copy_path;
 	}
 #endif
-	err = lib->open_library(abs_path, entry_symbol);
-
-	if (r_error) {
-		*r_error = err;
-	}
 
+	err = p_extension->open_library(abs_path, entry_symbol);
 	if (err != OK) {
 #if defined(WINDOWS_ENABLED) && defined(TOOLS_ENABLED)
 		// If the DLL fails to load, make sure that temporary DLL copies are cleaned up.
 		if (Engine::get_singleton()->is_editor_hint()) {
-			DirAccess::remove_absolute(lib->get_temp_library_path());
+			DirAccess::remove_absolute(p_extension->get_temp_library_path());
 		}
 #endif
 		// Errors already logged in open_library()
-		return Ref<Resource>();
+		return err;
 	}
 
 	// Handle icons if any are specified.
@@ -759,10 +935,20 @@ Ref<Resource> GDExtensionResourceLoader::load(const String &p_path, const String
 		List<String> keys;
 		config->get_section_keys("icons", &keys);
 		for (const String &key : keys) {
-			lib->class_icon_paths[key] = config->get_value("icons", key);
+			p_extension->class_icon_paths[key] = config->get_value("icons", key);
 		}
 	}
 
+	return OK;
+}
+
+Ref<Resource> GDExtensionResourceLoader::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, CacheMode p_cache_mode) {
+	Ref<GDExtension> lib;
+	Error err = load_gdextension_resource(p_path, lib);
+	if (err != OK && r_error) {
+		// Errors already logged in load_gdextension_resource().
+		*r_error = err;
+	}
 	return lib;
 }
 
@@ -783,6 +969,183 @@ String GDExtensionResourceLoader::get_resource_type(const String &p_path) const
 }
 
 #ifdef TOOLS_ENABLED
+bool GDExtension::has_library_changed() const {
+	if (FileAccess::get_modified_time(get_path()) > last_modified_time) {
+		return true;
+	}
+	if (FileAccess::get_modified_time(library_path) > last_modified_time) {
+		return true;
+	}
+	return false;
+}
+
+void GDExtension::prepare_reload() {
+	is_reloading = true;
+
+	for (KeyValue<StringName, Extension> &E : extension_classes) {
+		E.value.is_reloading = true;
+
+		for (KeyValue<StringName, GDExtensionMethodBind *> &M : E.value.methods) {
+			M.value->is_reloading = true;
+		}
+
+		for (const ObjectID &obj_id : E.value.instances) {
+			Object *obj = ObjectDB::get_instance(obj_id);
+			if (!obj) {
+				continue;
+			}
+
+			// Store instance state so it can be restored after reload.
+			List<Pair<String, Variant>> state;
+			List<PropertyInfo> prop_list;
+			obj->get_property_list(&prop_list);
+			for (const PropertyInfo &P : prop_list) {
+				if (!(P.usage & PROPERTY_USAGE_STORAGE)) {
+					continue;
+				}
+
+				Variant value = obj->get(P.name);
+				Variant default_value = ClassDB::class_get_default_property_value(obj->get_class_name(), P.name);
+
+				if (default_value.get_type() != Variant::NIL && bool(Variant::evaluate(Variant::OP_EQUAL, value, default_value))) {
+					continue;
+				}
+
+				if (P.type == Variant::OBJECT && value.is_zero() && !(P.usage & PROPERTY_USAGE_STORE_IF_NULL)) {
+					continue;
+				}
+
+				state.push_back(Pair<String, Variant>(P.name, value));
+			}
+			E.value.instance_state[obj_id] = state;
+		}
+	}
+}
+
+void GDExtension::_clear_extension(Extension *p_extension) {
+	// Clear out hierarchy information because it may change.
+	p_extension->gdextension.parent = nullptr;
+	p_extension->gdextension.children.clear();
+
+	// Clear all objects of any GDExtension data. It will become its native parent class
+	// until the reload can reset the object with the new GDExtension data.
+	for (const ObjectID &obj_id : p_extension->instances) {
+		Object *obj = ObjectDB::get_instance(obj_id);
+		if (!obj) {
+			continue;
+		}
+
+		obj->clear_internal_extension();
+	}
+}
+
+void GDExtension::track_instance_binding(Object *p_object) {
+	instance_bindings.push_back(p_object->get_instance_id());
+}
+
+void GDExtension::untrack_instance_binding(Object *p_object) {
+	instance_bindings.erase(p_object->get_instance_id());
+}
+
+void GDExtension::clear_instance_bindings() {
+	for (ObjectID obj_id : instance_bindings) {
+		Object *obj = ObjectDB::get_instance(obj_id);
+		if (!obj) {
+			continue;
+		}
+
+		obj->free_instance_binding(this);
+	}
+	instance_bindings.clear();
+}
+
+void GDExtension::finish_reload() {
+	is_reloading = false;
+
+	// Clean up any classes or methods that didn't get re-added.
+	Vector<StringName> classes_to_remove;
+	for (KeyValue<StringName, Extension> &E : extension_classes) {
+		if (E.value.is_reloading) {
+			E.value.is_reloading = false;
+			classes_to_remove.push_back(E.key);
+		}
+
+		Vector<StringName> methods_to_remove;
+		for (KeyValue<StringName, GDExtensionMethodBind *> &M : E.value.methods) {
+			if (M.value->is_reloading) {
+				M.value->valid = false;
+				invalid_methods.push_back(M.value);
+
+				M.value->is_reloading = false;
+				methods_to_remove.push_back(M.key);
+			}
+		}
+		for (const StringName &method_name : methods_to_remove) {
+			E.value.methods.erase(method_name);
+		}
+	}
+	for (const StringName &class_name : classes_to_remove) {
+		extension_classes.erase(class_name);
+	}
+
+	// Reset any the extension on instances made from the classes that remain.
+	for (KeyValue<StringName, Extension> &E : extension_classes) {
+		// Loop over 'instance_state' rather than 'instance' because new instances
+		// may have been created when re-initializing the extension.
+		for (const KeyValue<ObjectID, List<Pair<String, Variant>>> &S : E.value.instance_state) {
+			Object *obj = ObjectDB::get_instance(S.key);
+			if (!obj) {
+				continue;
+			}
+
+			obj->reset_internal_extension(&E.value.gdextension);
+		}
+	}
+
+	// Now that all the classes are back, restore the state.
+	for (KeyValue<StringName, Extension> &E : extension_classes) {
+		for (const KeyValue<ObjectID, List<Pair<String, Variant>>> &S : E.value.instance_state) {
+			Object *obj = ObjectDB::get_instance(S.key);
+			if (!obj) {
+				continue;
+			}
+
+			for (const Pair<String, Variant> &state : S.value) {
+				obj->set(state.first, state.second);
+			}
+		}
+	}
+
+	// Finally, let the objects know that we are done reloading them.
+	for (KeyValue<StringName, Extension> &E : extension_classes) {
+		for (const KeyValue<ObjectID, List<Pair<String, Variant>>> &S : E.value.instance_state) {
+			Object *obj = ObjectDB::get_instance(S.key);
+			if (!obj) {
+				continue;
+			}
+
+			obj->notification(NOTIFICATION_EXTENSION_RELOADED);
+		}
+
+		// Clear the instance state, we're done looping.
+		E.value.instance_state.clear();
+	}
+}
+
+void GDExtension::_track_instance(void *p_user_data, void *p_instance) {
+	Extension *extension = reinterpret_cast<Extension *>(p_user_data);
+	Object *obj = reinterpret_cast<Object *>(p_instance);
+
+	extension->instances.insert(obj->get_instance_id());
+}
+
+void GDExtension::_untrack_instance(void *p_user_data, void *p_instance) {
+	Extension *extension = reinterpret_cast<Extension *>(p_user_data);
+	Object *obj = reinterpret_cast<Object *>(p_instance);
+
+	extension->instances.erase(obj->get_instance_id());
+}
+
 Vector<StringName> GDExtensionEditorPlugins::extension_classes;
 GDExtensionEditorPlugins::EditorPluginRegisterFunc GDExtensionEditorPlugins::editor_node_add_plugin = nullptr;
 GDExtensionEditorPlugins::EditorPluginRegisterFunc GDExtensionEditorPlugins::editor_node_remove_plugin = nullptr;

core/extension/gdextension.h

@@ -38,17 +38,29 @@
 #include "core/io/resource_loader.h"
 #include "core/object/ref_counted.h"
 
+class GDExtensionMethodBind;
+
 class GDExtension : public Resource {
 	GDCLASS(GDExtension, Resource)
 
+	friend class GDExtensionManager;
+
 	void *library = nullptr; // pointer if valid,
 	String library_path;
 #if defined(WINDOWS_ENABLED) && defined(TOOLS_ENABLED)
 	String temp_lib_path;
 #endif
+	bool reloadable = false;
 
 	struct Extension {
 		ObjectGDExtension gdextension;
+
+#ifdef TOOLS_ENABLED
+		bool is_reloading = false;
+		HashMap<StringName, GDExtensionMethodBind *> methods;
+		HashSet<ObjectID> instances;
+		HashMap<ObjectID, List<Pair<String, Variant>>> instance_state;
+#endif
 	};
 
 	HashMap<StringName, Extension> extension_classes;
@@ -77,6 +89,23 @@ class GDExtension : public Resource {
 	GDExtensionInitialization initialization;
 	int32_t level_initialized = -1;
 
+#ifdef TOOLS_ENABLED
+	uint64_t last_modified_time = 0;
+	bool is_reloading = false;
+	Vector<GDExtensionMethodBind *> invalid_methods;
+	Vector<ObjectID> instance_bindings;
+
+	static void _track_instance(void *p_user_data, void *p_instance);
+	static void _untrack_instance(void *p_user_data, void *p_instance);
+
+	void _clear_extension(Extension *p_extension);
+
+	// Only called by GDExtensionManager during the reload process.
+	void prepare_reload();
+	void finish_reload();
+	void clear_instance_bindings();
+#endif
+
 protected:
 	static void _bind_methods();
 
@@ -103,6 +132,19 @@ public:
 
 	bool is_library_open() const;
 
+#ifdef TOOLS_ENABLED
+	bool is_reloadable() const { return reloadable; }
+	void set_reloadable(bool p_reloadable) { reloadable = p_reloadable; }
+
+	bool has_library_changed() const;
+	void update_last_modified_time(uint64_t p_last_modified_time) {
+		last_modified_time = MAX(last_modified_time, p_last_modified_time);
+	}
+
+	void track_instance_binding(Object *p_object);
+	void untrack_instance_binding(Object *p_object);
+#endif
+
 	InitializationLevel get_minimum_library_initialization_level() const;
 	void initialize_library(InitializationLevel p_level);
 	void deinitialize_library(InitializationLevel p_level);
@@ -119,6 +161,8 @@ VARIANT_ENUM_CAST(GDExtension::InitializationLevel)
 
 class GDExtensionResourceLoader : public ResourceFormatLoader {
 public:
+	static Error load_gdextension_resource(const String &p_path, Ref<GDExtension> &p_extension);
+
 	virtual Ref<Resource> load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads = false, float *r_progress = nullptr, CacheMode p_cache_mode = CACHE_MODE_REUSE);
 	virtual void get_recognized_extensions(List<String> *p_extensions) const;
 	virtual bool handles_type(const String &p_type) const;

core/extension/gdextension_interface.h

@@ -267,6 +267,7 @@ typedef void (*GDExtensionClassUnreference)(GDExtensionClassInstancePtr p_instan
 typedef void (*GDExtensionClassCallVirtual)(GDExtensionClassInstancePtr p_instance, const GDExtensionConstTypePtr *p_args, GDExtensionTypePtr r_ret);
 typedef GDExtensionObjectPtr (*GDExtensionClassCreateInstance)(void *p_class_userdata);
 typedef void (*GDExtensionClassFreeInstance)(void *p_class_userdata, GDExtensionClassInstancePtr p_instance);
+typedef GDExtensionClassInstancePtr (*GDExtensionClassRecreateInstance)(void *p_class_userdata, GDExtensionObjectPtr p_object);
 typedef GDExtensionClassCallVirtual (*GDExtensionClassGetVirtual)(void *p_class_userdata, GDExtensionConstStringNamePtr p_name);
 typedef void *(*GDExtensionClassGetVirtualCallData)(void *p_class_userdata, GDExtensionConstStringNamePtr p_name);
 typedef void (*GDExtensionClassCallVirtualWithData)(GDExtensionClassInstancePtr p_instance, GDExtensionConstStringNamePtr p_name, void *p_virtual_call_userdata, const GDExtensionConstTypePtr *p_args, GDExtensionTypePtr r_ret);
@@ -308,6 +309,7 @@ typedef struct {
 	GDExtensionClassUnreference unreference_func;
 	GDExtensionClassCreateInstance create_instance_func; // (Default) constructor; mandatory. If the class is not instantiable, consider making it virtual or abstract.
 	GDExtensionClassFreeInstance free_instance_func; // Destructor; mandatory.
+	GDExtensionClassRecreateInstance recreate_instance_func;
 	// Queries a virtual function by name and returns a callback to invoke the requested virtual function.
 	GDExtensionClassGetVirtual get_virtual_func;
 	// Paired with `call_virtual_with_data_func`, this is an alternative to `get_virtual_func` for extensions that

core/extension/gdextension_manager.cpp

@@ -32,58 +32,117 @@
 
 #include "core/extension/gdextension_compat_hashes.h"
 #include "core/io/file_access.h"
+#include "core/object/script_language.h"
 
-GDExtensionManager::LoadStatus GDExtensionManager::load_extension(const String &p_path) {
-	if (gdextension_map.has(p_path)) {
-		return LOAD_STATUS_ALREADY_LOADED;
-	}
-	Ref<GDExtension> extension = ResourceLoader::load(p_path);
-	if (extension.is_null()) {
-		return LOAD_STATUS_FAILED;
-	}
-
+GDExtensionManager::LoadStatus GDExtensionManager::_load_extension_internal(const Ref<GDExtension> &p_extension) {
 	if (level >= 0) { // Already initialized up to some level.
-		int32_t minimum_level = extension->get_minimum_library_initialization_level();
+		int32_t minimum_level = p_extension->get_minimum_library_initialization_level();
 		if (minimum_level < MIN(level, GDExtension::INITIALIZATION_LEVEL_SCENE)) {
 			return LOAD_STATUS_NEEDS_RESTART;
 		}
 		// Initialize up to current level.
 		for (int32_t i = minimum_level; i <= level; i++) {
-			extension->initialize_library(GDExtension::InitializationLevel(i));
+			p_extension->initialize_library(GDExtension::InitializationLevel(i));
 		}
 	}
 
-	for (const KeyValue<String, String> &kv : extension->class_icon_paths) {
+	for (const KeyValue<String, String> &kv : p_extension->class_icon_paths) {
 		gdextension_class_icon_paths[kv.key] = kv.value;
 	}
 
+	return LOAD_STATUS_OK;
+}
+
+GDExtensionManager::LoadStatus GDExtensionManager::_unload_extension_internal(const Ref<GDExtension> &p_extension) {
+	if (level >= 0) { // Already initialized up to some level.
+		// Deinitialize down from current level.
+		for (int32_t i = level; i >= GDExtension::INITIALIZATION_LEVEL_CORE; i--) {
+			p_extension->deinitialize_library(GDExtension::InitializationLevel(i));
+		}
+	}
+
+	for (const KeyValue<String, String> &kv : p_extension->class_icon_paths) {
+		gdextension_class_icon_paths.erase(kv.key);
+	}
+
+	return LOAD_STATUS_OK;
+}
+
+GDExtensionManager::LoadStatus GDExtensionManager::load_extension(const String &p_path) {
+	if (gdextension_map.has(p_path)) {
+		return LOAD_STATUS_ALREADY_LOADED;
+	}
+	Ref<GDExtension> extension = ResourceLoader::load(p_path);
+	if (extension.is_null()) {
+		return LOAD_STATUS_FAILED;
+	}
+
+	LoadStatus status = _load_extension_internal(extension);
+	if (status != LOAD_STATUS_OK) {
+		return status;
+	}
+
 	gdextension_map[p_path] = extension;
 	return LOAD_STATUS_OK;
 }
 
 GDExtensionManager::LoadStatus GDExtensionManager::reload_extension(const String &p_path) {
-	return LOAD_STATUS_OK; //TODO
-}
-GDExtensionManager::LoadStatus GDExtensionManager::unload_extension(const String &p_path) {
+#ifndef TOOLS_ENABLED
+	ERR_FAIL_V_MSG(LOAD_STATUS_FAILED, "GDExtensions can only be reloaded in an editor build.");
+#else
+	ERR_FAIL_COND_V_MSG(!Engine::get_singleton()->is_extension_reloading_enabled(), LOAD_STATUS_FAILED, "GDExtension reloading is disabled.");
+
 	if (!gdextension_map.has(p_path)) {
 		return LOAD_STATUS_NOT_LOADED;
 	}
 
 	Ref<GDExtension> extension = gdextension_map[p_path];
+	ERR_FAIL_COND_V_MSG(!extension->is_reloadable(), LOAD_STATUS_FAILED, vformat("This GDExtension is not marked as 'reloadable' or doesn't support reloading: %s.", p_path));
 
-	if (level >= 0) { // Already initialized up to some level.
-		int32_t minimum_level = extension->get_minimum_library_initialization_level();
-		if (minimum_level < MIN(level, GDExtension::INITIALIZATION_LEVEL_SCENE)) {
-			return LOAD_STATUS_NEEDS_RESTART;
-		}
-		// Deinitialize down to current level.
-		for (int32_t i = level; i >= minimum_level; i--) {
-			extension->deinitialize_library(GDExtension::InitializationLevel(i));
+	LoadStatus status;
+
+	extension->prepare_reload();
+
+	// Unload library if it's open. It may not be open if the developer made a
+	// change that broke loading in a previous hot-reload attempt.
+	if (extension->is_library_open()) {
+		status = _unload_extension_internal(extension);
+		if (status != LOAD_STATUS_OK) {
+			// We need to clear these no matter what.
+			extension->clear_instance_bindings();
+			return status;
 		}
+
+		extension->clear_instance_bindings();
+		extension->close_library();
 	}
 
-	for (const KeyValue<String, String> &kv : extension->class_icon_paths) {
-		gdextension_class_icon_paths.erase(kv.key);
+	Error err = GDExtensionResourceLoader::load_gdextension_resource(p_path, extension);
+	if (err != OK) {
+		return LOAD_STATUS_FAILED;
+	}
+
+	status = _load_extension_internal(extension);
+	if (status != LOAD_STATUS_OK) {
+		return status;
+	}
+
+	extension->finish_reload();
+
+	return LOAD_STATUS_OK;
+#endif
+}
+
+GDExtensionManager::LoadStatus GDExtensionManager::unload_extension(const String &p_path) {
+	if (!gdextension_map.has(p_path)) {
+		return LOAD_STATUS_NOT_LOADED;
+	}
+
+	Ref<GDExtension> extension = gdextension_map[p_path];
+
+	LoadStatus status = _unload_extension_internal(extension);
+	if (status != LOAD_STATUS_OK) {
+		return status;
 	}
 
 	gdextension_map.erase(p_path);
@@ -136,6 +195,36 @@ void GDExtensionManager::deinitialize_extensions(GDExtension::InitializationLeve
 	level = int32_t(p_level) - 1;
 }
 
+#ifdef TOOLS_ENABLED
+void GDExtensionManager::track_instance_binding(void *p_token, Object *p_object) {
+	for (KeyValue<String, Ref<GDExtension>> &E : gdextension_map) {
+		if (E.value.ptr() == p_token) {
+			if (E.value->is_reloadable()) {
+				E.value->track_instance_binding(p_object);
+				return;
+			}
+		}
+	}
+}
+
+void GDExtensionManager::untrack_instance_binding(void *p_token, Object *p_object) {
+	for (KeyValue<String, Ref<GDExtension>> &E : gdextension_map) {
+		if (E.value.ptr() == p_token) {
+			if (E.value->is_reloadable()) {
+				E.value->untrack_instance_binding(p_object);
+				return;
+			}
+		}
+	}
+}
+
+void GDExtensionManager::_reload_all_scripts() {
+	for (int i = 0; i < ScriptServer::get_language_count(); i++) {
+		ScriptServer::get_language(i)->reload_all_scripts();
+	}
+}
+#endif // TOOLS_ENABLED
+
 void GDExtensionManager::load_extensions() {
 	Ref<FileAccess> f = FileAccess::open(GDExtension::get_extension_list_config_file(), FileAccess::READ);
 	while (f.is_valid() && !f->eof_reached()) {
@@ -149,9 +238,33 @@ void GDExtensionManager::load_extensions() {
 	OS::get_singleton()->load_platform_gdextensions();
 }
 
+void GDExtensionManager::reload_extensions() {
+#ifdef TOOLS_ENABLED
+	bool reloaded = false;
+	for (const KeyValue<String, Ref<GDExtension>> &E : gdextension_map) {
+		if (!E.value->is_reloadable()) {
+			continue;
+		}
+
+		if (E.value->has_library_changed()) {
+			reloaded = true;
+			reload_extension(E.value->get_path());
+		}
+	}
+
+	if (reloaded) {
+		emit_signal("extensions_reloaded");
+
+		// Reload all scripts to clear out old references.
+		callable_mp_static(&GDExtensionManager::_reload_all_scripts).call_deferred();
+	}
+#endif
+}
+
 GDExtensionManager *GDExtensionManager::get_singleton() {
 	return singleton;
 }
+
 void GDExtensionManager::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("load_extension", "path"), &GDExtensionManager::load_extension);
 	ClassDB::bind_method(D_METHOD("reload_extension", "path"), &GDExtensionManager::reload_extension);
@@ -166,6 +279,8 @@ void GDExtensionManager::_bind_methods() {
 	BIND_ENUM_CONSTANT(LOAD_STATUS_ALREADY_LOADED);
 	BIND_ENUM_CONSTANT(LOAD_STATUS_NOT_LOADED);
 	BIND_ENUM_CONSTANT(LOAD_STATUS_NEEDS_RESTART);
+
+	ADD_SIGNAL(MethodInfo("extensions_reloaded"));
 }
 
 GDExtensionManager *GDExtensionManager::singleton = nullptr;

core/extension/gdextension_manager.h

@@ -53,6 +53,15 @@ public:
 		LOAD_STATUS_NEEDS_RESTART,
 	};
 
+private:
+	LoadStatus _load_extension_internal(const Ref<GDExtension> &p_extension);
+	LoadStatus _unload_extension_internal(const Ref<GDExtension> &p_extension);
+
+#ifdef TOOLS_ENABLED
+	static void _reload_all_scripts();
+#endif
+
+public:
 	LoadStatus load_extension(const String &p_path);
 	LoadStatus reload_extension(const String &p_path);
 	LoadStatus unload_extension(const String &p_path);
@@ -66,9 +75,15 @@ public:
 	void initialize_extensions(GDExtension::InitializationLevel p_level);
 	void deinitialize_extensions(GDExtension::InitializationLevel p_level);
 
+#ifdef TOOLS_ENABLED
+	void track_instance_binding(void *p_token, Object *p_object);
+	void untrack_instance_binding(void *p_token, Object *p_object);
+#endif
+
 	static GDExtensionManager *get_singleton();
 
 	void load_extensions();
+	void reload_extensions();
 
 	GDExtensionManager();
 };

core/object/class_db.cpp

@@ -349,7 +349,13 @@ Object *ClassDB::instantiate(const StringName &p_class) {
 	}
 #endif
 	if (ti->gdextension && ti->gdextension->create_instance) {
-		return (Object *)ti->gdextension->create_instance(ti->gdextension->class_userdata);
+		Object *obj = (Object *)ti->gdextension->create_instance(ti->gdextension->class_userdata);
+#ifdef TOOLS_ENABLED
+		if (ti->gdextension->track_instance) {
+			ti->gdextension->track_instance(ti->gdextension->tracking_userdata, obj);
+		}
+#endif
+		return obj;
 	} else {
 		return ti->creation_func();
 	}
@@ -1555,6 +1561,14 @@ bool ClassDB::is_class_exposed(const StringName &p_class) {
 	return ti->exposed;
 }
 
+bool ClassDB::is_class_reloadable(const StringName &p_class) {
+	OBJTYPE_RLOCK;
+
+	ClassInfo *ti = classes.getptr(p_class);
+	ERR_FAIL_NULL_V_MSG(ti, false, "Cannot get class '" + String(p_class) + "'.");
+	return ti->reloadable;
+}
+
 void ClassDB::add_resource_base_extension(const StringName &p_extension, const StringName &p_class) {
 	if (resource_base_extensions.has(p_extension)) {
 		return;
@@ -1693,15 +1707,18 @@ void ClassDB::register_extension_class(ObjectGDExtension *p_extension) {
 			parent = classes.getptr(parent->name);
 		}
 	}
+	c.reloadable = p_extension->reloadable;
 
 	classes[p_extension->class_name] = c;
 }
 
-void ClassDB::unregister_extension_class(const StringName &p_class) {
+void ClassDB::unregister_extension_class(const StringName &p_class, bool p_free_method_binds) {
 	ClassInfo *c = classes.getptr(p_class);
 	ERR_FAIL_NULL_MSG(c, "Class '" + String(p_class) + "' does not exist.");
-	for (KeyValue<StringName, MethodBind *> &F : c->method_map) {
-		memdelete(F.value);
+	if (p_free_method_binds) {
+		for (KeyValue<StringName, MethodBind *> &F : c->method_map) {
+			memdelete(F.value);
+		}
 	}
 	classes.erase(p_class);
 }

core/object/class_db.h

@@ -131,6 +131,7 @@ public:
 		StringName name;
 		bool disabled = false;
 		bool exposed = false;
+		bool reloadable = false;
 		bool is_virtual = false;
 		Object *(*creation_func)() = nullptr;
 
@@ -228,7 +229,7 @@ public:
 	}
 
 	static void register_extension_class(ObjectGDExtension *p_extension);
-	static void unregister_extension_class(const StringName &p_class);
+	static void unregister_extension_class(const StringName &p_class, bool p_free_method_binds = true);
 
 	template <class T>
 	static Object *_create_ptr_func() {
@@ -426,6 +427,7 @@ public:
 	static bool is_class_enabled(const StringName &p_class);
 
 	static bool is_class_exposed(const StringName &p_class);
+	static bool is_class_reloadable(const StringName &p_class);
 
 	static void add_resource_base_extension(const StringName &p_extension, const StringName &p_class);
 	static void get_resource_base_extensions(List<String> *p_extensions);

core/object/make_virtuals.py

@@ -22,6 +22,7 @@ _FORCE_INLINE_ bool _gdvirtual_##m_name##_call($CALLARGS) $CONST { \\
         } else if (_get_extension()->get_virtual) {\\
             _gdvirtual_##m_name = (void *)_get_extension()->get_virtual(_get_extension()->class_userdata, &_gdvirtual_##m_name##_sn);\\
         }\\
+        GDVIRTUAL_TRACK(_gdvirtual_##m_name, _gdvirtual_##m_name##_initialized); \\
         _gdvirtual_##m_name##_initialized = true;\\
     }\\
 	if (_gdvirtual_##m_name) {\\
@@ -56,6 +57,7 @@ _FORCE_INLINE_ bool _gdvirtual_##m_name##_overridden() const { \\
         } else if (_get_extension()->get_virtual) {\\
              _gdvirtual_##m_name = (void *)_get_extension()->get_virtual(_get_extension()->class_userdata, &_gdvirtual_##m_name##_sn);\\
         }\\
+        GDVIRTUAL_TRACK(_gdvirtual_##m_name, _gdvirtual_##m_name##_initialized); \\
         _gdvirtual_##m_name##_initialized = true;\\
     }\\
 	if (_gdvirtual_##m_name) {\\
@@ -175,6 +177,18 @@ def run(target, source, env):
 
 #include "core/object/script_instance.h"
 
+#ifdef TOOLS_ENABLED
+#define GDVIRTUAL_TRACK(m_virtual, m_initialized) \\
+    if (_get_extension()->reloadable) {\\
+        VirtualMethodTracker *tracker = memnew(VirtualMethodTracker);\\
+        tracker->method = (void **)&m_virtual;\\
+        tracker->initialized = &m_initialized;\\
+        tracker->next = virtual_method_list;\\
+        virtual_method_list = tracker;\\
+    }
+#else
+#define GDVIRTUAL_TRACK(m_virtual, m_initialized)
+#endif
 
 """
 

core/object/method_bind.h

@@ -111,6 +111,10 @@ public:
 
 	_FORCE_INLINE_ int get_argument_count() const { return argument_count; };
 
+#ifdef TOOLS_ENABLED
+	virtual bool is_valid() const { return true; }
+#endif
+
 	virtual Variant call(Object *p_object, const Variant **p_args, int p_arg_count, Callable::CallError &r_error) const = 0;
 	virtual void validated_call(Object *p_object, const Variant **p_args, Variant *r_ret) const = 0;
 

core/object/object.cpp

@@ -31,6 +31,7 @@
 #include "object.h"
 
 #include "core/core_string_names.h"
+#include "core/extension/gdextension_manager.h"
 #include "core/io/resource.h"
 #include "core/object/class_db.h"
 #include "core/object/message_queue.h"
@@ -1794,14 +1795,17 @@ StringName Object::get_class_name_for_extension(const GDExtension *p_library) co
 }
 
 void Object::set_instance_binding(void *p_token, void *p_binding, const GDExtensionInstanceBindingCallbacks *p_callbacks) {
-	// This is only meant to be used on creation by the binder.
-	ERR_FAIL_COND(_instance_bindings != nullptr);
-	_instance_bindings = (InstanceBinding *)memalloc(sizeof(InstanceBinding));
+	// This is only meant to be used on creation by the binder, but we also
+	// need to account for reloading (where the 'binding' will be cleared).
+	ERR_FAIL_COND(_instance_bindings != nullptr && _instance_bindings[0].binding != nullptr);
+	if (_instance_bindings == nullptr) {
+		_instance_bindings = (InstanceBinding *)memalloc(sizeof(InstanceBinding));
+		_instance_binding_count = 1;
+	}
 	_instance_bindings[0].binding = p_binding;
 	_instance_bindings[0].free_callback = p_callbacks->free_callback;
 	_instance_bindings[0].reference_callback = p_callbacks->reference_callback;
 	_instance_bindings[0].token = p_token;
-	_instance_binding_count = 1;
 }
 
 void *Object::get_instance_binding(void *p_token, const GDExtensionInstanceBindingCallbacks *p_callbacks) {
@@ -1828,6 +1832,12 @@ void *Object::get_instance_binding(void *p_token, const GDExtensionInstanceBindi
 		binding = p_callbacks->create_callback(p_token, this);
 		_instance_bindings[_instance_binding_count].binding = binding;
 
+#ifdef TOOLS_ENABLED
+		if (!_extension && Engine::get_singleton()->is_extension_reloading_enabled()) {
+			GDExtensionManager::get_singleton()->track_instance_binding(p_token, this);
+		}
+#endif
+
 		_instance_binding_count++;
 	}
 
@@ -1851,6 +1861,71 @@ bool Object::has_instance_binding(void *p_token) {
 	return found;
 }
 
+#ifdef TOOLS_ENABLED
+void Object::free_instance_binding(void *p_token) {
+	bool found = false;
+	_instance_binding_mutex.lock();
+	for (uint32_t i = 0; i < _instance_binding_count; i++) {
+		if (!found && _instance_bindings[i].token == p_token) {
+			if (_instance_bindings[i].free_callback) {
+				_instance_bindings[i].free_callback(_instance_bindings[i].token, this, _instance_bindings[i].binding);
+			}
+			found = true;
+		}
+		if (found) {
+			if (i + 1 < _instance_binding_count) {
+				_instance_bindings[i] = _instance_bindings[i + 1];
+			} else {
+				_instance_bindings[i] = { nullptr };
+			}
+		}
+	}
+	if (found) {
+		_instance_binding_count--;
+	}
+	_instance_binding_mutex.unlock();
+}
+
+void Object::clear_internal_extension() {
+	ERR_FAIL_NULL(_extension);
+
+	// Free the instance inside the GDExtension.
+	if (_extension->free_instance) {
+		_extension->free_instance(_extension->class_userdata, _extension_instance);
+	}
+	_extension = nullptr;
+	_extension_instance = nullptr;
+
+	// Clear the instance bindings.
+	_instance_binding_mutex.lock();
+	if (_instance_bindings[0].free_callback) {
+		_instance_bindings[0].free_callback(_instance_bindings[0].token, this, _instance_bindings[0].binding);
+	}
+	_instance_bindings[0].binding = nullptr;
+	_instance_bindings[0].token = nullptr;
+	_instance_bindings[0].free_callback = nullptr;
+	_instance_bindings[0].reference_callback = nullptr;
+	_instance_binding_mutex.unlock();
+
+	// Clear the virtual methods.
+	while (virtual_method_list) {
+		(*virtual_method_list->method) = nullptr;
+		(*virtual_method_list->initialized) = false;
+		virtual_method_list = virtual_method_list->next;
+	}
+}
+
+void Object::reset_internal_extension(ObjectGDExtension *p_extension) {
+	ERR_FAIL_COND(_extension != nullptr);
+
+	if (p_extension) {
+		_extension_instance = p_extension->recreate_instance ? p_extension->recreate_instance(p_extension->class_userdata, (GDExtensionObjectPtr)this) : nullptr;
+		ERR_FAIL_NULL_MSG(_extension_instance, "Unable to recreate GDExtension instance - does this extension support hot reloading?");
+		_extension = p_extension;
+	}
+}
+#endif
+
 void Object::_construct_object(bool p_reference) {
 	type_is_reference = p_reference;
 	_instance_id = ObjectDB::add_instance(this);
@@ -1881,11 +1956,25 @@ Object::~Object() {
 	}
 	script_instance = nullptr;
 
-	if (_extension && _extension->free_instance) {
-		_extension->free_instance(_extension->class_userdata, _extension_instance);
+	if (_extension) {
+#ifdef TOOLS_ENABLED
+		if (_extension->untrack_instance) {
+			_extension->untrack_instance(_extension->tracking_userdata, this);
+		}
+#endif
+		if (_extension->free_instance) {
+			_extension->free_instance(_extension->class_userdata, _extension_instance);
+		}
 		_extension = nullptr;
 		_extension_instance = nullptr;
 	}
+#ifdef TOOLS_ENABLED
+	else if (_instance_bindings != nullptr && Engine::get_singleton()->is_extension_reloading_enabled()) {
+		for (uint32_t i = 0; i < _instance_binding_count; i++) {
+			GDExtensionManager::get_singleton()->untrack_instance_binding(_instance_bindings[i].token, this);
+		}
+	}
+#endif
 
 	if (_emitting) {
 		//@todo this may need to actually reach the debugger prioritarily somehow because it may crash before

core/object/object.h

@@ -313,6 +313,7 @@ struct ObjectGDExtension {
 	StringName parent_class_name;
 	StringName class_name;
 	bool editor_class = false;
+	bool reloadable = false;
 	bool is_virtual = false;
 	bool is_abstract = false;
 	bool is_exposed = true;
@@ -349,6 +350,13 @@ struct ObjectGDExtension {
 	GDExtensionClassGetVirtual get_virtual;
 	GDExtensionClassGetVirtualCallData get_virtual_call_data;
 	GDExtensionClassCallVirtualWithData call_virtual_with_data;
+	GDExtensionClassRecreateInstance recreate_instance;
+
+#ifdef TOOLS_ENABLED
+	void *tracking_userdata = nullptr;
+	void (*track_instance)(void *p_userdata, void *p_instance);
+	void (*untrack_instance)(void *p_userdata, void *p_instance);
+#endif
 };
 
 #define GDVIRTUAL_CALL(m_name, ...) _gdvirtual_##m_name##_call<false>(__VA_ARGS__)
@@ -750,6 +758,16 @@ protected:
 
 	bool _disconnect(const StringName &p_signal, const Callable &p_callable, bool p_force = false);
 
+#ifdef TOOLS_ENABLED
+	struct VirtualMethodTracker {
+		void **method;
+		bool *initialized;
+		VirtualMethodTracker *next;
+	};
+
+	mutable VirtualMethodTracker *virtual_method_list = nullptr;
+#endif
+
 public: // Should be protected, but bug in clang++.
 	static void initialize_class();
 	_FORCE_INLINE_ static void register_custom_data_to_otdb() {}
@@ -781,7 +799,8 @@ public:
 
 	enum {
 		NOTIFICATION_POSTINITIALIZE = 0,
-		NOTIFICATION_PREDELETE = 1
+		NOTIFICATION_PREDELETE = 1,
+		NOTIFICATION_EXTENSION_RELOADED = 2,
 	};
 
 	/* TYPE API */
@@ -952,6 +971,12 @@ public:
 	void set_instance_binding(void *p_token, void *p_binding, const GDExtensionInstanceBindingCallbacks *p_callbacks);
 	bool has_instance_binding(void *p_token);
 
+#ifdef TOOLS_ENABLED
+	void free_instance_binding(void *p_token);
+	void clear_internal_extension();
+	void reset_internal_extension(ObjectGDExtension *p_extension);
+#endif
+
 	void clear_internal_resource_paths();
 
 	_ALWAYS_INLINE_ bool is_ref_counted() const { return type_is_reference; }

doc/classes/GDExtensionManager.xml

@@ -43,6 +43,13 @@
 			</description>
 		</method>
 	</methods>
+	<signals>
+		<signal name="extensions_reloaded">
+			<description>
+				Emitted after the editor has automatically reloaded any extensions.
+			</description>
+		</signal>
+	</signals>
 	<constants>
 		<constant name="LOAD_STATUS_OK" value="0" enum="LoadStatus">
 		</constant>

editor/editor_node.cpp

@@ -31,6 +31,7 @@
 #include "editor_node.h"
 
 #include "core/config/project_settings.h"
+#include "core/extension/gdextension_manager.h"
 #include "core/input/input.h"
 #include "core/io/config_file.h"
 #include "core/io/file_access.h"
@@ -435,6 +436,11 @@ void EditorNode::_update_from_settings() {
 #endif // DEBUG_ENABLED
 }
 
+void EditorNode::_gdextensions_reloaded() {
+	// In case the developer is inspecting an object that will be changed by the reload.
+	InspectorDock::get_inspector_singleton()->update_tree();
+}
+
 void EditorNode::_select_default_main_screen_plugin() {
 	if (EDITOR_3D < main_editor_buttons.size() && main_editor_buttons[EDITOR_3D]->is_visible()) {
 		// If the 3D editor is enabled, use this as the default.
@@ -714,6 +720,9 @@ void EditorNode::_notification(int p_what) {
 
 			EditorFileSystem::get_singleton()->scan_changes();
 			_scan_external_changes();
+
+			GDExtensionManager *gdextension_manager = GDExtensionManager::get_singleton();
+			callable_mp(gdextension_manager, &GDExtensionManager::reload_extensions).call_deferred();
 		} break;
 
 		case NOTIFICATION_APPLICATION_FOCUS_OUT: {
@@ -3269,7 +3278,7 @@ void EditorNode::remove_extension_editor_plugin(const StringName &p_class_name)
 
 	EditorPlugin *plugin = singleton->editor_data.get_extension_editor_plugin(p_class_name);
 	remove_editor_plugin(plugin);
-	memfree(plugin);
+	memdelete(plugin);
 	singleton->editor_data.remove_extension_editor_plugin(p_class_name);
 }
 
@@ -6710,6 +6719,7 @@ EditorNode::EditorNode() {
 	EditorUndoRedoManager::get_singleton()->connect("version_changed", callable_mp(this, &EditorNode::_update_undo_redo_allowed));
 	EditorUndoRedoManager::get_singleton()->connect("history_changed", callable_mp(this, &EditorNode::_update_undo_redo_allowed));
 	ProjectSettings::get_singleton()->connect("settings_changed", callable_mp(this, &EditorNode::_update_from_settings));
+	GDExtensionManager::get_singleton()->connect("extensions_reloaded", callable_mp(this, &EditorNode::_gdextensions_reloaded));
 
 	TranslationServer::get_singleton()->set_enabled(false);
 	// Load settings.

editor/editor_node.h

@@ -597,6 +597,7 @@ private:
 	void _add_dropped_files_recursive(const Vector<String> &p_files, String to_path);
 
 	void _update_from_settings();
+	void _gdextensions_reloaded();
 
 	void _renderer_selected(int);
 	void _update_renderer_color();

main/main.cpp

@@ -1605,6 +1605,7 @@ Error Main::setup(const char *execpath, int argc, char *argv[], bool p_second_ph
 #ifdef TOOLS_ENABLED
 	if (editor) {
 		Engine::get_singleton()->set_editor_hint(true);
+		Engine::get_singleton()->set_extension_reloading_enabled(true);
 	}
 #endif