diff --git a/.github/workflows/all_builds.yml b/.github/workflows/all_builds.yml
index ea5590cc..0e5f4785 100644
--- a/.github/workflows/all_builds.yml
+++ b/.github/workflows/all_builds.yml
@@ -28,7 +28,7 @@ env:
   # TODO: change this back to godotengine/godot and target master when #109685 and #109475 are merged
   GODOT_REPOSITORY: nikitalita/godot
   # Change the README too
-  GODOT_MAIN_SYNC_REF: gdre-wb-e2a10cd4
+  GODOT_MAIN_SYNC_REF: gdre-wb-63227bb
   SCONSFLAGS: verbose=yes warnings=all werror=no module_text_server_fb_enabled=yes minizip=yes deprecated=yes
   SCONSFLAGS_TEMPLATE: no_editor_splash=yes module_camera_enabled=no module_mobile_vr_enabled=no module_upnp_enabled=no module_websocket_enabled=no module_csg_enabled=yes module_gridmap_enabled=yes use_static_cpp=yes builtin_freetype=yes builtin_libpng=yes builtin_zlib=yes builtin_libwebp=yes builtin_libvorbis=yes builtin_libogg=yes disable_3d=no
   SCONS_CACHE_MSVC_CONFIG: true
@@ -367,7 +367,6 @@ jobs:
         shell: bash
         run: |
           ${{matrix.bin}} --headless --test --force-colors "--test-case=[GDSDecomp]*"
-
   export:
     needs: build
     runs-on: ${{ matrix.os }}
diff --git a/.scripts/rebase_godot.sh b/.scripts/rebase_godot.sh
index 8b38b9d3..0595d55f 100755
--- a/.scripts/rebase_godot.sh
+++ b/.scripts/rebase_godot.sh
@@ -19,6 +19,9 @@ git checkout working-branch
 git reset --hard $HEAD
 
 BRANCHES_TO_MERGE=(
+	gltf-dupe-images
+	material-fix-deprecated-param
+	fix-dummy-mesh-blend-shape
 	fix-pack-error
 	convert-3.x-escn
 	fix-svg
diff --git a/README.md b/README.md
index 500344d7..6d5ca06f 100644
--- a/README.md
+++ b/README.md
@@ -149,7 +149,7 @@ Note: Make sure to build the editor build first, and to launch the editor to edi
 
 ### Requirements
 
-[Our fork of godot](https://github.com/nikitalita/godot/tree/working-branch) @ `gdre-wb-e2a10cd4`
+[Our fork of godot](https://github.com/nikitalita/godot/tree/working-branch) @ `gdre-wb-63227bb`
 
 - Support for building on 3.x has been dropped and no new features are being pushed
   - Godot RE Tools still retains the ability to decompile 3.x and 2.x projects, however.
diff --git a/SCsub b/SCsub
index 8bee7da6..18c095fe 100644
--- a/SCsub
+++ b/SCsub
@@ -43,7 +43,6 @@ if env["platform"] == "android" or (is_using_clang and env["platform"] == "macos
     # force shared on macos with clang++, because `ld` does not support multiple definitions of the same symbol
     mono_native_lib_type = "Shared"
 
-etcpak_dir = "#thirdparty/etcpak/"
 mmp3thirdparty_dir = "#thirdparty/minimp3/"
 liboggthirdparty_dir = "#thirdparty/libogg/"
 libtheorathirdparty_dir = "#thirdparty/libtheora/"
@@ -195,7 +194,6 @@ def write_version_header():
 write_version_header()
 
 
-env_gdsdecomp.Prepend(CPPPATH=[etcpak_dir])
 if env["builtin_libogg"]:
     env_gdsdecomp.Prepend(CPPPATH=[liboggthirdparty_dir])
 if env["builtin_libvorbis"]:
@@ -862,7 +860,6 @@ if env["tests"]:
 env_gdsdecomp.add_source_files(module_obj, "utility/*.cpp")
 
 env_gdsdecomp.add_source_files(module_obj, "external/tga/*.cpp")
-env_gdsdecomp.add_source_files(module_obj, "external/etcpak-decompress/*.cpp")
 env_gdsdecomp.add_source_files(module_obj, "external/tinygltf/tiny_gltf.cc")
 env_gdsdecomp.add_source_files(module_obj, "module_etc_decompress/*.cpp")
 
diff --git a/compat/resource_compat_binary.cpp b/compat/resource_compat_binary.cpp
index 9e82b163..37c49613 100644
--- a/compat/resource_compat_binary.cpp
+++ b/compat/resource_compat_binary.cpp
@@ -972,7 +972,16 @@ Error ResourceLoaderCompatBinary::load() {
 				if (!missing_resource && ver_major <= 2 && name == "resource/name") {
 					name = "resource_name";
 				}
-				res->set(name, value);
+				bool valid = false;
+				res->set(name, value, &valid);
+				if (!valid) {
+					missing_resource_properties[name] = value;
+#ifdef DEBUG_ENABLED
+					if (ver_major < GODOT_VERSION_MAJOR) {
+						WARN_PRINT(vformat("Failed to set deprecated %d.%d property '%s' (type: %s) on res class '%s' (remap: %s)", ver_major, ver_minor, name, Variant::get_type_name(value.get_type()), t, res->get_class()));
+					}
+#endif
+				}
 			}
 		}
 
diff --git a/compat/resource_compat_text.cpp b/compat/resource_compat_text.cpp
index 6d82217e..713746ac 100644
--- a/compat/resource_compat_text.cpp
+++ b/compat/resource_compat_text.cpp
@@ -803,7 +803,16 @@ Error ResourceLoaderCompatText::load() {
 						if (!missing_resource && ver_major <= 2 && assign == "resource/name") {
 							assign = "resource_name";
 						}
-						res->set(assign, value);
+						bool valid = false;
+						res->set(assign, value, &valid);
+						if (!valid) {
+							missing_resource_properties[assign] = value;
+#ifdef DEBUG_ENABLED
+							if (ver_major < GODOT_VERSION_MAJOR) {
+								WARN_PRINT(vformat("Failed to set deprecated %d.%d property '%s' (type: %s) on res class '%s' (class remap: %s)", ver_major, ver_minor, assign, Variant::get_type_name(value.get_type()), type, res->get_class()));
+							}
+#endif
+						}
 					}
 				}
 				//it's assignment
@@ -1010,7 +1019,16 @@ Error ResourceLoaderCompatText::load() {
 					if (!missing_resource && ver_major <= 2 && assign == "resource/name") {
 						assign = "resource_name";
 					}
-					resource->set(assign, value);
+					bool valid = false;
+					resource->set(assign, value, &valid);
+					if (!valid) {
+						missing_resource_properties[assign] = value;
+#ifdef DEBUG_ENABLED
+						if (ver_major < GODOT_VERSION_MAJOR) {
+							WARN_PRINT(vformat("Failed to set deprecated %d.%d property '%s' (type: %s) on res class '%s' (class remap: %s)", ver_major, ver_minor, assign, Variant::get_type_name(value.get_type()), res_type, resource->get_class()));
+						}
+#endif
+					}
 				}
 				//it's assignment
 			} else if (!next_tag.name.is_empty()) {
diff --git a/editor/gdre_editor.cpp b/editor/gdre_editor.cpp
index 7fcbb8cd..a8d2e5b2 100644
--- a/editor/gdre_editor.cpp
+++ b/editor/gdre_editor.cpp
@@ -258,6 +258,22 @@ void GodotREEditor::init_gui(Control *p_control, HBoxContainer *p_menu, bool p_l
 	smpl_file_selection->set_current_dir(desktop_dir);
 	p_control->add_child(smpl_file_selection);
 
+	export_resource_file_selection = memnew(FileDialog);
+	export_resource_file_selection->set_access(FileDialog::ACCESS_FILESYSTEM);
+	export_resource_file_selection->set_file_mode(FileDialog::FILE_MODE_OPEN_FILE);
+	export_resource_file_selection->connect("file_selected", callable_mp(this, &GodotREEditor::_export_resource_request));
+	export_resource_file_selection->set_show_hidden_files(true);
+	export_resource_file_selection->set_current_dir(desktop_dir);
+	p_control->add_child(export_resource_file_selection);
+
+	export_resource_output_selection = memnew(FileDialog);
+	export_resource_output_selection->set_access(FileDialog::ACCESS_FILESYSTEM);
+	export_resource_output_selection->set_file_mode(FileDialog::FILE_MODE_SAVE_FILE);
+	export_resource_output_selection->connect("file_selected", callable_mp(this, &GodotREEditor::_export_resource_output_request));
+	export_resource_output_selection->set_show_hidden_files(true);
+	export_resource_output_selection->set_current_dir(desktop_dir);
+	p_control->add_child(export_resource_output_selection);
+
 	//Init about/warning dialog
 	{
 		about_dialog = memnew(AcceptDialog);
@@ -344,6 +360,8 @@ void GodotREEditor::init_gui(Control *p_control, HBoxContainer *p_menu, bool p_l
 		menu_popup->add_icon_item(GDREGuiIcons::get_icon("REResOther", scale), RTR("Convert stream textures to PNG..."), MENU_STEX_TO_PNG);
 		menu_popup->add_icon_item(GDREGuiIcons::get_icon("REResOther", scale), RTR("Convert OGG Samples to OGG..."), MENU_OSTR_TO_OGG);
 		menu_popup->add_icon_item(GDREGuiIcons::get_icon("REResOther", scale), RTR("Convert WAV Samples to WAV..."), MENU_SMPL_TO_WAV);
+		menu_popup->add_icon_item(GDREGuiIcons::get_icon("REResOther", scale), RTR("Export Resource..."), MENU_EXPORT_RESOURCE);
+
 		menu_popup->connect("id_pressed", callable_mp(this, &GodotREEditor::menu_option_pressed));
 		menu_button->set_anchor(Side::SIDE_TOP, 0);
 		p_menu->add_child(menu_button);
@@ -374,6 +392,7 @@ void GodotREEditor::init_gui(Control *p_control, HBoxContainer *p_menu, bool p_l
 		menu_popup->add_icon_item(GDREGuiIcons::get_icon("REResOther", scale), RTR("Convert stream textures to PNG..."), MENU_STEX_TO_PNG);
 		menu_popup->add_icon_item(GDREGuiIcons::get_icon("REResOther", scale), RTR("Convert OGG Samples to OGG..."), MENU_OSTR_TO_OGG);
 		menu_popup->add_icon_item(GDREGuiIcons::get_icon("REResOther", scale), RTR("Convert WAV Samples to WAV..."), MENU_SMPL_TO_WAV);
+		menu_popup->add_icon_item(GDREGuiIcons::get_icon("REResOther", scale), RTR("Export Resource..."), MENU_EXPORT_RESOURCE);
 		menu_popup->connect("id_pressed", callable_mp(this, &GodotREEditor::menu_option_pressed));
 		menu_button->set_anchor(Side::SIDE_TOP, 0);
 		p_menu->add_child(menu_button);
@@ -454,6 +473,9 @@ void GodotREEditor::menu_option_pressed(int p_id) {
 		case MENU_SMPL_TO_WAV: {
 			smpl_file_selection->popup_centered(Size2(600, 400));
 		} break;
+		case MENU_EXPORT_RESOURCE: {
+			export_resource_file_selection->popup_centered();
+		} break;
 		case MENU_ABOUT_RE: {
 			show_about_dialog();
 		} break;
@@ -1077,6 +1099,55 @@ void GodotREEditor::_res_bin_2_txt_process() {
 	}
 }
 
+void GodotREEditor::_export_resource_request(const String &p_file) {
+	res_files = { p_file };
+	Vector<String> extensions = Exporter::get_export_extensions(p_file);
+	if (extensions.size() == 0) {
+		show_warning(RTR("No exporters found for resource " + p_file), RTR("Export resource"), RTR("No exporters found for resource " + p_file));
+		return;
+	}
+	String default_extension = extensions.size() > 0 ? extensions[0] : "";
+	String default_filename = p_file.get_file().get_basename() + "." + default_extension;
+	export_resource_output_selection->clear_filters();
+	for (const String &extension : extensions) {
+		export_resource_output_selection->add_filter("*." + extension);
+	}
+	export_resource_output_selection->set_current_file(default_filename);
+	export_resource_output_selection->popup_centered(Size2(600, 400));
+}
+
+void GodotREEditor::_export_resource_output_request(const String &p_path) {
+	_export_resource_process(p_path);
+}
+
+void GodotREEditor::_export_resource_process(const String &p_output_path) {
+	EditorProgressGDDC *pr = memnew(EditorProgressGDDC(ne_parent, "re_export_res", RTR("Exporting resources..."), res_files.size(), true));
+
+	String failed_files;
+	for (int i = 0; i < res_files.size(); i++) {
+		GDRESettings::get_singleton()->get_errors();
+		// print_warning("exporting " + res_files[i], RTR("Export resources"));
+		bool cancel = pr->step(res_files[i], i, true);
+		if (cancel) {
+			break;
+		}
+
+		Error err = Exporter::export_file(p_output_path, res_files[i]);
+		if (err != OK) {
+			failed_files += res_files[i] + " failed:\n" + GDRESettings::get_singleton()->get_recent_error_string() + "\n";
+		}
+	}
+
+	memdelete(pr);
+	res_files = Vector<String>();
+
+	if (failed_files.length() > 0) {
+		show_warning(failed_files, RTR("Export resources"), RTR("At least one error was detected!"));
+	} else {
+		show_warning(RTR("No errors detected."), RTR("Export resources"), RTR("The operation completed successfully!"));
+	}
+}
+
 Error GodotREEditor::convert_file_to_text(const String &p_src_path, const String &p_dst_path) {
 	return ResourceCompatLoader::to_text(p_src_path, p_dst_path);
 }
diff --git a/editor/gdre_editor.h b/editor/gdre_editor.h
index a285cd7f..51700079 100644
--- a/editor/gdre_editor.h
+++ b/editor/gdre_editor.h
@@ -95,6 +95,8 @@ class GodotREEditor : public Node {
 	FileDialog *stex_file_selection = nullptr;
 	FileDialog *ostr_file_selection = nullptr;
 	FileDialog *smpl_file_selection = nullptr;
+	FileDialog *export_resource_file_selection = nullptr;
+	FileDialog *export_resource_output_selection = nullptr;
 
 	MenuButton *menu_button = nullptr;
 	PopupMenu *menu_popup = nullptr;
@@ -135,6 +137,10 @@ class GodotREEditor : public Node {
 	void _res_smpl_2_wav_request(const Vector<String> &p_files);
 	void _res_smpl_2_wav_process();
 
+	void _export_resource_request(const String &p_file);
+	void _export_resource_output_request(const String &p_path);
+	void _export_resource_process(const String &p_output_dir);
+
 	Error convert_file_to_binary(const String &p_src_path, const String &p_dst_path);
 	Error convert_file_to_text(const String &p_src_path, const String &p_dst_path);
 
@@ -159,6 +165,7 @@ class GodotREEditor : public Node {
 		MENU_STEX_TO_PNG,
 		MENU_OSTR_TO_OGG,
 		MENU_SMPL_TO_WAV,
+		MENU_EXPORT_RESOURCE,
 		MENU_ABOUT_RE,
 		MENU_REPORT_ISSUE,
 		MENU_EXIT_RE,
diff --git a/exporters/autoconverted_exporter.cpp b/exporters/autoconverted_exporter.cpp
index 02108e77..1a9c66b7 100644
--- a/exporters/autoconverted_exporter.cpp
+++ b/exporters/autoconverted_exporter.cpp
@@ -37,3 +37,10 @@ String AutoConvertedExporter::get_default_export_extension(const String &res_pat
 	}
 	return "tres";
 }
+
+Vector<String> AutoConvertedExporter::get_export_extensions(const String &res_path) const {
+	if (res_path.get_extension().to_lower() == "scn") {
+		return { "tscn", "tres" };
+	}
+	return { "tres" };
+}
diff --git a/exporters/autoconverted_exporter.h b/exporters/autoconverted_exporter.h
index 0013d762..0e51a594 100644
--- a/exporters/autoconverted_exporter.h
+++ b/exporters/autoconverted_exporter.h
@@ -13,4 +13,5 @@ class AutoConvertedExporter : public ResourceExporter {
 	virtual void get_handled_types(List<String> *out) const override;
 	virtual void get_handled_importers(List<String> *out) const override;
 	virtual String get_default_export_extension(const String &res_path) const override;
+	virtual Vector<String> get_export_extensions(const String &res_path) const override;
 };
diff --git a/exporters/csharp_exporter.cpp b/exporters/csharp_exporter.cpp
index 99a13115..4c795174 100644
--- a/exporters/csharp_exporter.cpp
+++ b/exporters/csharp_exporter.cpp
@@ -55,3 +55,9 @@ String CSharpExporter::get_name() const {
 String CSharpExporter::get_default_export_extension(const String &res_path) const {
 	return "cs";
 }
+
+Vector<String> CSharpExporter::get_export_extensions(const String &res_path) const {
+	Vector<String> extensions;
+	extensions.push_back("cs");
+	return extensions;
+}
diff --git a/exporters/csharp_exporter.h b/exporters/csharp_exporter.h
index 64ac530e..e1cbc621 100644
--- a/exporters/csharp_exporter.h
+++ b/exporters/csharp_exporter.h
@@ -22,6 +22,7 @@ class CSharpExporter : public ResourceExporter {
 	virtual String get_name() const override;
 	virtual bool supports_nonpack_export() const override { return false; }
 	virtual String get_default_export_extension(const String &res_path) const override;
+	virtual Vector<String> get_export_extensions(const String &res_path) const override;
 	CSharpExporter() = default;
 	~CSharpExporter() = default;
 };
diff --git a/exporters/dialogue_exporter.cpp b/exporters/dialogue_exporter.cpp
index fc2b681d..d0ede7a7 100644
--- a/exporters/dialogue_exporter.cpp
+++ b/exporters/dialogue_exporter.cpp
@@ -72,3 +72,9 @@ void DialogueExporter::get_handled_importers(List<String> *out) const {
 String DialogueExporter::get_default_export_extension(const String &res_path) const {
 	return "dialogue";
 }
+
+Vector<String> DialogueExporter::get_export_extensions(const String &res_path) const {
+	Vector<String> extensions;
+	extensions.push_back("dialogue");
+	return extensions;
+}
diff --git a/exporters/dialogue_exporter.h b/exporters/dialogue_exporter.h
index c6a17576..4bebca15 100644
--- a/exporters/dialogue_exporter.h
+++ b/exporters/dialogue_exporter.h
@@ -13,4 +13,5 @@ class DialogueExporter : public ResourceExporter {
 	virtual void get_handled_types(List<String> *out) const override;
 	virtual void get_handled_importers(List<String> *out) const override;
 	virtual String get_default_export_extension(const String &res_path) const override;
+	virtual Vector<String> get_export_extensions(const String &res_path) const override;
 };
diff --git a/exporters/fontfile_exporter.cpp b/exporters/fontfile_exporter.cpp
index 9e07f36a..a4f3b60b 100644
--- a/exporters/fontfile_exporter.cpp
+++ b/exporters/fontfile_exporter.cpp
@@ -387,3 +387,9 @@ String FontFileExporter::get_name() const {
 String FontFileExporter::get_default_export_extension(const String &res_path) const {
 	return "ttf";
 }
+
+Vector<String> FontFileExporter::get_export_extensions(const String &res_path) const {
+	Vector<String> extensions = { "ttf", "otf" };
+	extensions.append_array(ImageSaver::get_supported_extensions());
+	return extensions;
+}
diff --git a/exporters/fontfile_exporter.h b/exporters/fontfile_exporter.h
index 8eb63176..eda1b43c 100644
--- a/exporters/fontfile_exporter.h
+++ b/exporters/fontfile_exporter.h
@@ -16,4 +16,5 @@ class FontFileExporter : public ResourceExporter {
 	virtual void get_handled_importers(List<String> *out) const override;
 	virtual String get_name() const override;
 	virtual String get_default_export_extension(const String &res_path) const override;
+	virtual Vector<String> get_export_extensions(const String &res_path) const override;
 };
diff --git a/exporters/gdextension_exporter.cpp b/exporters/gdextension_exporter.cpp
index ff6b148b..f1c7c3de 100644
--- a/exporters/gdextension_exporter.cpp
+++ b/exporters/gdextension_exporter.cpp
@@ -374,3 +374,9 @@ String GDExtensionExporter::get_name() const {
 String GDExtensionExporter::get_default_export_extension(const String &res_path) const {
 	return "gdext";
 }
+
+Vector<String> GDExtensionExporter::get_export_extensions(const String &res_path) const {
+	Vector<String> extensions;
+	extensions.push_back("gdext");
+	return extensions;
+}
diff --git a/exporters/gdextension_exporter.h b/exporters/gdextension_exporter.h
index 37085595..f9f74404 100644
--- a/exporters/gdextension_exporter.h
+++ b/exporters/gdextension_exporter.h
@@ -14,4 +14,5 @@ class GDExtensionExporter : public ResourceExporter {
 	virtual String get_name() const override;
 	virtual bool supports_nonpack_export() const override { return false; }
 	virtual String get_default_export_extension(const String &res_path) const override;
+	virtual Vector<String> get_export_extensions(const String &res_path) const override;
 };
diff --git a/exporters/gdscript_exporter.cpp b/exporters/gdscript_exporter.cpp
index c167dd24..713812fe 100644
--- a/exporters/gdscript_exporter.cpp
+++ b/exporters/gdscript_exporter.cpp
@@ -100,6 +100,12 @@ String GDScriptExporter::get_default_export_extension(const String &res_path) co
 	return "gd";
 }
 
+Vector<String> GDScriptExporter::get_export_extensions(const String &res_path) const {
+	Vector<String> extensions;
+	extensions.push_back("gd");
+	return extensions;
+}
+
 Error GDScriptExporter::test_export(const Ref<ExportReport> &export_report, const String &original_project_dir) const {
 	Error _ret_err = OK;
 	{
diff --git a/exporters/gdscript_exporter.h b/exporters/gdscript_exporter.h
index ac0628ac..75100c5f 100644
--- a/exporters/gdscript_exporter.h
+++ b/exporters/gdscript_exporter.h
@@ -24,6 +24,7 @@ class GDScriptExporter : public ResourceExporter {
 	virtual String get_name() const override;
 	virtual bool supports_nonpack_export() const override { return false; }
 	virtual String get_default_export_extension(const String &res_path) const override;
+	virtual Vector<String> get_export_extensions(const String &res_path) const override;
 	virtual Error test_export(const Ref<ExportReport> &export_report, const String &original_project_dir) const override;
 	GDScriptExporter() = default;
 	~GDScriptExporter() = default;
diff --git a/exporters/mp3str_exporter.cpp b/exporters/mp3str_exporter.cpp
index ac1b628f..71027670 100644
--- a/exporters/mp3str_exporter.cpp
+++ b/exporters/mp3str_exporter.cpp
@@ -73,6 +73,10 @@ String Mp3StrExporter::get_default_export_extension(const String &res_path) cons
 	return "mp3";
 }
 
+Vector<String> Mp3StrExporter::get_export_extensions(const String &res_path) const {
+	return { "mp3" };
+}
+
 Error Mp3StrExporter::test_export(const Ref<ExportReport> &export_report, const String &original_project_dir) const {
 	Error _ret_err = OK;
 	{
diff --git a/exporters/mp3str_exporter.h b/exporters/mp3str_exporter.h
index 42f60e74..ab4f2af2 100644
--- a/exporters/mp3str_exporter.h
+++ b/exporters/mp3str_exporter.h
@@ -15,5 +15,6 @@ class Mp3StrExporter : public ResourceExporter {
 	virtual void get_handled_types(List<String> *out) const override;
 	virtual void get_handled_importers(List<String> *out) const override;
 	virtual String get_default_export_extension(const String &res_path) const override;
+	virtual Vector<String> get_export_extensions(const String &res_path) const override;
 	virtual Error test_export(const Ref<ExportReport> &export_report, const String &original_project_dir) const override;
 };
diff --git a/exporters/obj_exporter.cpp b/exporters/obj_exporter.cpp
index 5cb1da9c..af5c93a3 100644
--- a/exporters/obj_exporter.cpp
+++ b/exporters/obj_exporter.cpp
@@ -620,3 +620,7 @@ String ObjExporter::get_name() const {
 String ObjExporter::get_default_export_extension(const String &res_path) const {
 	return "obj";
 }
+
+Vector<String> ObjExporter::get_export_extensions(const String &res_path) const {
+	return { "obj" };
+}
diff --git a/exporters/obj_exporter.h b/exporters/obj_exporter.h
index ba4eba81..1852eb1d 100644
--- a/exporters/obj_exporter.h
+++ b/exporters/obj_exporter.h
@@ -39,6 +39,7 @@ class ObjExporter : public ResourceExporter {
 	virtual Ref<ExportReport> export_resource(const String &p_output_dir, Ref<ImportInfo> p_import_info) override;
 	virtual bool supports_multithread() const override;
 	virtual String get_default_export_extension(const String &res_path) const override;
+	virtual Vector<String> get_export_extensions(const String &res_path) const override;
 };
 
 #endif // OBJ_EXPORTER_H
diff --git a/exporters/oggstr_exporter.cpp b/exporters/oggstr_exporter.cpp
index 712e5e07..03c596e8 100644
--- a/exporters/oggstr_exporter.cpp
+++ b/exporters/oggstr_exporter.cpp
@@ -204,6 +204,10 @@ String OggStrExporter::get_default_export_extension(const String &res_path) cons
 	return "ogg";
 }
 
+Vector<String> OggStrExporter::get_export_extensions(const String &res_path) const {
+	return { "ogg" };
+}
+
 namespace {
 auto packet_data_to_flat_vector(const TypedArray<Array> &packet_data) -> Vector<Vector<uint8_t>> {
 	Vector<Vector<uint8_t>> data;
diff --git a/exporters/oggstr_exporter.h b/exporters/oggstr_exporter.h
index a1929aa9..20a85803 100644
--- a/exporters/oggstr_exporter.h
+++ b/exporters/oggstr_exporter.h
@@ -19,5 +19,6 @@ class OggStrExporter : public ResourceExporter {
 	virtual void get_handled_types(List<String> *out) const override;
 	virtual void get_handled_importers(List<String> *out) const override;
 	virtual String get_default_export_extension(const String &res_path) const override;
+	virtual Vector<String> get_export_extensions(const String &res_path) const override;
 	virtual Error test_export(const Ref<ExportReport> &export_report, const String &original_project_dir) const override;
 };
diff --git a/exporters/resource_exporter.cpp b/exporters/resource_exporter.cpp
index 04a1cb62..e56bef01 100644
--- a/exporters/resource_exporter.cpp
+++ b/exporters/resource_exporter.cpp
@@ -83,6 +83,10 @@ String ResourceExporter::get_default_export_extension(const String &res_path) co
 	ERR_FAIL_V_MSG(String(), "Not implemented");
 }
 
+Vector<String> ResourceExporter::get_export_extensions(const String &res_path) const {
+	ERR_FAIL_V_MSG(Vector<String>(), "Not implemented");
+}
+
 Error ResourceExporter::test_export(const Ref<ExportReport> &export_report, const String &original_project_dir) const {
 	return ERR_UNAVAILABLE;
 }
@@ -94,6 +98,7 @@ void ResourceExporter::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("export_resource", "output_dir", "import_infos"), &ResourceExporter::export_resource);
 	ClassDB::bind_method(D_METHOD("handles_import", "importer", "resource_type"), &ResourceExporter::handles_import);
 	ClassDB::bind_method(D_METHOD("get_default_export_extension", "res_path"), &ResourceExporter::get_default_export_extension);
+	ClassDB::bind_method(D_METHOD("get_export_extensions", "res_path"), &ResourceExporter::get_export_extensions);
 }
 
 Ref<ExportReport> ResourceExporter::_check_for_existing_resources(const Ref<ImportInfo> &iinfo) {
@@ -212,6 +217,11 @@ String Exporter::get_default_export_extension(const String &res_path) {
 	return exporter.is_null() ? "" : exporter->get_default_export_extension(res_path);
 }
 
+Vector<String> Exporter::get_export_extensions(const String &res_path) {
+	auto exporter = get_exporter_from_path(res_path, false);
+	return exporter.is_null() ? Vector<String>() : exporter->get_export_extensions(res_path);
+}
+
 Error Exporter::test_export(const Ref<ExportReport> &export_report, const String &original_project_dir) {
 	ERR_FAIL_NULL_V(export_report, ERR_BUG);
 	ERR_FAIL_NULL_V(export_report->get_import_info(), ERR_BUG);
@@ -233,4 +243,5 @@ void Exporter::_bind_methods() {
 	ClassDB::bind_static_method(get_class_static(), D_METHOD("get_exporter_from_path", "res_path", "nonpack_export"), &Exporter::get_exporter_from_path, DEFVAL(true));
 	ClassDB::bind_static_method(get_class_static(), D_METHOD("is_exportable_resource", "res_path"), &Exporter::is_exportable_resource);
 	ClassDB::bind_static_method(get_class_static(), D_METHOD("get_default_export_extension", "res_path"), &Exporter::get_default_export_extension);
+	ClassDB::bind_static_method(get_class_static(), D_METHOD("get_export_extensions", "res_path"), &Exporter::get_export_extensions);
 }
diff --git a/exporters/resource_exporter.h b/exporters/resource_exporter.h
index 1cf6fce2..2fa97ffa 100644
--- a/exporters/resource_exporter.h
+++ b/exporters/resource_exporter.h
@@ -22,6 +22,7 @@ class ResourceExporter : public RefCounted {
 	virtual bool supports_multithread() const;
 	virtual bool supports_nonpack_export() const;
 	virtual String get_default_export_extension(const String &res_path) const;
+	virtual Vector<String> get_export_extensions(const String &res_path) const;
 	virtual Error test_export(const Ref<ExportReport> &export_report, const String &original_project_dir) const;
 
 	static Ref<ExportReport> _check_for_existing_resources(const Ref<ImportInfo> &iinfo);
@@ -49,5 +50,6 @@ class Exporter : public Object {
 	static Ref<ResourceExporter> get_exporter_from_path(const String &res_path, bool p_nonpack_export = false);
 	static bool is_exportable_resource(const String &res_path);
 	static String get_default_export_extension(const String &res_path);
+	static Vector<String> get_export_extensions(const String &res_path);
 	static Error test_export(const Ref<ExportReport> &export_report, const String &original_project_dir);
 };
diff --git a/exporters/sample_exporter.cpp b/exporters/sample_exporter.cpp
index 6f943736..667fe34b 100644
--- a/exporters/sample_exporter.cpp
+++ b/exporters/sample_exporter.cpp
@@ -286,6 +286,10 @@ String SampleExporter::get_default_export_extension(const String &res_path) cons
 	return "wav";
 }
 
+Vector<String> SampleExporter::get_export_extensions(const String &res_path) const {
+	return { "wav" };
+}
+
 Error SampleExporter::test_export(const Ref<ExportReport> &export_report, const String &original_project_dir) const {
 	Error _ret_err = OK;
 	{
diff --git a/exporters/sample_exporter.h b/exporters/sample_exporter.h
index d78b9bf6..bb16138d 100644
--- a/exporters/sample_exporter.h
+++ b/exporters/sample_exporter.h
@@ -18,5 +18,6 @@ class SampleExporter : public ResourceExporter {
 	virtual void get_handled_importers(List<String> *out) const override;
 	virtual String get_name() const override;
 	virtual String get_default_export_extension(const String &res_path) const override;
+	virtual Vector<String> get_export_extensions(const String &res_path) const override;
 	virtual Error test_export(const Ref<ExportReport> &export_report, const String &original_project_dir) const override;
 };
diff --git a/exporters/scene_exporter.cpp b/exporters/scene_exporter.cpp
index 234e5e8f..95fccab6 100644
--- a/exporters/scene_exporter.cpp
+++ b/exporters/scene_exporter.cpp
@@ -4,6 +4,7 @@
 #include "core/io/file_access.h"
 #include "core/io/resource_loader.h"
 #include "core/variant/variant.h"
+#include "core/version_generated.gen.h"
 #include "exporters/export_report.h"
 #include "exporters/obj_exporter.h"
 #include "external/tinygltf/tiny_gltf.h"
@@ -12,25 +13,28 @@
 #include "modules/gltf/structures/gltf_node.h"
 #include "modules/regex/regex.h"
 #include "scene/3d/mesh_instance_3d.h"
+#include "scene/3d/navigation/navigation_region_3d.h"
 #include "scene/3d/occluder_instance_3d.h"
+#include "scene/3d/physics/area_3d.h"
 #include "scene/3d/physics/rigid_body_3d.h"
 #include "scene/3d/physics/static_body_3d.h"
 #include "scene/resources/3d/box_shape_3d.h"
 #include "scene/resources/3d/capsule_shape_3d.h"
 #include "scene/resources/3d/cylinder_shape_3d.h"
 #include "scene/resources/3d/sphere_shape_3d.h"
+#include "scene/resources/surface_tool.h"
 #include "scene/resources/texture.h"
 #include "utility/common.h"
 #include "utility/gdre_config.h"
 #include "utility/gdre_logger.h"
 #include "utility/gdre_settings.h"
 
-#include "core/crypto/crypto_core.h"
 #include "core/error/error_list.h"
 #include "core/error/error_macros.h"
 #include "main/main.h"
 #include "scene/resources/compressed_texture.h"
 #include "scene/resources/packed_scene.h"
+#include "servers/navigation_3d/navigation_server_3d.h"
 #include "utility/task_manager.h"
 
 #ifndef MAKE_GLTF_COPY
@@ -676,6 +680,8 @@ String GLBExporterInstance::add_errors_to_report(Error p_err, const String &err_
 		err_message = "Export was cancelled";
 	} else if (p_err == ERR_TIMEOUT) {
 		err_message = "Export timed out";
+	} else if (p_err == OK) {
+		err_message = "";
 	}
 	if (!err_msg.is_empty()) {
 		err_message += ":\n  " + err_msg;
@@ -685,6 +691,10 @@ String GLBExporterInstance::add_errors_to_report(Error p_err, const String &err_
 	}
 	error_statement = err_message;
 	Vector<String> errors;
+	if (scene_loading_error_messages.size() > 0) {
+		errors.append("** Errors during scene loading:");
+		errors.append_array(scene_loading_error_messages);
+	}
 	if (scene_instantiation_error_messages.size() > 0) {
 		errors.append("** Errors during scene instantiation:");
 		errors.append_array(scene_instantiation_error_messages);
@@ -718,8 +728,9 @@ String GLBExporterInstance::add_errors_to_report(Error p_err, const String &err_
 			}
 		}
 		report->set_message(error_statement + "\n");
-		report->append_message_detail({ "Dependencies:" });
-		report->append_message_detail(dependency_resolution_list);
+		Dictionary extra_info = report->get_extra_info();
+		extra_info["dependencies"] = dependency_resolution_list;
+		report->set_extra_info(extra_info);
 		report->set_error(p_err);
 		report->append_error_messages(errors);
 	}
@@ -763,15 +774,14 @@ void GLBExporterInstance::set_cache_res(const dep_info &info, const Ref<Resource
 }
 
 String GLBExporterInstance::get_name_res(const Dictionary &dict, const Ref<Resource> &res, int64_t idx) {
-	String name = dict.get("name", String());
+	String name;
+	name = dict.get("name", String());
 	if (name.is_empty()) {
 		name = res->get_name();
 		if (name.is_empty()) {
 			Ref<ResourceInfo> info = ResourceInfo::get_info_from_resource(res);
 			if (info.is_valid() && !info->resource_name.is_empty()) {
 				name = info->resource_name;
-			} else {
-				// name = res->get_class() + "_" + String::num_int64(idx);
 			}
 		}
 	}
@@ -880,6 +890,7 @@ void GLBExporterInstance::_initial_set(const String &p_src_path, Ref<ExportRepor
 }
 
 Error GLBExporterInstance::_load_deps() {
+	other_error_messages.append_array(_get_logged_error_messages());
 	get_deps_recursive(source_path, get_deps_map);
 
 	for (auto &E : get_deps_map) {
@@ -949,6 +960,7 @@ Error GLBExporterInstance::_load_deps() {
 		}
 		if (!FileAccess::exists(info.remap) && !FileAccess::exists(info.dep)) {
 			if (ignore_missing_dependencies) {
+				missing_dependencies.push_back(info.dep);
 				WARN_PRINT(vformat("%s: Dependency %s -> %s does not exist.", source_path, info.dep, info.remap));
 				continue;
 			}
@@ -983,6 +995,7 @@ Error GLBExporterInstance::_load_deps() {
 							ResourceFormatLoader::CACHE_MODE_IGNORE); // not ignore deep, we want to reuse dependencies if they exist
 					if (err || texture.is_null()) {
 						if (ignore_missing_dependencies) {
+							missing_dependencies.push_back(info.dep);
 							WARN_PRINT(vformat("%s: Dependency %s:%s failed to load.", source_path, info.dep, info.remap));
 							continue;
 						}
@@ -1029,6 +1042,7 @@ Error GLBExporterInstance::_load_deps() {
 		report->set_loss_type(ImportInfo::STORED_LOSSY);
 	}
 
+	scene_loading_error_messages.append_array(_get_logged_error_messages());
 	return OK;
 }
 
@@ -1093,9 +1107,9 @@ Dictionary get_default_node_options() {
 
 	// INTERNAL_IMPORT_CATEGORY_MESH_3D_NODE
 	dict["generate/physics"] = false;
-	dict["generate/navmesh"] = 0;
-	dict["physics/body_type"] = 0;
-	dict["physics/shape_type"] = 7;
+	dict["generate/navmesh"] = SceneExporterEnums::NAVMESH_DISABLED;
+	dict["physics/body_type"] = SceneExporterEnums::BODY_TYPE_STATIC;
+	dict["physics/shape_type"] = SceneExporterEnums::SHAPE_TYPE_AUTOMATIC;
 	dict["physics/physics_material_override"] = Variant();
 	dict["physics/layer"] = 1;
 	dict["physics/mask"] = 1;
@@ -1134,7 +1148,7 @@ Dictionary get_default_node_options() {
 	dict["primitive/position"] = Vector3();
 	dict["primitive/rotation"] = Vector3();
 
-	dict["generate/occluder"] = 0;
+	dict["generate/occluder"] = SceneExporterEnums::OCCLUDER_DISABLED;
 	dict["occluder/simplification_distance"] = 0.1f;
 
 	// animation node
@@ -1157,20 +1171,55 @@ Dictionary get_default_node_options() {
 	return dict;
 }
 
-Dictionary get_node_options(Node *p_node) {
+bool is_auto_generated_node(Node *p_node) {
+	ERR_FAIL_NULL_V(p_node, false);
+	RigidBody3D *parent_rigid_body = Object::cast_to<RigidBody3D>(p_node);
+	if (parent_rigid_body) {
+		for (auto &child : p_node->get_children()) {
+			if (Object::cast_to<MeshInstance3D>(child)) {
+				return true;
+			}
+		}
+	}
+	Node *parent = p_node->get_parent();
+	Node *parent_parent = parent ? parent->get_parent() : nullptr;
+	if (parent && p_node->get_owner() != parent->get_owner()) {
+		parent_parent = nullptr;
+	}
+	bool parent_is_mesh_instance = parent ? !!Object::cast_to<MeshInstance3D>(parent) : false;
+	bool parent_is_root_and_node3d = parent && parent_parent == nullptr && parent->get_class() == "Node3D";
+	if (Object::cast_to<StaticBody3D>(p_node) && (!parent || parent_is_root_and_node3d || parent_is_mesh_instance || Object::cast_to<Area3D>(parent))) {
+		return true;
+	}
+	if (!parent || parent_is_mesh_instance || parent_is_root_and_node3d) {
+		if (Object::cast_to<NavigationRegion3D>(p_node)) {
+			return true;
+		}
+		if (Object::cast_to<OccluderInstance3D>(p_node)) {
+			return true;
+		}
+	}
+	if (parent && Object::cast_to<CollisionShape3D>(p_node)) {
+		if (Object::cast_to<Area3D>(parent)) {
+			return true;
+		}
+		return is_auto_generated_node(parent);
+	}
+	return false;
+}
+
+Dictionary get_node_options(Node *p_node, Node *original_node = nullptr) {
+	ERR_FAIL_NULL_V(p_node, Dictionary());
 	Dictionary node_options_dict = Dictionary();
 
 	MeshInstance3D *mesh_instance = Object::cast_to<MeshInstance3D>(p_node);
 	AnimationPlayer *animation_player = Object::cast_to<AnimationPlayer>(p_node);
+	Skeleton3D *skeleton = Object::cast_to<Skeleton3D>(p_node);
 	Ref<Script> script = p_node->get_script();
-	if (!mesh_instance && !animation_player) {
+	if (!mesh_instance && !animation_player && !skeleton && !is_auto_generated_node(p_node)) {
 		String type_name;
 		if (script.is_valid()) {
 			type_name = script->get_global_name();
-			// TODO: fix FakeScript to not put the path in the global name if it doesn't have a class_name
-			if (type_name.begins_with("res://")) {
-				type_name = "";
-			}
 		}
 		if (type_name.is_empty()) {
 			type_name = p_node->get_class();
@@ -1210,15 +1259,14 @@ Dictionary get_node_options(Node *p_node) {
 			body_type = SceneExporterEnums::BODY_TYPE_DYNAMIC;
 		}
 		for (auto &child : p_node->get_children()) {
-			if (Object::cast_to<StaticBody3D>(child)) {
-				auto static_body = Object::cast_to<StaticBody3D>(child);
+			if (auto static_body = Object::cast_to<StaticBody3D>(child); static_body) {
 				physics_body_node = static_body;
 				physics_material_override = static_body->get_physics_material_override();
 				body_type = SceneExporterEnums::BODY_TYPE_STATIC;
 				mesh_physics_mode = SceneExporterEnums::MESH_PHYSICS_MESH_AND_STATIC_COLLIDER;
 			}
 			// navmesh
-			if (Object::cast_to<NavigationMesh>(child)) {
+			if (auto navmesh = Object::cast_to<NavigationRegion3D>(child); navmesh) {
 				navmesh_mode = SceneExporterEnums::NAVMESH_MESH_AND_NAVMESH;
 			}
 			// occluder
@@ -1228,6 +1276,21 @@ Dictionary get_node_options(Node *p_node) {
 			}
 		}
 
+		if (original_node) {
+			if (auto area_3d = Object::cast_to<Area3D>(original_node); area_3d) {
+				mesh_physics_mode = SceneExporterEnums::MESH_PHYSICS_AREA_ONLY;
+			} else {
+				if (auto navigation_region = Object::cast_to<NavigationRegion3D>(original_node); navigation_region) {
+					navmesh_mode = SceneExporterEnums::NAVMESH_NAVMESH_ONLY;
+				} else if (auto occluder_instance = Object::cast_to<OccluderInstance3D>(original_node); occluder_instance) {
+					occluder_mode = SceneExporterEnums::OCCLUDER_OCCLUDER_ONLY;
+				}
+				if (mesh_physics_mode == SceneExporterEnums::MESH_PHYSICS_MESH_AND_STATIC_COLLIDER) {
+					mesh_physics_mode = SceneExporterEnums::MESH_PHYSICS_STATIC_COLLIDER_ONLY;
+				}
+			}
+		}
+
 		node_options_dict["generate/physics"] = mesh_physics_mode != SceneExporterEnums::MESH_PHYSICS_DISABLED;
 		node_options_dict["generate/navmesh"] = navmesh_mode;
 		Dictionary primtive_options_dict = Dictionary();
@@ -1235,35 +1298,35 @@ Dictionary get_node_options(Node *p_node) {
 		if (physics_body_node) {
 			physics_layer_bits = physics_body_node->get_collision_layer();
 			physics_mask_bits = physics_body_node->get_collision_mask();
-			TypedArray<Node> physics_nodes = p_node->find_children("*", "CollisionObject3D");
+			TypedArray<Node> physics_nodes = physics_body_node->find_children("*", "CollisionShape3D", true);
 			if (physics_nodes.size() > 1) {
 				// easy, it's decomposing convex
 				shape_type = SceneExporterEnums::SHAPE_TYPE_DECOMPOSE_CONVEX;
 			} else if (physics_nodes.size() == 1) {
-				CollisionObject3D *physics_node = Object::cast_to<CollisionObject3D>(physics_nodes[0]);
+				CollisionShape3D *physics_node = Object::cast_to<CollisionShape3D>(physics_nodes[0]);
 				if (physics_node) {
-					auto shape = physics_node->get("shape");
-					if (auto convex_shape = Object::cast_to<ConvexPolygonShape3D>(shape); convex_shape) {
+					auto shape = physics_node->get_shape();
+					if (Ref<ConvexPolygonShape3D> convex_shape = shape; convex_shape.is_valid()) {
 						shape_type = SceneExporterEnums::SHAPE_TYPE_SIMPLE_CONVEX;
-					} else if (auto concave_shape = Object::cast_to<ConcavePolygonShape3D>(shape); concave_shape) {
+					} else if (Ref<ConcavePolygonShape3D> concave_shape = shape; concave_shape.is_valid()) {
 						shape_type = SceneExporterEnums::SHAPE_TYPE_TRIMESH;
-					} else if (auto box_shape = Object::cast_to<BoxShape3D>(shape); box_shape) {
+					} else if (Ref<BoxShape3D> box_shape = shape; box_shape.is_valid()) {
 						shape_type = SceneExporterEnums::SHAPE_TYPE_BOX;
 						primtive_options_dict["primitive/size"] = box_shape->get_size();
 						primtive_options_dict["primitive/position"] = physics_node->get_position();
 						primtive_options_dict["primitive/rotation"] = physics_node->get_rotation();
-					} else if (auto sphere_shape = Object::cast_to<SphereShape3D>(shape); sphere_shape) {
+					} else if (Ref<SphereShape3D> sphere_shape = shape; sphere_shape.is_valid()) {
 						shape_type = SceneExporterEnums::SHAPE_TYPE_SPHERE;
 						primtive_options_dict["primitive/radius"] = sphere_shape->get_radius();
 						primtive_options_dict["primitive/position"] = physics_node->get_position();
 						primtive_options_dict["primitive/rotation"] = physics_node->get_rotation();
-					} else if (auto cylinder_shape = Object::cast_to<CylinderShape3D>(shape); cylinder_shape) {
+					} else if (Ref<CylinderShape3D> cylinder_shape = shape; cylinder_shape.is_valid()) {
 						shape_type = SceneExporterEnums::SHAPE_TYPE_CYLINDER;
 						primtive_options_dict["primitive/height"] = cylinder_shape->get_height();
 						primtive_options_dict["primitive/radius"] = cylinder_shape->get_radius();
 						primtive_options_dict["primitive/position"] = physics_node->get_position();
 						primtive_options_dict["primitive/rotation"] = physics_node->get_rotation();
-					} else if (auto capsule_shape = Object::cast_to<CapsuleShape3D>(shape); capsule_shape) {
+					} else if (Ref<CapsuleShape3D> capsule_shape = shape; capsule_shape.is_valid()) {
 						shape_type = SceneExporterEnums::SHAPE_TYPE_CAPSULE;
 						primtive_options_dict["primitive/height"] = capsule_shape->get_height();
 						primtive_options_dict["primitive/radius"] = capsule_shape->get_radius();
@@ -1304,6 +1367,10 @@ Dictionary get_node_options(Node *p_node) {
 			node_options_dict["occluder/simplification_distance"] = occlusion_simplification_distance;
 		}
 	}
+	// AnimationPlayer options modify the imported animations, they all have to do with optimizing and culling tracks,
+	// so we want the default options.
+	// Skeleton3D options modify the imported skeleton and it will be exported according to those modifications
+	// e.g. a retargeted skeleton will be exported with the retargeted bones, so we want the default options so as to leave it as is.
 
 	return node_options_dict;
 }
@@ -1319,21 +1386,95 @@ NodePath get_node_path(Node *p_node) {
 	}
 
 	path.reverse();
+	if (path.is_empty()) {
+		return NodePath(".");
+	}
 
 	return NodePath(path, true);
 }
 
-void GLBExporterInstance::_set_stuff_from_instanced_scene(Node *root) {
+// disabled in debug builds, so we have to copy-and-paste it here.
+Ref<ArrayMesh> get_nav_array_debug_mesh(const Ref<NavigationMesh> navmesh) {
+	Ref<ArrayMesh> debug_mesh;
+	debug_mesh.instantiate();
+	Vector<Vector3> vertices = navmesh->get_vertices();
+
+	if (vertices.is_empty()) {
+		return debug_mesh;
+	}
+
+	int polygon_count = navmesh->get_polygon_count();
+
+	if (polygon_count < 1) {
+		// no face, no play
+		return debug_mesh;
+	}
+
+	// build geometry face surface
+	Vector<Vector3> face_vertex_array;
+	face_vertex_array.resize(polygon_count * 3);
+
+	for (int i = 0; i < polygon_count; i++) {
+		Vector<int> polygon = navmesh->get_polygon(i);
+
+		face_vertex_array.push_back(vertices[polygon[0]]);
+		face_vertex_array.push_back(vertices[polygon[1]]);
+		face_vertex_array.push_back(vertices[polygon[2]]);
+	}
+
+	Array face_mesh_array;
+	face_mesh_array.resize(Mesh::ARRAY_MAX);
+	face_mesh_array[Mesh::ARRAY_VERTEX] = face_vertex_array;
+
+	// if enabled add vertex colors to colorize each face individually
+	static constexpr bool enabled_geometry_face_random_color = false;
+	static const Color debug_navigation_geometry_face_color = Color(0.5, 1.0, 1.0, 0.4);
+	if (enabled_geometry_face_random_color) {
+		Color polygon_color = debug_navigation_geometry_face_color;
+
+		Vector<Color> face_color_array;
+		face_color_array.resize(polygon_count * 3);
+
+		for (int i = 0; i < polygon_count; i++) {
+			polygon_color = debug_navigation_geometry_face_color * (Color(Math::randf(), Math::randf(), Math::randf()));
+
+			face_color_array.push_back(polygon_color);
+			face_color_array.push_back(polygon_color);
+			face_color_array.push_back(polygon_color);
+		}
+		face_mesh_array[Mesh::ARRAY_COLOR] = face_color_array;
+	}
+
+	debug_mesh->add_surface_from_arrays(Mesh::PRIMITIVE_TRIANGLES, face_mesh_array);
+	Ref<StandardMaterial3D> face_material;
+	face_material = Ref<StandardMaterial3D>(memnew(StandardMaterial3D));
+	face_material->set_shading_mode(StandardMaterial3D::SHADING_MODE_UNSHADED);
+	face_material->set_transparency(StandardMaterial3D::TRANSPARENCY_ALPHA);
+	face_material->set_albedo(debug_navigation_geometry_face_color);
+	face_material->set_cull_mode(StandardMaterial3D::CULL_DISABLED);
+	face_material->set_flag(StandardMaterial3D::FLAG_DISABLE_FOG, true);
+	if (enabled_geometry_face_random_color) {
+		face_material->set_flag(StandardMaterial3D::FLAG_SRGB_VERTEX_COLOR, true);
+		face_material->set_flag(StandardMaterial3D::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
+	}
+	debug_mesh->surface_set_material(0, face_material);
+
+	return debug_mesh;
+}
+
+Node *GLBExporterInstance::_set_stuff_from_instanced_scene(Node *root) {
 	root_type = root->get_class();
 	root_name = root->get_name();
 
 	TypedArray<Node> animation_player_nodes = root->find_children("*", "AnimationPlayer");
 	TypedArray<Node> mesh_instances = root->find_children("*", "MeshInstance3D");
 	HashSet<Node *> skinned_mesh_instances;
+	HashSet<Node *> generated_mesh_instance_parents;
+	HashMap<Ref<ShaderMaterial>, Ref<BaseMaterial3D>> shader_material_to_base_material_map;
+
 	HashSet<Ref<Mesh>> meshes_in_mesh_instances;
-	for (auto &E : mesh_instances) {
-		MeshInstance3D *mesh_instance = Object::cast_to<MeshInstance3D>(E);
-		ERR_CONTINUE(!mesh_instance);
+
+	auto process_mesh_instance = [&](MeshInstance3D *mesh_instance) {
 		auto skin = mesh_instance->get_skin();
 		if (skin.is_valid()) {
 			has_skinned_meshes = true;
@@ -1347,102 +1488,265 @@ void GLBExporterInstance::_set_stuff_from_instanced_scene(Node *root) {
 				mesh_path_to_instance_map[path] = mesh_instance;
 			}
 		}
-		if (updating_import_info) {
-			auto node_path = get_node_path(mesh_instance);
-			if (!node_path.is_empty()) {
-				node_options[node_path.operator String()] = get_node_options(mesh_instance);
+		if (replace_shader_materials && mesh.is_valid()) {
+			for (int surface_i = 0; surface_i < mesh->get_surface_count(); surface_i++) {
+				Ref<ShaderMaterial> shader_material;
+				Ref<Material> active_surface_material = mesh_instance->get_active_material(surface_i);
+				Ref<Material> surface_material = mesh->surface_get_material(surface_i);
+				Ref<BaseMaterial3D> base_material;
+				shader_material = active_surface_material;
+				if (shader_material.is_valid()) {
+					if (shader_material_to_base_material_map.has(shader_material)) {
+						base_material = shader_material_to_base_material_map[shader_material];
+					} else {
+						Pair<Ref<BaseMaterial3D>, Pair<bool, bool>> base_material_pair = convert_shader_material_to_base_material(shader_material, mesh_instance);
+						if (!base_material_pair.second.first) {
+							base_material = surface_material;
+							if (!base_material.is_valid()) {
+								Ref<ShaderMaterial> surface_shader_material = surface_material;
+								if (surface_shader_material.is_valid() && surface_shader_material != shader_material) {
+									auto new_material_pair = convert_shader_material_to_base_material(surface_shader_material);
+									if (new_material_pair.second.first) {
+										shader_material = surface_shader_material;
+										base_material_pair = new_material_pair;
+									}
+								}
+							}
+						}
+						if (!base_material.is_valid()) {
+							base_material = base_material_pair.first;
+						}
+						// We don't want to cache it if it has instance uniforms that were actually used,
+						// since they will need to be created per-instance
+						if (base_material.is_valid() && !base_material_pair.second.second) {
+							shader_material_to_base_material_map[shader_material] = base_material;
+						}
+					}
+					if (base_material.is_valid()) {
+						mesh_instance->set_surface_override_material(surface_i, base_material);
+					}
+				}
 			}
 		}
+	};
+	other_error_messages.append_array(_get_logged_error_messages());
+	for (auto &E : mesh_instances) {
+		MeshInstance3D *mesh_instance = Object::cast_to<MeshInstance3D>(E);
+		ERR_CONTINUE(!mesh_instance);
+		process_mesh_instance(mesh_instance);
+	}
+	other_error_messages.append_array(_get_logged_error_messages());
+	// Needed for warning about scene with physics nodes being exported as multi-root
+	{
+		TypedArray<Node> physics_nodes = root->find_children("*", "CollisionObject3D");
+		TypedArray<Node> physics_shapes = root->find_children("*", "CollisionShape3D");
+		has_physics_nodes = physics_nodes.size() > 0 || physics_shapes.size() > 0;
 	}
-	TypedArray<Node> physics_nodes = root->find_children("*", "CollisionObject3D");
-	TypedArray<Node> physics_shapes = root->find_children("*", "CollisionShape3D");
-	has_physics_nodes = physics_nodes.size() > 0 || physics_shapes.size() > 0;
 
-	if (has_script) {
-		TypedArray<Node> nodes = { root };
-		nodes.append_array(root->get_children());
-		for (int i = 0; i < nodes.size(); i++) {
-			auto &E = nodes[i];
-			Node *node = static_cast<Node *>(E.operator Object *());
-			ScriptInstance *si = node->get_script_instance();
-			List<PropertyInfo> properties;
-			if (si) {
-				if (updating_import_info) {
-					node_options[get_node_path(node).operator String()] = get_node_options(node);
+	TypedArray<Node> nodes = { root };
+	nodes.append_array(root->get_children());
+	int i = 0;
+	auto generate_mesh_instance = [&](Node *node, const Ref<Mesh> &mesh, Node *original_node = nullptr) {
+		auto mesh_instance = memnew(MeshInstance3D());
+		mesh_instance->set_mesh(mesh);
+		String name = mesh->get_name();
+		String path = mesh->get_path();
+
+		if (name.is_empty()) {
+			name = demangle_name(path.get_file().get_basename());
+			if (name.is_empty() || path.contains("::")) {
+				if (original_node) {
+					name = original_node->get_name();
+				} else {
+					name = ("Mesh_" + String::num_int64(++i));
+				}
+			}
+			mesh->set_name(name);
+		}
+		if (!path.is_empty()) {
+			mesh_path_to_instance_map[path] = mesh_instance;
+		}
+		mesh_instance->set_name(name);
+		generated_mesh_instance_parents.insert(node);
+		meshes_in_mesh_instances.insert(mesh);
+		return mesh_instance;
+	};
+	std::function<void(Node *)> process_node = [&](Node *node) {
+		ScriptInstance *si = node->get_script_instance();
+		List<PropertyInfo> properties;
+		HashSet<MeshInstance3D *> mis_generated_from_scripts;
+		// generate mesh instances from script properties
+		if (si) {
+			si->get_property_list(&properties);
+			HashSet<Variant> other_values;
+			HashSet<Ref<Skin>> skins;
+			HashSet<NodePath> skeleton_paths;
+			for (auto &prop : properties) {
+				Variant value;
+				if (si->get(prop.name, value)) {
+					// check if it's a mesh instance
+					Ref<Mesh> mesh = value;
+					if (mesh.is_valid() && !meshes_in_mesh_instances.has(mesh)) {
+						// create a new mesh instance
+						auto mesh_instance = generate_mesh_instance(node, mesh);
+						mis_generated_from_scripts.insert(mesh_instance);
+						node->add_child(mesh_instance);
+					}
 				}
-				si->get_property_list(&properties);
-				HashSet<Variant> other_values;
-				Vector<MeshInstance3D *> mesh_instances;
-				HashSet<Ref<Skin>> skins;
-				HashSet<NodePath> skeleton_paths;
+			}
+			for (auto &mesh_instance : mis_generated_from_scripts) {
+				bool set_skin = false;
+				bool set_skeleton = false;
 				for (auto &prop : properties) {
 					Variant value;
-					if (si->get(prop.name, value)) {
-						// check if it's a mesh instance
-						Ref<Mesh> mesh = value;
-						if (mesh.is_valid() && !meshes_in_mesh_instances.has(mesh)) {
-							// create a new mesh instance
-							auto mesh_instance = memnew(MeshInstance3D());
-							mesh_instance->set_mesh(mesh);
-							String name = mesh->get_name();
-							String path = mesh->get_path();
-
-							if (name.is_empty()) {
-								name = demangle_name(path.get_file().get_basename());
-								if (name.is_empty() || path.contains("::")) {
-									name = ("Mesh_" + String::num_int64(i));
+					if (si->get(prop.name, value) && !skins.has(value) && !skeleton_paths.has(value)) {
+						Ref<Skin> skin = value;
+						if (skin.is_valid() && !set_skin) {
+							mesh_instance->set_skin(skin);
+							set_skin = true;
+							skins.insert(skin);
+						} else if (!set_skeleton) {
+							NodePath skeleton_path = value;
+							if (!skeleton_path.is_empty()) {
+								// we need to check to see if this is actually a skeleton
+								Node *skeleton = node->get_node(skeleton_path);
+								Skeleton3D *skeleton3d = skeleton ? Object::cast_to<Skeleton3D>(skeleton) : nullptr;
+								if (skeleton3d) {
+									NodePath actual_path = skeleton_path;
+									if (!skeleton_path.is_absolute()) {
+										actual_path = mesh_instance->get_path_to(skeleton3d);
+									}
+									mesh_instance->set_skeleton_path(actual_path);
+									set_skeleton = true;
+									skeleton_paths.insert(skeleton_path);
 								}
-								mesh->set_name(name);
-							}
-							if (!path.is_empty()) {
-								mesh_path_to_instance_map[path] = mesh_instance;
 							}
-							mesh_instance->set_name(name);
-							node->add_child(mesh_instance);
-							mesh_instances.push_back(mesh_instance);
-							// meshes_in_mesh_instances.insert(mesh);
 						}
 					}
+					if (set_skin && set_skeleton) {
+						break;
+					}
 				}
-				for (auto &mesh_instance : mesh_instances) {
-					bool set_skin = false;
-					bool set_skeleton = false;
-					for (auto &prop : properties) {
-						Variant value;
-						if (si->get(prop.name, value) && !skins.has(value) && !skeleton_paths.has(value)) {
-							Ref<Skin> skin = value;
-							if (skin.is_valid() && !set_skin) {
-								has_skinned_meshes = true;
-								skinned_mesh_instances.insert(mesh_instance);
-								mesh_instance->set_skin(skin);
-								set_skin = true;
-								skins.insert(skin);
-							} else if (!set_skeleton) {
-								NodePath skeleton_path = value;
-								if (!skeleton_path.is_empty()) {
-									// we need to check to see if this is actually a skeleton
-									Node *skeleton = node->get_node(skeleton_path);
-									Skeleton3D *skeleton3d = skeleton ? Object::cast_to<Skeleton3D>(skeleton) : nullptr;
-									if (skeleton3d) {
-										NodePath actual_path = skeleton_path;
-										if (!skeleton_path.is_absolute()) {
-											actual_path = node->get_path_to(skeleton3d);
-										}
-										mesh_instance->set_skeleton_path(actual_path);
-										set_skeleton = true;
-										skeleton_paths.insert(skeleton_path);
-									}
-								}
+				process_mesh_instance(mesh_instance);
+				if (updating_import_info) {
+					node_options[get_node_path(mesh_instance).operator String()] = { { "import/skip_import", true } };
+				}
+			}
+		}
+		Node *original_node = nullptr;
+		auto replace_with_mi = [&](Ref<ArrayMesh> mesh) {
+			auto mesh_instance = generate_mesh_instance(node, mesh, node);
+			mesh_instance->set_name(node->get_name());
+			process_mesh_instance(mesh_instance);
+			replaced_node_names.push_back(get_node_path(node).operator String() + ":" + node->get_class());
+			auto node3d = Object::cast_to<Node3D>(node);
+			auto transform = node3d ? node3d->get_transform() : Transform3D();
+			auto script = node->get_script();
+			node->replace_by(mesh_instance);
+			mesh_instance->set_transform(transform);
+			mesh_instance->set_script(script);
+
+			original_node = node;
+			node = mesh_instance;
+			if (original_node == root) {
+				root = node;
+				root_type = node->get_class();
+				root_name = node->get_name();
+			}
+			auto parent = original_node->get_parent();
+			Vector<CollisionShape3D *> shapes;
+			if (!parent || !Object::cast_to<RigidBody3D>(parent)) {
+				for (auto &E : mesh_instance->get_children()) {
+					auto shape = Object::cast_to<CollisionShape3D>(E.operator Object *());
+					if (shape) {
+						shapes.push_back(shape);
+					}
+				}
+			}
+			if (!shapes.is_empty()) {
+				StaticBody3D *static_body = memnew(StaticBody3D());
+				static_body->set_name(mesh_instance->get_name().operator String() + "_StaticBody3D");
+				mesh_instance->add_child(static_body);
+				for (auto &shape : shapes) {
+					shape->set_owner(nullptr);
+					shape->reparent(static_body, false);
+				}
+			}
+		};
+		// replace NavMesh/Occluder/Area3D-only nodes with mesh instances
+		// e.g. the original mesh will have been replaced by a NavMesh/Occluder/Area3D node by the importer, so we have to put it back.
+		if (!is_auto_generated_node(node) && node != root) {
+			if (auto navigation_region = Object::cast_to<NavigationRegion3D>(node); navigation_region) {
+				if (Ref<NavigationMesh> navmesh = navigation_region->get_navigation_mesh(); navmesh.is_valid()) {
+					auto debug_mesh = get_nav_array_debug_mesh(navmesh);
+					replace_with_mi(debug_mesh);
+				}
+			} else if (auto occluder_instance = Object::cast_to<OccluderInstance3D>(node); occluder_instance) {
+				if (Ref<Occluder3D> occluder = occluder_instance->get_occluder(); occluder.is_valid()) {
+					replace_with_mi(occluder->get_debug_mesh());
+				}
+			} else if (auto area_3d = Object::cast_to<Area3D>(node); area_3d) {
+				Vector<Ref<ArrayMesh>> meshes;
+				Ref<ArrayMesh> mesh;
+				for (auto &E : area_3d->get_children()) {
+					if (auto collision_shape = Object::cast_to<CollisionShape3D>(E.operator Object *()); collision_shape && collision_shape->get_shape().is_valid()) {
+						meshes.push_back(collision_shape->get_shape()->get_debug_mesh());
+					}
+				}
+				if (meshes.size() > 1) {
+					SurfaceTool surface_tool;
+					for (size_t i = 0; i < meshes.size(); i++) {
+						for (size_t j = 0; j < meshes[i]->get_surface_count(); j++) {
+							if (i == 0 && j == 0) {
+								surface_tool.create_from(meshes[i], j);
+							} else {
+								surface_tool.append_from(meshes[i], j, Transform3D());
 							}
 						}
-						if (set_skin && set_skeleton) {
-							break;
-						}
 					}
+					mesh = surface_tool.commit();
+				} else if (meshes.size() == 1) {
+					mesh = meshes[0];
+				}
+				if (mesh.is_valid()) {
+					replace_with_mi(mesh);
 				}
 			}
 		}
+		if (updating_import_info && node != root) {
+			node_options[get_node_path(node).operator String()] = get_node_options(node, original_node);
+		}
+
+		if (original_node) {
+			if (SceneTree::get_singleton()) {
+				original_node->queue_free();
+			} else {
+				memdelete(original_node);
+			}
+		}
+
+		for (auto &E : node->get_children()) {
+			auto child = Object::cast_to<Node>(E.operator Object *());
+			if (!mis_generated_from_scripts.has(Object::cast_to<MeshInstance3D>(child))) {
+				process_node(child);
+			}
+		}
+	};
+	process_node(root);
+	if (replaced_node_names.size() > 0) {
+		auto thingy = String(", ").join(replaced_node_names);
+		print_line(vformat("%s: replaced nodes with mesh instances: %s", scene_name, thingy));
+#ifdef DEBUG_ENABLED
+		if (true) {
+			auto new_dest = "res://.tscn_manip/" + report->get_import_info()->get_export_dest().trim_prefix("res://.assets/").trim_prefix("res://").get_basename() + ".tscn";
+			auto new_dest_path = output_dir.path_join(new_dest.replace_first("res://", ""));
+			Ref<PackedScene> scene = memnew(PackedScene);
+			scene->pack(root);
+			ResourceCompatLoader::save_custom(scene, new_dest_path, GODOT_VERSION_MAJOR, GODOT_VERSION_MINOR);
+		}
+#endif
 	}
+
 	Vector<int64_t> fps_values;
 	for (int32_t node_i = 0; node_i < animation_player_nodes.size(); node_i++) {
 		bool any_compressed = false;
@@ -1586,6 +1890,7 @@ void GLBExporterInstance::_set_stuff_from_instanced_scene(Node *root) {
 			baked_fps = MIN(max_fps, 120);
 		}
 	}
+	return root;
 }
 
 bool GLBExporterInstance::_is_logger_silencing_errors() const {
@@ -1701,7 +2006,7 @@ struct UniformInfo {
 	String hint;
 };
 
-Pair<Ref<BaseMaterial3D>, Pair<bool, bool>> convert_shader_material_to_base_material(Ref<ShaderMaterial> p_shader_material, Node *p_parent = nullptr) {
+Pair<Ref<BaseMaterial3D>, Pair<bool, bool>> GLBExporterInstance::convert_shader_material_to_base_material(Ref<ShaderMaterial> p_shader_material, Node *p_parent) {
 	// we need to manually create a BaseMaterial3D from the shader material
 	// We do this by getting the shader uniforms and then mapping them to the BaseMaterial3D properties
 	// We also need to handle the texture parameters and features
@@ -2057,6 +2362,7 @@ Pair<Ref<BaseMaterial3D>, Pair<bool, bool>> convert_shader_material_to_base_mate
 	base_material->set_name(p_shader_material->get_name());
 	// set the path to the shader material's path so that we can add it to the external deps found if necessary
 	base_material->set_path_cache(p_shader_material->get_path());
+	base_material->merge_meta_from(p_shader_material.ptr());
 
 	bool set_instance_uniforms = false;
 	for (auto &E : set_params) {
@@ -2135,7 +2441,7 @@ Error GLBExporterInstance::_export_instanced_scene(Node *root, const String &p_d
 		flags |= 16; // EditorSceneFormatImporter::IMPORT_USE_NAMED_SKIN_BINDS;
 		bool was_silenced = _is_logger_silencing_errors();
 		_silence_errors(true);
-		other_error_messages = _get_logged_error_messages();
+		other_error_messages.append_array(_get_logged_error_messages());
 		auto errors_before_append = _get_error_count();
 		err = doc->append_from_scene(root, state, flags);
 		_silence_errors(was_silenced);
@@ -2146,86 +2452,6 @@ Error GLBExporterInstance::_export_instanced_scene(Node *root, const String &p_d
 		}
 		GDRE_SCN_EXP_CHECK_CANCEL();
 
-		Vector<String> errors_before_replace_shader_materials = _get_logged_error_messages();
-
-		// remove shader materials from meshes in the state before serializing
-		if (replace_shader_materials) {
-			for (auto &E : state->get_meshes()) {
-				Ref<GLTFMesh> mesh = E;
-				if (mesh.is_valid()) {
-					Ref<ImporterMesh> im = mesh->get_mesh();
-					ERR_CONTINUE_MSG(im.is_null(), "ImporterMesh is null");
-					auto instance_materials = mesh->get_instance_materials();
-
-					String path = get_path_res(im);
-					MeshInstance3D *instance = nullptr;
-					if (!path.is_empty() && mesh_path_to_instance_map.has(path)) {
-						instance = mesh_path_to_instance_map[path];
-					}
-					for (int surface_i = 0; surface_i < im->get_surface_count(); surface_i++) {
-						Ref<ShaderMaterial> shader_material;
-						Ref<BaseMaterial3D> base_material;
-						;
-						if (surface_i < instance_materials.size()) {
-							shader_material = instance_materials[surface_i];
-						} else {
-							shader_material = im->get_surface_material(surface_i);
-						}
-						if (shader_material.is_valid()) {
-							if (shader_material_to_base_material_map.has(shader_material)) {
-								base_material = shader_material_to_base_material_map[shader_material];
-							} else {
-								Pair<Ref<BaseMaterial3D>, Pair<bool, bool>> base_material_pair = convert_shader_material_to_base_material(shader_material, instance);
-								if (!base_material_pair.second.first) {
-									base_material = im->get_surface_material(surface_i);
-									if (!base_material.is_valid()) {
-										Ref<ShaderMaterial> surface_shader_material = im->get_surface_material(surface_i);
-										if (surface_shader_material.is_valid() && surface_shader_material != shader_material) {
-											auto new_material_pair = convert_shader_material_to_base_material(surface_shader_material);
-											if (new_material_pair.second.first) {
-												shader_material = surface_shader_material;
-												base_material_pair = new_material_pair;
-											}
-										}
-									}
-								}
-								if (!base_material.is_valid()) {
-									base_material = base_material_pair.first;
-								}
-								// We don't want to cache it if it has instance uniforms that were actually used,
-								// since they will need to be created per-instance
-								if (base_material.is_valid() && !base_material_pair.second.second) {
-									shader_material_to_base_material_map[shader_material] = base_material;
-								}
-							}
-							if (base_material.is_valid()) {
-								if (surface_i < instance_materials.size()) {
-									instance_materials[surface_i] = base_material;
-								}
-								im->set_surface_material(surface_i, base_material);
-							}
-						}
-					}
-					// This shouldn't happen??
-					if (instance_materials.size() > im->get_surface_count()) {
-						WARN_PRINT("Instance materials size is greater than the mesh's surface count????");
-						for (int i = im->get_surface_count(); i < instance_materials.size(); i++) {
-							Ref<ShaderMaterial> shader_material = instance_materials[i];
-							if (shader_material.is_valid()) {
-								auto new_material_pair = convert_shader_material_to_base_material(shader_material);
-								if (new_material_pair.second.first) {
-									instance_materials[i] = new_material_pair.first;
-								}
-							}
-						}
-					}
-					mesh->set_instance_materials(instance_materials);
-				}
-			}
-			// clear material conversion error messages
-			other_error_messages.append_array(_get_logged_error_messages());
-		}
-
 		_silence_errors(true);
 		auto errors_before_serialize = _get_error_count();
 		err = doc->_serialize(state);
@@ -2234,7 +2460,6 @@ Error GLBExporterInstance::_export_instanced_scene(Node *root, const String &p_d
 		GDRE_SCN_EXP_CHECK_CANCEL();
 
 		if (errors_after_serialize > errors_before_serialize || errors_after_append > errors_before_append) {
-			gltf_serialization_error_messages.append_array(errors_before_replace_shader_materials);
 			gltf_serialization_error_messages.append_array(_get_logged_error_messages());
 		}
 		if (err) {
@@ -2255,22 +2480,24 @@ Error GLBExporterInstance::_export_instanced_scene(Node *root, const String &p_d
 		}
 		GDRE_SCN_EXP_CHECK_CANCEL();
 #endif
+		auto check_unique = [&](String &name, HashSet<String> &image_map) {
+			if (name.is_empty()) {
+				return;
+			}
+			if (!image_map.has(name)) {
+				image_map.insert(name);
+			} else {
+				name = String(name) + vformat("_%03d", image_map.size() - 1);
+			}
+		};
+
 		// rename objects in the state so that they will be imported correctly, and gather import params info
 		{
 			auto json = state->get_json();
 			auto materials = state->get_materials();
 			auto images = state->get_images();
 			Array json_images = json.has("images") ? (Array)json["images"] : Array();
-			HashMap<String, Vector<int>> image_map;
-			auto insert_image_map = [&](String &name, int i) {
-				if (!image_map.has(name)) {
-					image_map[name] = Vector<int>();
-					image_map[name].push_back(i);
-				} else {
-					image_map[name].push_back(i);
-					name = String(name) + vformat("_%03d", image_map[name].size() - 1);
-				}
-			};
+			HashSet<String> image_map;
 			static const HashMap<String, Vector<BaseMaterial3D::TextureParam>> generated_tex_suffixes = {
 				{ "emission", { BaseMaterial3D::TEXTURE_EMISSION } },
 				{ "normal", { BaseMaterial3D::TEXTURE_NORMAL } },
@@ -2278,21 +2505,27 @@ Error GLBExporterInstance::_export_instanced_scene(Node *root, const String &p_d
 				{ "orm", { BaseMaterial3D::TEXTURE_AMBIENT_OCCLUSION, BaseMaterial3D::TEXTURE_ROUGHNESS, BaseMaterial3D::TEXTURE_METALLIC } },
 				{ "albedo", { BaseMaterial3D::TEXTURE_ALBEDO } }
 			};
+			HashMap<String, String> image_name_to_path;
+			for (auto E : image_deps_needed) {
+				image_name_to_path[E.get_file().get_basename()] = E;
+			}
+
 			for (int i = 0; i < json_images.size(); i++) {
 				Dictionary image_dict = json_images[i];
 				Ref<Texture2D> image = images[i];
 				auto path = get_path_res(image);
-				String name = image_dict.get("name", String());
+				String name = image->get_name();
 				if (path.is_empty() && !name.is_empty()) {
-					for (auto E : image_deps_needed) {
-						if (E.get_file().get_basename() == name) {
-							path = E;
-							break;
+					if (image_name_to_path.has(name)) {
+						path = image_name_to_path[name];
+					} else if (name[name.length() - 1] <= '9' && name[name.length() - 1] >= '0') {
+						name = name.substr(0, name.length() - 1);
+						if (image_name_to_path.has(name) && !image_map.has(name)) {
+							path = image_name_to_path[name];
 						}
 					}
 				}
-				if (path.is_empty() && !get_name_res(image_dict, image, i).is_empty()) {
-					name = get_name_res(image_dict, image, i);
+				if (path.is_empty() && !name.is_empty()) {
 					auto parts = name.rsplit("_", false, 1);
 					String material_name = parts.size() > 0 ? parts[0] : String();
 					String suffix;
@@ -2328,18 +2561,13 @@ Error GLBExporterInstance::_export_instanced_scene(Node *root, const String &p_d
 				bool is_internal = path.is_empty() || path.get_file().contains("::");
 				if (is_internal) {
 					name = get_name_res(image_dict, image, i);
-					insert_image_map(name, i);
 				} else {
 					name = path.get_file().get_basename();
 					external_deps_updated.insert(path);
-					insert_image_map(name, i);
-					unsigned char md5_hash[16];
-					Ref<Image> img = image->get_image();
-					auto img_data = img->get_data();
-					CryptoCore::md5(img_data.ptr(), img_data.size(), md5_hash);
-					String new_md5 = String::hex_encode_buffer(md5_hash, 16);
-					image_path_to_data_hash[path] = new_md5;
+					image_path_to_data_hash[path] = FileAccess::get_md5(path);
 				}
+				check_unique(name, image_map);
+
 				if (!name.is_empty()) {
 					image_dict["name"] = demangle_name(name);
 				}
@@ -2356,7 +2584,7 @@ Error GLBExporterInstance::_export_instanced_scene(Node *root, const String &p_d
 
 			if (json.has("meshes")) {
 				auto default_light_map_size = Vector2i(0, 0);
-				Vector<String> mesh_names;
+				HashSet<String> mesh_names;
 				Vector<Pair<Ref<ArrayMesh>, MeshInstance3D *>> mesh_to_instance;
 				Vector<bool> mesh_is_shadow;
 				auto gltf_meshes = state->get_meshes();
@@ -2382,21 +2610,21 @@ Error GLBExporterInstance::_export_instanced_scene(Node *root, const String &p_d
 						continue;
 					}
 					String path = get_path_res(imesh);
-					String name;
-					bool is_internal = path.is_empty() || path.get_file().contains("::");
-					if (is_internal) {
-						name = get_name_res(mesh_dict, imesh, i);
-					} else {
-						name = path.get_file().get_basename();
+					String name = original_name;
+					if (name.is_empty()) {
+						bool is_internal = path.is_empty() || path.get_file().contains("::");
+						if (is_internal) {
+							name = get_name_res(mesh_dict, imesh, i);
+						} else {
+							name = path.get_file().get_basename();
+						}
 					}
+					check_unique(name, mesh_names);
 					if (!name.is_empty()) {
 						mesh_dict["name"] = demangle_name(name);
 						if (original_name.is_empty()) {
 							gltf_mesh->set_original_name(name);
 						}
-					} else if (!original_name.is_empty()) {
-						mesh_dict["name"] = original_name;
-						name = original_name;
 					}
 					if (!updating_import_info || shadow_meshes.has(imesh) || (path.is_empty() && name.is_empty())) {
 						// mesh that won't be imported, skip
@@ -2442,18 +2670,22 @@ Error GLBExporterInstance::_export_instanced_scene(Node *root, const String &p_d
 			}
 
 			if (json.has("materials")) {
+				HashSet<String> material_names;
 				Array json_materials = json["materials"];
 				for (int i = 0; i < materials.size(); i++) {
 					Dictionary material_dict = json_materials[i];
 					Ref<Material> material = materials[i];
 					auto path = get_path_res(material);
-					String name;
+					String name = material->get_name();
 					bool is_internal = path.is_empty() || path.get_file().contains("::");
-					if (is_internal) {
-						name = get_name_res(material_dict, material, i);
-					} else {
-						name = path.get_file().get_basename();
+					if (name.is_empty()) {
+						if (is_internal) {
+							name = get_name_res(material_dict, material, i);
+						} else {
+							name = path.get_file().get_basename();
+						}
 					}
+					check_unique(name, material_names);
 					// the name in the options import is the name in the gltf file, unlike for meshes
 					if (!name.is_empty()) {
 						material_dict["name"] = name;
@@ -2513,6 +2745,76 @@ Error GLBExporterInstance::_check_model_can_load(const String &p_dest_path) {
 	return OK;
 }
 
+Dictionary GLBExporterInstance::_get_default_subresource_options() {
+	Dictionary dict = {
+		{ "save_to_file/enabled", false },
+		{ "save_to_file/path", "" },
+		{ "save_to_file/fallback_path", "" },
+		{ "generate/shadow_meshes", 0 },
+		{ "generate/lightmap_uv", 0 },
+		{ "generate/lods", 0 },
+		{ "lods/normal_merge_angle", 20.0f },
+		{ "use_external/enabled", false },
+		{ "use_external/path", "" },
+		{ "use_external/fallback_path", "" },
+		{ "settings/loop_mode", 0 },
+		{ "save_to_file/keep_custom_tracks", false },
+		{ "slices/amount", 0 },
+	};
+	if (!after_4_3) {
+		dict["lods/normal_split_angle"] = 25.0f;
+	}
+	if (!after_4_4) {
+		dict["lods/normal_merge_angle"] = 60.0f;
+	}
+	for (int i = 0; i < 256; i++) {
+		dict["slice_" + itos(i + 1) + "/name"] = "";
+		dict["slice_" + itos(i + 1) + "/start_frame"] = 0;
+		dict["slice_" + itos(i + 1) + "/end_frame"] = 0;
+		dict["slice_" + itos(i + 1) + "/loop_mode"] = 0;
+		dict["slice_" + itos(i + 1) + "/save_to_file/enabled"] = false;
+		dict["slice_" + itos(i + 1) + "/save_to_file/path"] = "";
+		dict["slice_" + itos(i + 1) + "/save_to_file/fallback_path"] = "";
+		dict["slice_" + itos(i + 1) + "/save_to_file/keep_custom_tracks"] = false;
+	}
+	return dict;
+	// switch (p_category) {
+	// 	case SceneExporterEnums::INTERNAL_IMPORT_CATEGORY_MESH: {
+	// 		r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "save_to_file/enabled", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED), false));
+	// 		r_options->push_back(ImportOption(PropertyInfo(Variant::STRING, "save_to_file/path", PROPERTY_HINT_SAVE_FILE, "*.res,*.tres"), ""));
+	// 		r_options->push_back(ImportOption(PropertyInfo(Variant::STRING, "save_to_file/fallback_path", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR), ""));
+	// 		r_options->push_back(ImportOption(PropertyInfo(Variant::INT, "generate/shadow_meshes", PROPERTY_HINT_ENUM, "Default,Enable,Disable"), 0));
+	// 		r_options->push_back(ImportOption(PropertyInfo(Variant::INT, "generate/lightmap_uv", PROPERTY_HINT_ENUM, "Default,Enable,Disable"), 0));
+	// 		r_options->push_back(ImportOption(PropertyInfo(Variant::INT, "generate/lods", PROPERTY_HINT_ENUM, "Default,Enable,Disable"), 0));
+	// 		r_options->push_back(ImportOption(PropertyInfo(Variant::FLOAT, "lods/normal_merge_angle", PROPERTY_HINT_RANGE, "0,180,1,degrees"), 20.0f));
+	// 	} break;
+	// 	case SceneExporterEnums::INTERNAL_IMPORT_CATEGORY_MATERIAL: {
+	// 		r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "use_external/enabled", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED), false));
+	// 		r_options->push_back(ImportOption(PropertyInfo(Variant::STRING, "use_external/path", PROPERTY_HINT_FILE, "*.material,*.res,*.tres"), ""));
+	// 		r_options->push_back(ImportOption(PropertyInfo(Variant::STRING, "use_external/fallback_path", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR), ""));
+	// 	} break;
+	// 	case SceneExporterEnums::INTERNAL_IMPORT_CATEGORY_ANIMATION: {
+	// 		r_options->push_back(ImportOption(PropertyInfo(Variant::INT, "settings/loop_mode", PROPERTY_HINT_ENUM, "None,Linear,Pingpong"), 0));
+	// 		r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "save_to_file/enabled", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED), false));
+	// 		r_options->push_back(ImportOption(PropertyInfo(Variant::STRING, "save_to_file/path", PROPERTY_HINT_SAVE_FILE, "*.res,*.anim,*.tres"), ""));
+	// 		r_options->push_back(ImportOption(PropertyInfo(Variant::STRING, "save_to_file/fallback_path", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR), ""));
+	// 		r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "save_to_file/keep_custom_tracks"), ""));
+	// 		r_options->push_back(ImportOption(PropertyInfo(Variant::INT, "slices/amount", PROPERTY_HINT_RANGE, "0,256,1", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED), 0));
+
+	// 		for (int i = 0; i < 256; i++) {
+	// 			r_options->push_back(ImportOption(PropertyInfo(Variant::STRING, "slice_" + itos(i + 1) + "/name"), ""));
+	// 			r_options->push_back(ImportOption(PropertyInfo(Variant::INT, "slice_" + itos(i + 1) + "/start_frame"), 0));
+	// 			r_options->push_back(ImportOption(PropertyInfo(Variant::INT, "slice_" + itos(i + 1) + "/end_frame"), 0));
+	// 			r_options->push_back(ImportOption(PropertyInfo(Variant::INT, "slice_" + itos(i + 1) + "/loop_mode", PROPERTY_HINT_ENUM, "None,Linear,Pingpong"), 0));
+	// 			r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "slice_" + itos(i + 1) + "/save_to_file/enabled", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_UPDATE_ALL_IF_MODIFIED), false));
+	// 			r_options->push_back(ImportOption(PropertyInfo(Variant::STRING, "slice_" + itos(i + 1) + "/save_to_file/path", PROPERTY_HINT_SAVE_FILE, "*.res,*.anim,*.tres"), ""));
+	// 			r_options->push_back(ImportOption(PropertyInfo(Variant::STRING, "slice_" + itos(i + 1) + "/save_to_file/fallback_path", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR), ""));
+	// 			r_options->push_back(ImportOption(PropertyInfo(Variant::BOOL, "slice_" + itos(i + 1) + "/save_to_file/keep_custom_tracks"), false));
+	// 		}
+	// 	} break;
+	// }
+}
+
 void GLBExporterInstance::_update_import_params(const String &p_dest_path) {
 	ObjExporter::MeshInfo global_mesh_info = _get_mesh_options_for_import_params();
 
@@ -2573,19 +2875,36 @@ void GLBExporterInstance::_update_import_params(const String &p_dest_path) {
 
 	iinfo->set_param("gltf/embedded_image_handling", image_handling_val);
 
-	if (animation_options.size() > 0) {
-		if (!_subresources_dict.has("animations")) {
-			_subresources_dict["animations"] = Dictionary();
+	Dictionary default_subresource_options = _get_default_subresource_options();
+	auto check_subresource_dict = [&](Dictionary &p_dict) {
+		bool differs = false;
+		for (auto &E : p_dict) {
+			if (!default_subresource_options.has(E.key)) {
+				ERR_CONTINUE(!default_subresource_options.has(E.key));
+			}
+			if (E.value != default_subresource_options.get(E.key, Variant())) {
+				differs = true;
+				break;
+			}
 		}
-		Dictionary animations_dict = _subresources_dict["animations"];
+		// the importer puts all the default options in if one of them differs; if none do, we don't have to include it
+		return differs;
+	};
+	if (animation_options.size() > 0) {
+		Dictionary animations_dict = _subresources_dict.get("animations", Dictionary());
 		for (auto &E : animation_options) {
-			animations_dict[E.key] = E.value;
+			if (check_subresource_dict(E.value)) {
+				animations_dict[E.key] = E.value;
+			}
 			String path = get_path_options(E.value);
 			if (!(path.is_empty() || path.get_file().contains("::"))) {
 				external_deps_updated.insert(path);
 				animation_deps_updated.insert(path);
 			}
 		}
+		if (!animations_dict.is_empty()) {
+			_subresources_dict["animations"] = animations_dict;
+		}
 	}
 	auto get_default_mesh_opt = [](bool global_opt, bool local_opt) {
 		if (global_opt == local_opt) {
@@ -2597,11 +2916,7 @@ void GLBExporterInstance::_update_import_params(const String &p_dest_path) {
 		return 2;
 	};
 	if (id_to_mesh_info.size() > 0) {
-		if (!_subresources_dict.has("meshes")) {
-			_subresources_dict["meshes"] = Dictionary();
-		}
-
-		Dictionary mesh_Dict = _subresources_dict["meshes"];
+		Dictionary mesh_Dict = _subresources_dict.get("meshes", Dictionary());
 		for (auto &E : id_to_mesh_info) {
 			auto name = E.name;
 			auto path = E.path;
@@ -2610,8 +2925,7 @@ void GLBExporterInstance::_update_import_params(const String &p_dest_path) {
 			}
 			// "save_to_file/enabled": true,
 			// "save_to_file/path": "res://models/Enemies/cultist-shoot-anim.res",
-			mesh_Dict[name] = Dictionary();
-			Dictionary subres = mesh_Dict[name];
+			Dictionary subres;
 			if (path.is_empty() || path.get_file().contains("::")) {
 				subres["save_to_file/enabled"] = false;
 				set_path_options(subres, "");
@@ -2625,29 +2939,30 @@ void GLBExporterInstance::_update_import_params(const String &p_dest_path) {
 			subres["generate/lods"] = get_default_mesh_opt(global_mesh_info.has_lods, E.has_lods);
 			// TODO: get these somehow??
 			if (!after_4_3) {
-				subres["lods/normal_split_angle"] = 25.0f;
+				subres["lods/normal_split_angle"] = default_subresource_options.get("lods/normal_split_angle", 25.0f);
 			}
-			subres["lods/normal_merge_angle"] = 60.0f;
+			subres["lods/normal_merge_angle"] = default_subresource_options.get("lods/normal_merge_angle", 60.0f);
 			// Doesn't look like this ever made it in?
 			// if (!after_4_3) {
 			// 	subres["lods/raycast_normals"] = false;
 			// }
+			if (check_subresource_dict(subres)) {
+				mesh_Dict[name] = subres;
+			}
+		}
+		if (!mesh_Dict.is_empty()) {
+			_subresources_dict["meshes"] = mesh_Dict;
 		}
 	}
 	if (id_to_material_path.size() > 0) {
-		if (!_subresources_dict.has("materials")) {
-			_subresources_dict["materials"] = Dictionary();
-		}
-
-		Dictionary mat_Dict = _subresources_dict["materials"];
+		Dictionary mat_Dict = _subresources_dict.get("materials", Dictionary());
 		for (auto &E : id_to_material_path) {
 			auto name = E.first;
 			auto path = E.second;
 			if (name.is_empty() || mat_Dict.has(name)) {
 				continue;
 			}
-			mat_Dict[name] = Dictionary();
-			Dictionary subres = mat_Dict[name];
+			Dictionary subres;
 			if (path.is_empty() || path.get_file().contains("::")) {
 				subres["use_external/enabled"] = false;
 				set_path_options(subres, "", "use_external");
@@ -2656,6 +2971,12 @@ void GLBExporterInstance::_update_import_params(const String &p_dest_path) {
 				set_path_options(subres, path, "use_external");
 				external_deps_updated.insert(path);
 			}
+			if (check_subresource_dict(subres)) {
+				mat_Dict[name] = subres;
+			}
+		}
+		if (!mat_Dict.is_empty()) {
+			_subresources_dict["materials"] = mat_Dict;
 		}
 	}
 	if (node_options.size() > 0) {
@@ -2713,20 +3034,21 @@ Error SceneExporter::export_file_to_non_glb(const String &p_src_path, const Stri
 }
 
 Node *GLBExporterInstance::_instantiate_scene(Ref<PackedScene> scene) {
-	auto errors_before = _get_error_count();
+	other_error_messages.append_array(_get_logged_error_messages());
 	// Instantiation of older scenes will spam warnings about deprecated features (this doesn't affect the error count or retrieving the logged error messages)
+#ifndef DEBUG_ENABLED
 	if (ver_major <= 3) {
 		_silence_errors(true);
 	}
+#endif
 	Node *root = scene->instantiate();
+#ifndef DEBUG_ENABLED
 	if (ver_major <= 3) {
 		_silence_errors(false);
 	}
-	auto errors_after = _get_error_count();
+#endif
 	// this isn't an explcit error by itself, but it's context in case we experience further errors during the export
-	if (errors_after > errors_before) {
-		scene_instantiation_error_messages.append_array(_get_logged_error_messages());
-	}
+	scene_instantiation_error_messages.append_array(_get_logged_error_messages());
 	if (root == nullptr) {
 		err = ERR_CANT_ACQUIRE_RESOURCE;
 		ERR_PRINT(add_errors_to_report(ERR_CANT_ACQUIRE_RESOURCE, "Failed to instantiate scene " + source_path));
@@ -2747,18 +3069,23 @@ Error GLBExporterInstance::_load_scene_and_deps(Ref<PackedScene> &r_scene) {
 Error GLBExporterInstance::_load_scene(Ref<PackedScene> &r_scene) {
 	auto mode_type = ResourceCompatLoader::get_default_load_type();
 	// loading older scenes will spam warnings about deprecated features
+#ifndef DEBUG_ENABLED
 	if (ver_major <= 3) {
 		_silence_errors(true);
 	}
+#endif
 	// For some reason, scenes with meshes fail to load without the load done by ResourceLoader::load, possibly due to notification shenanigans.
 	if (ResourceCompatLoader::is_globally_available() && using_threaded_load()) {
 		r_scene = ResourceLoader::load(source_path, "PackedScene", ResourceFormatLoader::CACHE_MODE_REUSE, &err);
 	} else {
 		r_scene = ResourceCompatLoader::custom_load(source_path, "PackedScene", mode_type, &err, using_threaded_load(), ResourceFormatLoader::CACHE_MODE_REUSE);
 	}
+#ifndef DEBUG_ENABLED
 	if (ver_major <= 3) {
 		_silence_errors(false);
 	}
+#endif
+	scene_loading_error_messages.append_array(_get_logged_error_messages());
 	if (err || !r_scene.is_valid()) {
 		r_scene = nullptr;
 		_unload_deps();
@@ -2850,8 +3177,10 @@ Error GLBExporterInstance::_get_return_error() {
 
 	if (had_gltf_serialization_errors) {
 		String _ = add_errors_to_report(ERR_BUG, "");
-	} else if (!set_all_externals && err == OK) {
+	} else if ((!set_all_externals || missing_dependencies.size() > 0) && err == OK) {
 		String _ = add_errors_to_report(ERR_PRINTER_ON_FIRE, "Failed to set all external dependencies in GLTF export and/or import info. This scene may not be imported correctly upon re-import.");
+	} else if (err == OK) {
+		String _ = add_errors_to_report(OK, "");
 	} else {
 		GDRE_SCN_EXP_FAIL_COND_V_MSG(err, err, "");
 	}
@@ -3114,6 +3443,7 @@ struct BatchExportToken : public TaskRunnerStruct {
 
 	// scene loading and scene instancing has to be done on the main thread to avoid deadlocks and crashes
 	bool batch_preload() {
+		GDRELogger::clear_error_queues();
 		if (check_unsupported()) {
 			err = ERR_UNAVAILABLE;
 			_set_unsupported(report, ver_major, is_obj_output());
@@ -3157,7 +3487,7 @@ struct BatchExportToken : public TaskRunnerStruct {
 					preload_done = true;
 					return false;
 				}
-				instance._set_stuff_from_instanced_scene(root);
+				root = instance._set_stuff_from_instanced_scene(root);
 			}
 		}
 
@@ -3219,6 +3549,13 @@ struct BatchExportToken : public TaskRunnerStruct {
 			if (err == OK) {
 				report->set_saved_path(p_dest_path);
 			}
+#ifdef DEBUG_ENABLED // export a text copy so we can see what went wrong
+			if (true) {
+				auto new_dest = "res://.tscn_copy/" + report->get_import_info()->get_export_dest().trim_prefix("res://.assets/").trim_prefix("res://").get_basename() + ".tscn";
+				auto new_dest_path = output_dir.path_join(new_dest.replace_first("res://", ""));
+				ResourceCompatLoader::to_text(p_src_path, new_dest_path);
+			}
+#endif
 		}
 		_scene = nullptr;
 		// print_line("Finished exporting scene " + p_src_path);
@@ -3250,13 +3587,6 @@ struct BatchExportToken : public TaskRunnerStruct {
 				report->set_saved_path(p_dest_path);
 			}
 		} else {
-#ifdef DEBUG_ENABLED // export a text copy so we can see what went wrong
-			if (err != OK) {
-				auto new_dest = "res://.tscn_copy/" + report->get_import_info()->get_export_dest().trim_prefix("res://").get_basename() + ".tscn";
-				auto new_dest_path = output_dir.path_join(new_dest.replace_first("res://", ""));
-				ResourceCompatLoader::to_text(p_src_path, new_dest_path);
-			}
-#endif
 			instance._unload_deps();
 			if (instance.had_script() && err == OK) {
 				report->set_message("Script has scripts, not saving to original path.");
@@ -3392,6 +3722,10 @@ String SceneExporter::get_default_export_extension(const String &res_path) const
 	return "glb";
 }
 
+Vector<String> SceneExporter::get_export_extensions(const String &res_path) const {
+	return { "glb", "gltf", "obj", "escn", "tscn" };
+}
+
 void SceneExporter::_bind_methods() {
 	ClassDB::bind_static_method(get_class_static(), D_METHOD("export_file_with_options", "out_path", "res_path", "options"), &SceneExporter::export_file_with_options);
 	ClassDB::bind_static_method(get_class_static(), D_METHOD("get_minimum_godot_ver_supported"), &SceneExporter::get_minimum_godot_ver_supported);
@@ -3402,7 +3736,15 @@ uint64_t GLBExporterInstance::_get_error_count() {
 }
 
 Vector<String> GLBExporterInstance::_get_logged_error_messages() {
-	return supports_multithread() ? GDRELogger::get_thread_errors() : GDRELogger::get_errors();
+	auto errors = supports_multithread() ? GDRELogger::get_thread_errors() : GDRELogger::get_errors();
+	Vector<String> ret;
+	for (auto &err : errors) {
+		String lstripped = err.strip_edges(true, false);
+		if (!lstripped.begins_with("GDScript backtrace")) {
+			ret.push_back(err.strip_edges(false, true));
+		}
+	}
+	return ret;
 }
 
 SceneExporter *SceneExporter::singleton = nullptr;
@@ -3431,14 +3773,14 @@ Error GLBExporterInstance::_batch_export_instanced_scene(Node *root, const Strin
 		return err;
 	}
 
+	if (updating_import_info) {
+		_update_import_params(p_dest_path);
+	}
 	// Check if the model can be loaded; minimum validation to ensure the model is valid
 	err = _check_model_can_load(p_dest_path);
 	if (err) {
 		GDRE_SCN_EXP_FAIL_V_MSG(ERR_FILE_CORRUPT, "");
 	}
-	if (updating_import_info) {
-		_update_import_params(p_dest_path);
-	}
 	err = _get_return_error();
 
 	return err;
@@ -3581,6 +3923,7 @@ Vector<Ref<ExportReport>> SceneExporter::batch_export_files(const String &output
 	Vector<uint64_t> abnormal_deltas;
 	Vector<uint64_t> resync_deltas;
 	constexpr size_t MAX_DELTA_COUNT = 1000000;
+	constexpr uint64_t DRAW_DELTA_THRESHOLD = 50000;
 	resync_deltas.reserve(MAX_DELTA_COUNT);
 
 	auto average_out_delta = [&](Vector<uint64_t> &deltas) {
@@ -3630,15 +3973,14 @@ Vector<Ref<ExportReport>> SceneExporter::batch_export_files(const String &output
 
 	auto ensure_progress = [&]() {
 		auto current_time = OS::get_singleton()->get_ticks_usec();
-		if (current_time - last_update_time >= 10000) {
+		if (current_time - last_update_time >= DRAW_DELTA_THRESHOLD) {
 			last_update_time = current_time;
 			return TaskManager::get_singleton()->update_progress_bg(true);
 		}
 		resync_rendering_server();
 		return false;
 	};
-	// if (number_of_threads <= 1 || GDREConfig::get_singleton()->get_setting("force_single_threaded", false)) {
-	if (true) { // TODO: On current master, multi-threaded export is causing crashes, so disabling for now
+	if (number_of_threads <= 1 || GDREConfig::get_singleton()->get_setting("force_single_threaded", false)) {
 		print_line("Forcing single-threaded scene export...");
 		err = TaskManager::get_singleton()->run_group_task_on_current_thread(
 				this,
diff --git a/exporters/scene_exporter.h b/exporters/scene_exporter.h
index 0a514645..b9c2f3db 100644
--- a/exporters/scene_exporter.h
+++ b/exporters/scene_exporter.h
@@ -42,6 +42,13 @@ class SceneExporter : public ResourceExporter {
 #endif
 	static constexpr const char *const EXPORTER_NAME = "PackedScene";
 
+	enum class KeepRootMode {
+		KEEP_ROOT_MODE_AUTO,
+		KEEP_ROOT_MODE_SINGLE_ROOT,
+		KEEP_ROOT_MODE_KEEP_ROOT,
+		KEEP_ROOT_MODE_MULTI_ROOT,
+	};
+
 	static Error export_file_to_non_glb(const String &p_src_path, const String &p_dest_path, Ref<ImportInfo> iinfo);
 	static constexpr bool can_multithread = false;
 
@@ -57,6 +64,7 @@ class SceneExporter : public ResourceExporter {
 	virtual String get_name() const override;
 	virtual bool supports_nonpack_export() const override { return false; }
 	virtual String get_default_export_extension(const String &res_path) const override;
+	virtual Vector<String> get_export_extensions(const String &res_path) const override;
 
 	static Ref<ExportReport> export_file_with_options(const String &out_path, const String &res_path, const Dictionary &options);
 	static size_t get_vram_usage();
@@ -114,6 +122,7 @@ class GLBExporterInstance {
 	Vector<String> image_extensions;
 	Vector<Ref<Resource>> loaded_deps;
 	Vector<uint64_t> loaded_dep_uids;
+	Vector<String> missing_dependencies;
 
 	// set during _export_instanced_scene
 	bool had_images = false;
@@ -121,7 +130,6 @@ class GLBExporterInstance {
 	Dictionary image_path_to_data_hash;
 	Vector<ObjExporter::MeshInfo> id_to_mesh_info;
 	Vector<Pair<String, String>> id_to_material_path;
-	HashMap<Ref<ShaderMaterial>, Ref<BaseMaterial3D>> shader_material_to_base_material_map;
 
 	// set during _set_stuff_from_instanced_scene
 	HashMap<String, Dictionary> node_options;
@@ -131,6 +139,7 @@ class GLBExporterInstance {
 	bool has_non_skeleton_transforms = false;
 	bool has_physics_nodes = false;
 	HashMap<String, MeshInstance3D *> mesh_path_to_instance_map;
+	Vector<String> replaced_node_names;
 	String root_type;
 	String root_name;
 	bool has_lossy_images = false;
@@ -143,6 +152,7 @@ class GLBExporterInstance {
 
 	// error tracking
 	String error_statement;
+	Vector<String> scene_loading_error_messages;
 	Vector<String> scene_instantiation_error_messages;
 	Vector<String> gltf_serialization_error_messages;
 	Vector<String> import_param_error_messages;
@@ -151,6 +161,8 @@ class GLBExporterInstance {
 
 	constexpr static const char *const COPYRIGHT_STRING_FORMAT = "The Creators of '%s'";
 
+	Pair<Ref<BaseMaterial3D>, Pair<bool, bool>> convert_shader_material_to_base_material(Ref<ShaderMaterial> p_shader_material, Node *p_parent = nullptr);
+
 	ObjExporter::MeshInfo _get_mesh_options_for_import_params();
 
 	static String get_resource_path(const Ref<Resource> &res);
@@ -161,9 +173,10 @@ class GLBExporterInstance {
 	String add_errors_to_report(Error p_err, const String &err_msg = "");
 	void set_cache_res(const dep_info &info, const Ref<Resource> &texture, bool force_replace);
 
-	void _set_stuff_from_instanced_scene(Node *root);
+	[[nodiscard]] Node *_set_stuff_from_instanced_scene(Node *root);
 	Error _export_instanced_scene(Node *root, const String &p_dest_path);
 	void _update_import_params(const String &p_dest_path);
+	Dictionary _get_default_subresource_options();
 	Error _check_model_can_load(const String &p_dest_path);
 	Error _load_deps();
 	Error _load_scene_and_deps(Ref<PackedScene> &r_scene);
diff --git a/exporters/spine_exporter.cpp b/exporters/spine_exporter.cpp
index 05b5c7dc..4fb78d16 100644
--- a/exporters/spine_exporter.cpp
+++ b/exporters/spine_exporter.cpp
@@ -70,6 +70,10 @@ String SpineAtlasExporter::get_default_export_extension(const String &res_path)
 	return "atlas";
 }
 
+Vector<String> SpineAtlasExporter::get_export_extensions(const String &res_path) const {
+	return { "atlas" };
+}
+
 // Literally all we have to do is copy the file
 Error SpineSkeletonExporter::export_file(const String &out_path, const String &res_path) {
 	gdre::ensure_dir(out_path.get_base_dir());
@@ -103,3 +107,7 @@ String SpineSkeletonExporter::get_name() const {
 String SpineSkeletonExporter::get_default_export_extension(const String &res_path) const {
 	return "spine-json";
 }
+
+Vector<String> SpineSkeletonExporter::get_export_extensions(const String &res_path) const {
+	return { "spine-json" };
+}
diff --git a/exporters/spine_exporter.h b/exporters/spine_exporter.h
index 94bbe425..251ce68a 100644
--- a/exporters/spine_exporter.h
+++ b/exporters/spine_exporter.h
@@ -13,6 +13,7 @@ class SpineAtlasExporter : public ResourceExporter {
 	virtual void get_handled_types(List<String> *out) const override;
 	virtual void get_handled_importers(List<String> *out) const override;
 	virtual String get_default_export_extension(const String &res_path) const override;
+	virtual Vector<String> get_export_extensions(const String &res_path) const override;
 };
 
 class SpineSkeletonExporter : public ResourceExporter {
@@ -27,4 +28,5 @@ class SpineSkeletonExporter : public ResourceExporter {
 	virtual void get_handled_types(List<String> *out) const override;
 	virtual void get_handled_importers(List<String> *out) const override;
 	virtual String get_default_export_extension(const String &res_path) const override;
+	virtual Vector<String> get_export_extensions(const String &res_path) const override;
 };
diff --git a/exporters/texture_exporter.cpp b/exporters/texture_exporter.cpp
index 93cddfb8..e74b9cfb 100644
--- a/exporters/texture_exporter.cpp
+++ b/exporters/texture_exporter.cpp
@@ -4,6 +4,7 @@
 #include "compat/resource_loader_compat.h"
 #include "core/version_generated.gen.h"
 #include "gdre_test_macros.h"
+#include "scene/resources/dpi_texture.h"
 #include "utility/common.h"
 
 #include "core/error/error_list.h"
@@ -984,6 +985,31 @@ Error TextureExporter::_convert_layered_2d(const String &p_path, const String &d
 	return OK;
 }
 
+Error TextureExporter::_convert_svg(const String &p_path, const String &dest_path, Ref<ExportReport> report) {
+	Error err;
+	Ref<DPITexture> tex = ResourceCompatLoader::non_global_load(p_path, "", &err);
+	if (err == ERR_UNAVAILABLE) {
+		print_line("Did not convert deprecated SVG resource " + p_path);
+		return err;
+	}
+	String source = tex->get_source();
+	ERR_FAIL_COND_V_MSG(source.is_empty(), ERR_FILE_CORRUPT, "SVG source is empty: " + p_path);
+	auto fa = FileAccess::open(dest_path, FileAccess::WRITE);
+	ERR_FAIL_COND_V_MSG(fa.is_null(), ERR_FILE_CANT_WRITE, "Cannot write to file: " + dest_path);
+	fa->store_string(source);
+	fa->close();
+	if (report.is_valid() && report->get_import_info().is_valid() && report->get_import_info()->get_ver_major() >= 4) {
+		Dictionary params;
+		Ref<ResourceInfo> res_info = ResourceInfo::get_info_from_resource(tex);
+		params["base_scale"] = tex->get_base_scale();
+		params["saturation"] = tex->get_saturation();
+		params["color_map"] = tex->get_color_map();
+		params["compress"] = res_info.is_valid() ? res_info->is_compressed : true;
+		report->get_import_info()->set_params(params);
+	}
+	return OK;
+}
+
 Ref<ExportReport> TextureExporter::export_resource(const String &output_dir, Ref<ImportInfo> iinfo) {
 	String path = iinfo->get_path();
 	String source = iinfo->get_source_file();
@@ -1040,6 +1066,8 @@ Ref<ExportReport> TextureExporter::export_resource(const String &output_dir, Ref
 			return report;
 		}
 	}
+	String importer = iinfo->get_importer();
+
 	// for Godot 2.x resources, we can easily rewrite the metadata to point to a renamed file with a different extension,
 	// but this isn't the case for 3.x and greater, so we have to save in the original (lossy) format.
 	String source_ext = source.get_extension().to_lower();
@@ -1085,7 +1113,6 @@ Ref<ExportReport> TextureExporter::export_resource(const String &output_dir, Ref
 
 	Error err = OK;
 	String img_format = "bitmap";
-	String importer = iinfo->get_importer();
 	String dest_path = output_dir.path_join(iinfo->get_export_dest().replace("res://", ""));
 	if (importer == "image") {
 		ResourceFormatLoaderImage rli;
@@ -1119,6 +1146,8 @@ Ref<ExportReport> TextureExporter::export_resource(const String &output_dir, Ref
 		err = _convert_3d(path, dest_path, lossy, img_format, report);
 	} else if (importer == "texture" || importer == "texture_2d") {
 		err = _convert_tex(path, dest_path, lossy, img_format, report);
+	} else if (importer == "svg") {
+		err = _convert_svg(path, dest_path, report);
 	} else {
 		report->set_error(ERR_UNAVAILABLE);
 		report->set_message("Unsupported texture importer: " + importer);
@@ -1176,6 +1205,7 @@ void TextureExporter::get_handled_types(List<String> *out) const {
 	out->push_back("CompressedCubemap");
 	out->push_back("CompressedCubemapArray");
 	out->push_back("TextureArray");
+	out->push_back("DPITexture");
 }
 
 void TextureExporter::get_handled_importers(List<String> *out) const {
@@ -1191,6 +1221,7 @@ void TextureExporter::get_handled_importers(List<String> *out) const {
 	out->push_back("cubemap_array_texture");
 	out->push_back("texture_3d");
 	out->push_back("3d_texture");
+	out->push_back("svg");
 }
 
 String TextureExporter::get_name() const {
@@ -1200,6 +1231,11 @@ String TextureExporter::get_name() const {
 String TextureExporter::get_default_export_extension(const String &res_path) const {
 	return "png";
 }
+
+Vector<String> TextureExporter::get_export_extensions(const String &res_path) const {
+	return ImageSaver::get_supported_extensions();
+}
+
 namespace {
 Error check_image_colors(const Ref<Image> &original_image, const Ref<Image> &exported_image) {
 	Error _ret_err = OK;
diff --git a/exporters/texture_exporter.h b/exporters/texture_exporter.h
index acafdeda..f9f6a7f4 100644
--- a/exporters/texture_exporter.h
+++ b/exporters/texture_exporter.h
@@ -8,6 +8,7 @@ class TextureExporter : public ResourceExporter {
 	Error _convert_tex(const String &p_path, const String &p_dst, bool lossy, String &image_format, Ref<ExportReport> report = nullptr);
 	Error _convert_atex(const String &p_path, const String &p_dst, bool lossy, String &image_format, Ref<ExportReport> report = nullptr);
 	Error _convert_bitmap(const String &p_path, const String &p_dst, bool lossy, Ref<ExportReport> report = nullptr);
+	Error _convert_svg(const String &p_path, const String &p_dst, Ref<ExportReport> report = nullptr);
 
 	static Ref<Image> load_image_from_bitmap(const String p_path, Error *r_err);
 	Error _convert_3d(const String &p_path, const String &p_dst, bool lossy, String &image_format, Ref<ExportReport> report = nullptr);
@@ -24,5 +25,6 @@ class TextureExporter : public ResourceExporter {
 	virtual void get_handled_importers(List<String> *out) const override;
 	virtual String get_name() const override;
 	virtual String get_default_export_extension(const String &res_path) const override;
+	virtual Vector<String> get_export_extensions(const String &res_path) const override;
 	virtual Error test_export(const Ref<ExportReport> &export_report, const String &original_project_dir) const override;
 };
diff --git a/exporters/translation_exporter.cpp b/exporters/translation_exporter.cpp
index 71ce3bb5..eb7ca457 100644
--- a/exporters/translation_exporter.cpp
+++ b/exporters/translation_exporter.cpp
@@ -2475,6 +2475,10 @@ String TranslationExporter::get_default_export_extension(const String &res_path)
 	return "csv";
 }
 
+Vector<String> TranslationExporter::get_export_extensions(const String &res_path) const {
+	return { "csv" };
+}
+
 Error TranslationExporter::parse_csv(const String &csv_path, HashMap<String, Vector<String>> &new_messages, int64_t &missing_keys, bool &has_non_empty_lines_without_key, int64_t &non_empty_line_count) {
 	Ref<FileAccess> f = FileAccess::open(csv_path, FileAccess::READ);
 	ERR_FAIL_COND_V_MSG(f.is_null(), ERR_CANT_ACQUIRE_RESOURCE, "Could not open file " + csv_path);
diff --git a/exporters/translation_exporter.h b/exporters/translation_exporter.h
index 46529d58..e60e0d3e 100644
--- a/exporters/translation_exporter.h
+++ b/exporters/translation_exporter.h
@@ -29,6 +29,7 @@ class TranslationExporter : public ResourceExporter {
 	virtual String get_name() const override;
 	virtual bool supports_nonpack_export() const override { return false; }
 	virtual String get_default_export_extension(const String &res_path) const override;
+	virtual Vector<String> get_export_extensions(const String &res_path) const override;
 
 	static TypedDictionary<String, Vector<String>> get_messages_from_translation(Ref<ImportInfo> translation_info);
 	static TypedDictionary<String, Vector<String>> get_csv_messages(const String &csv_path, Dictionary ret_info);
diff --git a/external/etcpak-decompress/.clang-format b/external/etcpak-decompress/.clang-format
deleted file mode 100644
index c8e4cf5c..00000000
--- a/external/etcpak-decompress/.clang-format
+++ /dev/null
@@ -1,2 +0,0 @@
-DisableFormat: true
-SortIncludes: Never
diff --git a/external/etcpak-decompress/BlockData.cpp b/external/etcpak-decompress/BlockData.cpp
deleted file mode 100644
index 408f895d..00000000
--- a/external/etcpak-decompress/BlockData.cpp
+++ /dev/null
@@ -1,1062 +0,0 @@
-#include <assert.h>
-#include <string.h>
-
-#include "etc_format.h"
-#include "BlockData.hpp"
-#include "Math.hpp"
-#include "Tables.hpp"
-#ifdef __ARM_NEON
-#  include <arm_neon.h>
-#endif
-
-#if defined __SSE4_1__ || defined __AVX2__ || defined _MSC_VER
-#  ifdef _MSC_VER
-#    include <intrin.h>
-#    include <Windows.h>
-#    define _bswap(x) _byteswap_ulong(x)
-#    define _bswap64(x) _byteswap_uint64(x)
-#  else
-#    include <x86intrin.h>
-#  endif
-#endif
-
-#ifndef _bswap
-#  define _bswap(x) __builtin_bswap32(x)
-#  define _bswap64(x) __builtin_bswap64(x)
-#endif
-
-static uint8_t table59T58H[8] = { 3,6,11,16,23,32,41,64 };
-
-namespace
-{
-
-static etcpak_force_inline int32_t expand6(uint32_t value)
-{
-    return (value << 2) | (value >> 4);
-}
-
-static etcpak_force_inline int32_t expand7(uint32_t value)
-{
-    return (value << 1) | (value >> 6);
-}
-
-static etcpak_force_inline void DecodeT( uint64_t block, uint32_t* dst, uint32_t w )
-{
-    const auto r0 = ( block >> 24 ) & 0x1B;
-    const auto rh0 = ( r0 >> 3 ) & 0x3;
-    const auto rl0 = r0 & 0x3;
-    const auto g0 = ( block >> 20 ) & 0xF;
-    const auto b0 = ( block >> 16 ) & 0xF;
-
-    const auto r1 = ( block >> 12 ) & 0xF;
-    const auto g1 = ( block >> 8 ) & 0xF;
-    const auto b1 = ( block >> 4 ) & 0xF;
-
-    const auto cr0 = ( ( rh0 << 6 ) | ( rl0 << 4 ) | ( rh0 << 2 ) | rl0);
-    const auto cg0 = ( g0 << 4 ) | g0;
-    const auto cb0 = ( b0 << 4 ) | b0;
-
-    const auto cr1 = ( r1 << 4 ) | r1;
-    const auto cg1 = ( g1 << 4 ) | g1;
-    const auto cb1 = ( b1 << 4 ) | b1;
-
-    const auto codeword_hi = ( block >> 2 ) & 0x3;
-    const auto codeword_lo = block & 0x1;
-    const auto codeword = ( codeword_hi << 1 ) | codeword_lo;
-
-    const auto c2r = clampu8( cr1 + table59T58H[codeword] );
-    const auto c2g = clampu8( cg1 + table59T58H[codeword] );
-    const auto c2b = clampu8( cb1 + table59T58H[codeword] );
-
-    const auto c3r = clampu8( cr1 - table59T58H[codeword] );
-    const auto c3g = clampu8( cg1 - table59T58H[codeword] );
-    const auto c3b = clampu8( cb1 - table59T58H[codeword] );
-
-    const uint32_t col_tab[4] = {
-        uint32_t( cr0 | ( cg0 << 8 ) | ( cb0 << 16 ) | 0xFF000000 ),
-        uint32_t( c2r | ( c2g << 8 ) | ( c2b << 16 ) | 0xFF000000 ),
-        uint32_t( cr1 | ( cg1 << 8 ) | ( cb1 << 16 ) | 0xFF000000 ),
-        uint32_t( c3r | ( c3g << 8 ) | ( c3b << 16 ) | 0xFF000000 )
-    };
-
-    const uint32_t indexes = ( block >> 32 ) & 0xFFFFFFFF;
-    for( uint8_t j = 0; j < 4; j++ )
-    {
-        for( uint8_t i = 0; i < 4; i++ )
-        {
-            //2bit indices distributed on two lane 16bit numbers
-            const uint8_t index = ( ( ( indexes >> ( j + i * 4 + 16 ) ) & 0x1 ) << 1) | ( ( indexes >> ( j + i * 4 ) ) & 0x1);
-            dst[j * w + i] = col_tab[index];
-        }
-    }
-}
-
-static etcpak_force_inline void DecodeTAlpha( uint64_t block, uint64_t alpha, uint32_t* dst, uint32_t w )
-{
-    const auto r0 = ( block >> 24 ) & 0x1B;
-    const auto rh0 = ( r0 >> 3 ) & 0x3;
-    const auto rl0 = r0 & 0x3;
-    const auto g0 = ( block >> 20 ) & 0xF;
-    const auto b0 = ( block >> 16 ) & 0xF;
-
-    const auto r1 = ( block >> 12 ) & 0xF;
-    const auto g1 = ( block >> 8 ) & 0xF;
-    const auto b1 = ( block >> 4 ) & 0xF;
-
-    const auto cr0 = ( ( rh0 << 6 ) | ( rl0 << 4 ) | ( rh0 << 2 ) | rl0);
-    const auto cg0 = ( g0 << 4 ) | g0;
-    const auto cb0 = ( b0 << 4 ) | b0;
-
-    const auto cr1 = ( r1 << 4 ) | r1;
-    const auto cg1 = ( g1 << 4 ) | g1;
-    const auto cb1 = ( b1 << 4 ) | b1;
-
-    const auto codeword_hi = ( block >> 2 ) & 0x3;
-    const auto codeword_lo = block & 0x1;
-    const auto codeword = (codeword_hi << 1) | codeword_lo;
-
-    const int32_t base = alpha >> 56;
-    const int32_t mul = ( alpha >> 52 ) & 0xF;
-    const auto tbl = g_alpha[( alpha >> 48 ) & 0xF];
-
-    const auto c2r = clampu8( cr1 + table59T58H[codeword] );
-    const auto c2g = clampu8( cg1 + table59T58H[codeword] );
-    const auto c2b = clampu8( cb1 + table59T58H[codeword] );
-
-    const auto c3r = clampu8( cr1 - table59T58H[codeword] );
-    const auto c3g = clampu8( cg1 - table59T58H[codeword] );
-    const auto c3b = clampu8( cb1 - table59T58H[codeword] );
-
-    const uint32_t col_tab[4] = {
-        uint32_t( cr0 | ( cg0 << 8 ) | ( cb0 << 16 ) ),
-        uint32_t( c2r | ( c2g << 8 ) | ( c2b << 16 ) ),
-        uint32_t( cr1 | ( cg1 << 8 ) | ( cb1 << 16 ) ),
-        uint32_t( c3r | ( c3g << 8 ) | ( c3b << 16 ) )
-    };
-
-    const uint32_t indexes = ( block >> 32 ) & 0xFFFFFFFF;
-    for( uint8_t j = 0; j < 4; j++ )
-    {
-        for( uint8_t i = 0; i < 4; i++ )
-        {
-            //2bit indices distributed on two lane 16bit numbers
-            const uint8_t index = ( ( ( indexes >> ( j + i * 4 + 16 ) ) & 0x1 ) << 1 ) | ( ( indexes >> ( j + i * 4 ) ) & 0x1 );
-            const auto amod = tbl[( alpha >> ( 45 - j * 3 - i * 12 ) ) & 0x7];
-            const uint32_t a = clampu8( base + amod * mul );
-            dst[j * w + i] = col_tab[index] | ( a << 24 );
-        }
-    }
-}
-
-static etcpak_force_inline void DecodeH( uint64_t block, uint32_t* dst, uint32_t w )
-{
-    const uint32_t indexes = ( block >> 32 ) & 0xFFFFFFFF;
-
-    const auto r0444 = ( block >> 27 ) & 0xF;
-    const auto g0444 = ( ( block >> 20 ) & 0x1 ) | ( ( ( block >> 24 ) & 0x7 ) << 1 );
-    const auto b0444 = ( ( block >> 15 ) & 0x7 ) | ( ( ( block >> 19 ) & 0x1 ) << 3 );
-
-    const auto r1444 = ( block >> 11 ) & 0xF;
-    const auto g1444 = ( block >> 7 ) & 0xF;
-    const auto b1444 = ( block >> 3 ) & 0xF;
-
-    const auto r0 = ( r0444 << 4 ) | r0444;
-    const auto g0 = ( g0444 << 4 ) | g0444;
-    const auto b0 = ( b0444 << 4 ) | b0444;
-
-    const auto r1 = ( r1444 << 4 ) | r1444;
-    const auto g1 = ( g1444 << 4 ) | g1444;
-    const auto b1 = ( b1444 << 4 ) | b1444;
-
-    const auto codeword_hi = ( ( block & 0x1 ) << 1 ) | ( ( block & 0x4 ) );
-    const auto c0 = ( r0444 << 8 ) | ( g0444 << 4 ) | ( b0444 << 0 );
-    const auto c1 = ( block >> 3 ) & ( ( 1 << 12 ) - 1 );
-    const auto codeword_lo = ( c0 >= c1 ) ? 1 : 0;
-    const auto codeword = codeword_hi | codeword_lo;
-
-    const uint32_t col_tab[] = {
-        uint32_t( clampu8( r0 + table59T58H[codeword] ) | ( clampu8( g0 + table59T58H[codeword] ) << 8 ) | ( clampu8( b0 + table59T58H[codeword] ) << 16 ) ),
-        uint32_t( clampu8( r0 - table59T58H[codeword] ) | ( clampu8( g0 - table59T58H[codeword] ) << 8 ) | ( clampu8( b0 - table59T58H[codeword] ) << 16 ) ),
-        uint32_t( clampu8( r1 + table59T58H[codeword] ) | ( clampu8( g1 + table59T58H[codeword] ) << 8 ) | ( clampu8( b1 + table59T58H[codeword] ) << 16 ) ),
-        uint32_t( clampu8( r1 - table59T58H[codeword] ) | ( clampu8( g1 - table59T58H[codeword] ) << 8 ) | ( clampu8( b1 - table59T58H[codeword] ) << 16 ) )
-    };
-
-    for( uint8_t j = 0; j < 4; j++ )
-    {
-        for( uint8_t i = 0; i < 4; i++ )
-        {
-            const uint8_t index = ( ( ( indexes >> ( j + i * 4 + 16 ) ) & 0x1 ) << 1 ) | ( ( indexes >> ( j + i * 4 ) ) & 0x1 );
-            dst[j * w + i] = col_tab[index] | 0xFF000000;
-        }
-    }
-}
-
-static etcpak_force_inline void DecodeHAlpha( uint64_t block, uint64_t alpha, uint32_t* dst, uint32_t w )
-{
-    const uint32_t indexes = ( block >> 32 ) & 0xFFFFFFFF;
-
-    const auto r0444 = ( block >> 27 ) & 0xF;
-    const auto g0444 = ( ( block >> 20 ) & 0x1 ) | ( ( ( block >> 24 ) & 0x7 ) << 1 );
-    const auto b0444 = ( ( block >> 15 ) & 0x7 ) | ( ( ( block >> 19 ) & 0x1 ) << 3 );
-
-    const auto r1444 = ( block >> 11 ) & 0xF;
-    const auto g1444 = ( block >> 7 ) & 0xF;
-    const auto b1444 = ( block >> 3 ) & 0xF;
-
-    const auto r0 = ( r0444 << 4 ) | r0444;
-    const auto g0 = ( g0444 << 4 ) | g0444;
-    const auto b0 = ( b0444 << 4 ) | b0444;
-
-    const auto r1 = ( r1444 << 4 ) | r1444;
-    const auto g1 = ( g1444 << 4 ) | g1444;
-    const auto b1 = ( b1444 << 4 ) | b1444;
-
-    const auto codeword_hi = ( ( block & 0x1 ) << 1 ) | ( ( block & 0x4 ) );
-    const auto c0 = ( r0444 << 8 ) | ( g0444 << 4 ) | ( b0444 << 0 );
-    const auto c1 = ( block >> 3 ) & ( ( 1 << 12 ) - 1 );
-    const auto codeword_lo = ( c0 >= c1 ) ? 1 : 0;
-    const auto codeword = codeword_hi | codeword_lo;
-
-    const int32_t base = alpha >> 56;
-    const int32_t mul = ( alpha >> 52 ) & 0xF;
-    const auto tbl = g_alpha[(alpha >> 48) & 0xF];
-
-    const uint32_t col_tab[] = {
-        uint32_t( clampu8( r0 + table59T58H[codeword] ) | ( clampu8( g0 + table59T58H[codeword] ) << 8 ) | ( clampu8( b0 + table59T58H[codeword] ) << 16 ) ),
-        uint32_t( clampu8( r0 - table59T58H[codeword] ) | ( clampu8( g0 - table59T58H[codeword] ) << 8 ) | ( clampu8( b0 - table59T58H[codeword] ) << 16 ) ),
-        uint32_t( clampu8( r1 + table59T58H[codeword] ) | ( clampu8( g1 + table59T58H[codeword] ) << 8 ) | ( clampu8( b1 + table59T58H[codeword] ) << 16 ) ),
-        uint32_t( clampu8( r1 - table59T58H[codeword] ) | ( clampu8( g1 - table59T58H[codeword] ) << 8 ) | ( clampu8( b1 - table59T58H[codeword] ) << 16 ) )
-    };
-
-    for( uint8_t j = 0; j < 4; j++ )
-    {
-        for( uint8_t i = 0; i < 4; i++ )
-        {
-            const uint8_t index = ( ( ( indexes >> ( j + i * 4 + 16 ) ) & 0x1 ) << 1 ) | ( ( indexes >> ( j + i * 4 ) ) & 0x1 );
-            const auto amod = tbl[( alpha >> ( 45 - j * 3 - i * 12) ) & 0x7];
-            const uint32_t a = clampu8( base + amod * mul );
-            dst[j * w + i] = col_tab[index] | ( a << 24 );
-        }
-    }
-}
-
-static etcpak_force_inline void DecodePlanar( uint64_t block, uint32_t* dst, uint32_t w )
-{
-    const auto bv = expand6((block >> ( 0 + 32)) & 0x3F);
-    const auto gv = expand7((block >> ( 6 + 32)) & 0x7F);
-    const auto rv = expand6((block >> (13 + 32)) & 0x3F);
-
-    const auto bh = expand6((block >> (19 + 32)) & 0x3F);
-    const auto gh = expand7((block >> (25 + 32)) & 0x7F);
-
-    const auto rh0 = (block >> (32 - 32)) & 0x01;
-    const auto rh1 = ((block >> (34 - 32)) & 0x1F) << 1;
-    const auto rh = expand6(rh0 | rh1);
-
-    const auto bo0 = (block >> (39 - 32)) & 0x07;
-    const auto bo1 = ((block >> (43 - 32)) & 0x3) << 3;
-    const auto bo2 = ((block >> (48 - 32)) & 0x1) << 5;
-    const auto bo = expand6(bo0 | bo1 | bo2);
-    const auto go0 = (block >> (49 - 32)) & 0x3F;
-    const auto go1 = ((block >> (56 - 32)) & 0x01) << 6;
-    const auto go = expand7(go0 | go1);
-    const auto ro = expand6((block >> (57 - 32)) & 0x3F);
-
-#ifdef __ARM_NEON
-    uint64_t init = uint64_t(uint16_t(rh-ro)) | ( uint64_t(uint16_t(gh-go)) << 16 ) | ( uint64_t(uint16_t(bh-bo)) << 32 );
-    int16x8_t chco = vreinterpretq_s16_u64( vdupq_n_u64( init ) );
-    init = uint64_t(uint16_t( (rv-ro) - 4 * (rh-ro) )) | ( uint64_t(uint16_t( (gv-go) - 4 * (gh-go) )) << 16 ) | ( uint64_t(uint16_t( (bv-bo) - 4 * (bh-bo) )) << 32 );
-    int16x8_t cvco = vreinterpretq_s16_u64( vdupq_n_u64( init ) );
-    init = uint64_t(4*ro+2) | ( uint64_t(4*go+2) << 16 ) | ( uint64_t(4*bo+2) << 32 ) | ( uint64_t(0xFFF) << 48 );
-    int16x8_t col = vreinterpretq_s16_u64( vdupq_n_u64( init ) );
-
-    for( int j=0; j<4; j++ )
-    {
-        for( int i=0; i<4; i++ )
-        {
-            uint8x8_t c = vqshrun_n_s16( col, 2 );
-            vst1_lane_u32( dst+j*w+i, vreinterpret_u32_u8( c ), 0 );
-            col = vaddq_s16( col, chco );
-        }
-        col = vaddq_s16( col, cvco );
-    }
-#elif defined __AVX2__
-    const auto R0 = 4*ro+2;
-    const auto G0 = 4*go+2;
-    const auto B0 = 4*bo+2;
-    const auto RHO = rh-ro;
-    const auto GHO = gh-go;
-    const auto BHO = bh-bo;
-
-    __m256i cvco = _mm256_setr_epi16( rv - ro, gv - go, bv - bo, 0, rv - ro, gv - go, bv - bo, 0, rv - ro, gv - go, bv - bo, 0, rv - ro, gv - go, bv - bo, 0 );
-    __m256i col = _mm256_setr_epi16( R0, G0, B0, 0xFFF, R0+RHO, G0+GHO, B0+BHO, 0xFFF, R0+2*RHO, G0+2*GHO, B0+2*BHO, 0xFFF, R0+3*RHO, G0+3*GHO, B0+3*BHO, 0xFFF );
-
-    for( int j=0; j<4; j++ )
-    {
-        __m256i c = _mm256_srai_epi16( col, 2 );
-        __m128i s = _mm_packus_epi16( _mm256_castsi256_si128( c ), _mm256_extracti128_si256( c, 1 ) );
-        _mm_storeu_si128( (__m128i*)(dst+j*w), s );
-        col = _mm256_add_epi16( col, cvco );
-    }
-#elif defined __SSE4_1__
-    __m128i chco = _mm_setr_epi16( rh - ro, gh - go, bh - bo, 0, 0, 0, 0, 0 );
-    __m128i cvco = _mm_setr_epi16( (rv - ro) - 4 * (rh - ro), (gv - go) - 4 * (gh - go), (bv - bo) - 4 * (bh - bo), 0, 0, 0, 0, 0 );
-    __m128i col = _mm_setr_epi16( 4*ro+2, 4*go+2, 4*bo+2, 0xFFF, 0, 0, 0, 0 );
-
-    for( int j=0; j<4; j++ )
-    {
-        for( int i=0; i<4; i++ )
-        {
-            __m128i c = _mm_srai_epi16( col, 2 );
-            __m128i s = _mm_packus_epi16( c, c );
-            dst[j*w+i] = _mm_cvtsi128_si32( s );
-            col = _mm_add_epi16( col, chco );
-        }
-        col = _mm_add_epi16( col, cvco );
-    }
-#else
-    for( int j=0; j<4; j++ )
-    {
-        for( int i=0; i<4; i++ )
-        {
-            const uint32_t r = (i * (rh - ro) + j * (rv - ro) + 4 * ro + 2) >> 2;
-            const uint32_t g = (i * (gh - go) + j * (gv - go) + 4 * go + 2) >> 2;
-            const uint32_t b = (i * (bh - bo) + j * (bv - bo) + 4 * bo + 2) >> 2;
-            if( ( ( r | g | b ) & ~0xFF ) == 0 )
-            {
-                dst[j*w+i] = r | ( g << 8 ) | ( b << 16 ) | 0xFF000000;
-            }
-            else
-            {
-                const auto rc = clampu8( r );
-                const auto gc = clampu8( g );
-                const auto bc = clampu8( b );
-                dst[j*w+i] = rc | ( gc << 8 ) | ( bc << 16 ) | 0xFF000000;
-            }
-        }
-    }
-#endif
-}
-
-static etcpak_force_inline void DecodePlanarAlpha( uint64_t block, uint64_t alpha, uint32_t* dst, uint32_t w )
-{
-    const auto bv = expand6((block >> ( 0 + 32)) & 0x3F);
-    const auto gv = expand7((block >> ( 6 + 32)) & 0x7F);
-    const auto rv = expand6((block >> (13 + 32)) & 0x3F);
-
-    const auto bh = expand6((block >> (19 + 32)) & 0x3F);
-    const auto gh = expand7((block >> (25 + 32)) & 0x7F);
-
-    const auto rh0 = (block >> (32 - 32)) & 0x01;
-    const auto rh1 = ((block >> (34 - 32)) & 0x1F) << 1;
-    const auto rh = expand6(rh0 | rh1);
-
-    const auto bo0 = (block >> (39 - 32)) & 0x07;
-    const auto bo1 = ((block >> (43 - 32)) & 0x3) << 3;
-    const auto bo2 = ((block >> (48 - 32)) & 0x1) << 5;
-    const auto bo = expand6(bo0 | bo1 | bo2);
-    const auto go0 = (block >> (49 - 32)) & 0x3F;
-    const auto go1 = ((block >> (56 - 32)) & 0x01) << 6;
-    const auto go = expand7(go0 | go1);
-    const auto ro = expand6((block >> (57 - 32)) & 0x3F);
-
-    const int32_t base = alpha >> 56;
-    const int32_t mul = ( alpha >> 52 ) & 0xF;
-    const auto tbl = g_alpha[( alpha >> 48 ) & 0xF];
-
-#ifdef __ARM_NEON
-    uint64_t init = uint64_t(uint16_t(rh-ro)) | ( uint64_t(uint16_t(gh-go)) << 16 ) | ( uint64_t(uint16_t(bh-bo)) << 32 );
-    int16x8_t chco = vreinterpretq_s16_u64( vdupq_n_u64( init ) );
-    init = uint64_t(uint16_t( (rv-ro) - 4 * (rh-ro) )) | ( uint64_t(uint16_t( (gv-go) - 4 * (gh-go) )) << 16 ) | ( uint64_t(uint16_t( (bv-bo) - 4 * (bh-bo) )) << 32 );
-    int16x8_t cvco = vreinterpretq_s16_u64( vdupq_n_u64( init ) );
-    init = uint64_t(4*ro+2) | ( uint64_t(4*go+2) << 16 ) | ( uint64_t(4*bo+2) << 32 );
-    int16x8_t col = vreinterpretq_s16_u64( vdupq_n_u64( init ) );
-
-    for( int j=0; j<4; j++ )
-    {
-        for( int i=0; i<4; i++ )
-        {
-            const auto amod = tbl[(alpha >> ( 45 - j*3 - i*12 )) & 0x7];
-            const uint32_t a = clampu8( base + amod * mul );
-            uint8x8_t c = vqshrun_n_s16( col, 2 );
-            dst[j*w+i] = vget_lane_u32( vreinterpret_u32_u8( c ), 0 ) | ( a << 24 );
-            col = vaddq_s16( col, chco );
-        }
-        col = vaddq_s16( col, cvco );
-    }
-#elif defined __SSE4_1__
-    __m128i chco = _mm_setr_epi16( rh - ro, gh - go, bh - bo, 0, 0, 0, 0, 0 );
-    __m128i cvco = _mm_setr_epi16( (rv - ro) - 4 * (rh - ro), (gv - go) - 4 * (gh - go), (bv - bo) - 4 * (bh - bo), 0, 0, 0, 0, 0 );
-    __m128i col = _mm_setr_epi16( 4*ro+2, 4*go+2, 4*bo+2, 0, 0, 0, 0, 0 );
-
-    for( int j=0; j<4; j++ )
-    {
-        for( int i=0; i<4; i++ )
-        {
-            const auto amod = tbl[(alpha >> ( 45 - j*3 - i*12 )) & 0x7];
-            const uint32_t a = clampu8( base + amod * mul );
-            __m128i c = _mm_srai_epi16( col, 2 );
-            __m128i s = _mm_packus_epi16( c, c );
-            dst[j*w+i] = _mm_cvtsi128_si32( s ) | ( a << 24 );
-            col = _mm_add_epi16( col, chco );
-        }
-        col = _mm_add_epi16( col, cvco );
-    }
-#else
-    for (auto j = 0; j < 4; j++)
-    {
-        for (auto i = 0; i < 4; i++)
-        {
-            const uint32_t r = (i * (rh - ro) + j * (rv - ro) + 4 * ro + 2) >> 2;
-            const uint32_t g = (i * (gh - go) + j * (gv - go) + 4 * go + 2) >> 2;
-            const uint32_t b = (i * (bh - bo) + j * (bv - bo) + 4 * bo + 2) >> 2;
-            const auto amod = tbl[(alpha >> ( 45 - j*3 - i*12 )) & 0x7];
-            const uint32_t a = clampu8( base + amod * mul );
-            if( ( ( r | g | b ) & ~0xFF ) == 0 )
-            {
-                dst[j*w+i] = r | ( g << 8 ) | ( b << 16 ) | ( a << 24 );
-            }
-            else
-            {
-                const auto rc = clampu8( r );
-                const auto gc = clampu8( g );
-                const auto bc = clampu8( b );
-                dst[j*w+i] = rc | ( gc << 8 ) | ( bc << 16 ) | ( a << 24 );
-            }
-        }
-    }
-#endif
-}
-
-}
-
-
-static etcpak_force_inline uint64_t ConvertByteOrder( uint64_t d )
-{
-    uint32_t word[2];
-    memcpy( word, &d, 8 );
-    word[0] = _bswap( word[0] );
-    word[1] = _bswap( word[1] );
-    memcpy( &d, word, 8 );
-    return d;
-}
-
-static etcpak_force_inline void DecodeRGBPart( uint64_t d, uint32_t* dst, uint32_t w )
-{
-    d = ConvertByteOrder( d );
-
-    uint32_t br[2], bg[2], bb[2];
-
-    if( d & 0x2 )
-    {
-        int32_t dr, dg, db;
-
-        uint32_t r0 = ( d & 0xF8000000 ) >> 27;
-        uint32_t g0 = ( d & 0x00F80000 ) >> 19;
-        uint32_t b0 = ( d & 0x0000F800 ) >> 11;
-
-        dr = ( int32_t(d) << 5 ) >> 29;
-        dg = ( int32_t(d) << 13 ) >> 29;
-        db = ( int32_t(d) << 21 ) >> 29;
-
-        int32_t r1 = int32_t(r0) + dr;
-        int32_t g1 = int32_t(g0) + dg;
-        int32_t b1 = int32_t(b0) + db;
-
-        // T mode
-        if ( (r1 < 0) || (r1 > 31) )
-        {
-            DecodeT( d, dst, w );
-            return;
-        }
-
-        // H mode
-        if ((g1 < 0) || (g1 > 31))
-        {
-            DecodeH( d, dst, w );
-            return;
-        }
-
-        // P mode
-        if( (b1 < 0) || (b1 > 31) )
-        {
-            DecodePlanar( d, dst, w );
-            return;
-        }
-
-        br[0] = ( r0 << 3 ) | ( r0 >> 2 );
-        br[1] = ( r1 << 3 ) | ( r1 >> 2 );
-        bg[0] = ( g0 << 3 ) | ( g0 >> 2 );
-        bg[1] = ( g1 << 3 ) | ( g1 >> 2 );
-        bb[0] = ( b0 << 3 ) | ( b0 >> 2 );
-        bb[1] = ( b1 << 3 ) | ( b1 >> 2 );
-    }
-    else
-    {
-        br[0] = ( ( d & 0xF0000000 ) >> 24 ) | ( ( d & 0xF0000000 ) >> 28 );
-        br[1] = ( ( d & 0x0F000000 ) >> 20 ) | ( ( d & 0x0F000000 ) >> 24 );
-        bg[0] = ( ( d & 0x00F00000 ) >> 16 ) | ( ( d & 0x00F00000 ) >> 20 );
-        bg[1] = ( ( d & 0x000F0000 ) >> 12 ) | ( ( d & 0x000F0000 ) >> 16 );
-        bb[0] = ( ( d & 0x0000F000 ) >> 8  ) | ( ( d & 0x0000F000 ) >> 12 );
-        bb[1] = ( ( d & 0x00000F00 ) >> 4  ) | ( ( d & 0x00000F00 ) >> 8  );
-    }
-
-    unsigned int tcw[2];
-    tcw[0] = ( d & 0xE0 ) >> 5;
-    tcw[1] = ( d & 0x1C ) >> 2;
-
-    uint32_t b1 = ( d >> 32 ) & 0xFFFF;
-    uint32_t b2 = ( d >> 48 );
-
-    b1 = ( b1 | ( b1 << 8 ) ) & 0x00FF00FF;
-    b1 = ( b1 | ( b1 << 4 ) ) & 0x0F0F0F0F;
-    b1 = ( b1 | ( b1 << 2 ) ) & 0x33333333;
-    b1 = ( b1 | ( b1 << 1 ) ) & 0x55555555;
-
-    b2 = ( b2 | ( b2 << 8 ) ) & 0x00FF00FF;
-    b2 = ( b2 | ( b2 << 4 ) ) & 0x0F0F0F0F;
-    b2 = ( b2 | ( b2 << 2 ) ) & 0x33333333;
-    b2 = ( b2 | ( b2 << 1 ) ) & 0x55555555;
-
-    uint32_t idx = b1 | ( b2 << 1 );
-
-    if( d & 0x1 )
-    {
-        for( int i=0; i<4; i++ )
-        {
-            for( int j=0; j<4; j++ )
-            {
-                const auto mod = g_table[tcw[j/2]][idx & 0x3];
-                const auto r = br[j/2] + mod;
-                const auto g = bg[j/2] + mod;
-                const auto b = bb[j/2] + mod;
-                if( ( ( r | g | b ) & ~0xFF ) == 0 )
-                {
-                    dst[j*w+i] = r | ( g << 8 ) | ( b << 16 ) | 0xFF000000;
-                }
-                else
-                {
-                    const auto rc = clampu8( r );
-                    const auto gc = clampu8( g );
-                    const auto bc = clampu8( b );
-                    dst[j*w+i] = rc | ( gc << 8 ) | ( bc << 16 ) | 0xFF000000;
-                }
-                idx >>= 2;
-            }
-        }
-    }
-    else
-    {
-        for( int i=0; i<4; i++ )
-        {
-            const auto tbl = g_table[tcw[i/2]];
-            const auto cr = br[i/2];
-            const auto cg = bg[i/2];
-            const auto cb = bb[i/2];
-
-            for( int j=0; j<4; j++ )
-            {
-                const auto mod = tbl[idx & 0x3];
-                const auto r = cr + mod;
-                const auto g = cg + mod;
-                const auto b = cb + mod;
-                if( ( ( r | g | b ) & ~0xFF ) == 0 )
-                {
-                    dst[j*w+i] = r | ( g << 8 ) | ( b << 16 ) | 0xFF000000;
-                }
-                else
-                {
-                    const auto rc = clampu8( r );
-                    const auto gc = clampu8( g );
-                    const auto bc = clampu8( b );
-                    dst[j*w+i] = rc | ( gc << 8 ) | ( bc << 16 ) | 0xFF000000;
-                }
-                idx >>= 2;
-            }
-        }
-    }
-}
-
-static etcpak_force_inline void DecodeRGBAPart( uint64_t d, uint64_t alpha, uint32_t* dst, uint32_t w )
-{
-    d = ConvertByteOrder( d );
-    alpha = _bswap64( alpha );
-
-    uint32_t br[2], bg[2], bb[2];
-
-    if( d & 0x2 )
-    {
-        int32_t dr, dg, db;
-
-        uint32_t r0 = ( d & 0xF8000000 ) >> 27;
-        uint32_t g0 = ( d & 0x00F80000 ) >> 19;
-        uint32_t b0 = ( d & 0x0000F800 ) >> 11;
-
-        dr = ( int32_t(d) << 5 ) >> 29;
-        dg = ( int32_t(d) << 13 ) >> 29;
-        db = ( int32_t(d) << 21 ) >> 29;
-
-        int32_t r1 = int32_t(r0) + dr;
-        int32_t g1 = int32_t(g0) + dg;
-        int32_t b1 = int32_t(b0) + db;
-
-        // T mode
-        if ( (r1 < 0) || (r1 > 31) )
-        {
-            DecodeTAlpha( d, alpha, dst, w );
-            return;
-        }
-
-        // H mode
-        if ( (g1 < 0) || (g1 > 31) )
-        {
-            DecodeHAlpha( d, alpha, dst, w );
-            return;
-        }
-
-        // P mode
-        if ( (b1 < 0) || (b1 > 31) )
-        {
-            DecodePlanarAlpha( d, alpha, dst, w );
-            return;
-        }
-
-        br[0] = ( r0 << 3 ) | ( r0 >> 2 );
-        br[1] = ( r1 << 3 ) | ( r1 >> 2 );
-        bg[0] = ( g0 << 3 ) | ( g0 >> 2 );
-        bg[1] = ( g1 << 3 ) | ( g1 >> 2 );
-        bb[0] = ( b0 << 3 ) | ( b0 >> 2 );
-        bb[1] = ( b1 << 3 ) | ( b1 >> 2 );
-    }
-    else
-    {
-        br[0] = ( ( d & 0xF0000000 ) >> 24 ) | ( ( d & 0xF0000000 ) >> 28 );
-        br[1] = ( ( d & 0x0F000000 ) >> 20 ) | ( ( d & 0x0F000000 ) >> 24 );
-        bg[0] = ( ( d & 0x00F00000 ) >> 16 ) | ( ( d & 0x00F00000 ) >> 20 );
-        bg[1] = ( ( d & 0x000F0000 ) >> 12 ) | ( ( d & 0x000F0000 ) >> 16 );
-        bb[0] = ( ( d & 0x0000F000 ) >> 8  ) | ( ( d & 0x0000F000 ) >> 12 );
-        bb[1] = ( ( d & 0x00000F00 ) >> 4  ) | ( ( d & 0x00000F00 ) >> 8  );
-    }
-
-    unsigned int tcw[2];
-    tcw[0] = ( d & 0xE0 ) >> 5;
-    tcw[1] = ( d & 0x1C ) >> 2;
-
-    uint32_t b1 = ( d >> 32 ) & 0xFFFF;
-    uint32_t b2 = ( d >> 48 );
-
-    b1 = ( b1 | ( b1 << 8 ) ) & 0x00FF00FF;
-    b1 = ( b1 | ( b1 << 4 ) ) & 0x0F0F0F0F;
-    b1 = ( b1 | ( b1 << 2 ) ) & 0x33333333;
-    b1 = ( b1 | ( b1 << 1 ) ) & 0x55555555;
-
-    b2 = ( b2 | ( b2 << 8 ) ) & 0x00FF00FF;
-    b2 = ( b2 | ( b2 << 4 ) ) & 0x0F0F0F0F;
-    b2 = ( b2 | ( b2 << 2 ) ) & 0x33333333;
-    b2 = ( b2 | ( b2 << 1 ) ) & 0x55555555;
-
-    uint32_t idx = b1 | ( b2 << 1 );
-
-    const int32_t base = alpha >> 56;
-    const int32_t mul = ( alpha >> 52 ) & 0xF;
-    const auto atbl = g_alpha[( alpha >> 48 ) & 0xF];
-
-    if( d & 0x1 )
-    {
-        for( int i=0; i<4; i++ )
-        {
-            for( int j=0; j<4; j++ )
-            {
-                const auto mod = g_table[tcw[j/2]][idx & 0x3];
-                const auto r = br[j/2] + mod;
-                const auto g = bg[j/2] + mod;
-                const auto b = bb[j/2] + mod;
-                const auto amod = atbl[(alpha >> ( 45 - j*3 - i*12 )) & 0x7];
-                const uint32_t a = clampu8( base + amod * mul );
-                if( ( ( r | g | b ) & ~0xFF ) == 0 )
-                {
-                    dst[j*w+i] = r | ( g << 8 ) | ( b << 16 ) | ( a << 24 );
-                }
-                else
-                {
-                    const auto rc = clampu8( r );
-                    const auto gc = clampu8( g );
-                    const auto bc = clampu8( b );
-                    dst[j*w+i] = rc | ( gc << 8 ) | ( bc << 16 ) | ( a << 24 );
-                }
-                idx >>= 2;
-            }
-        }
-    }
-    else
-    {
-        for( int i=0; i<4; i++ )
-        {
-            const auto tbl = g_table[tcw[i/2]];
-            const auto cr = br[i/2];
-            const auto cg = bg[i/2];
-            const auto cb = bb[i/2];
-
-            for( int j=0; j<4; j++ )
-            {
-                const auto mod = tbl[idx & 0x3];
-                const auto r = cr + mod;
-                const auto g = cg + mod;
-                const auto b = cb + mod;
-                const auto amod = atbl[(alpha >> ( 45 - j*3 - i*12 )) & 0x7];
-                const uint32_t a = clampu8( base + amod * mul );
-                if( ( ( r | g | b ) & ~0xFF ) == 0 )
-                {
-                    dst[j*w+i] = r | ( g << 8 ) | ( b << 16 ) | ( a << 24 );
-                }
-                else
-                {
-                    const auto rc = clampu8( r );
-                    const auto gc = clampu8( g );
-                    const auto bc = clampu8( b );
-                    dst[j*w+i] = rc | ( gc << 8 ) | ( bc << 16 ) | ( a << 24 );
-                }
-                idx >>= 2;
-            }
-        }
-    }
-}
-
-static etcpak_force_inline void DecodeRPart( uint64_t r, uint32_t* dst, uint32_t w )
-{
-    r = _bswap64( r );
-
-    const int32_t base = ( r >> 56 )*8+4;
-    const int32_t mul = ( r >> 52 ) & 0xF;
-    const auto atbl = g_alpha[( r >> 48 ) & 0xF];
-
-    for( int i=0; i<4; i++ )
-    {
-        for ( int j=0; j<4; j++ )
-        {
-            const auto amod = atbl[(r >> ( 45 - j*3 - i*12 )) & 0x7];
-            const uint32_t rc = clampu8( ( base + amod * g_alpha11Mul[mul] )/8 );
-            dst[j*w+i] = rc | 0xFF000000;
-        }
-    }
-}
-
-static etcpak_force_inline void DecodeRGPart( uint64_t r, uint64_t g, uint32_t* dst, uint32_t w )
-{
-    r = _bswap64( r );
-    g = _bswap64( g );
-
-    const int32_t rbase = ( r >> 56 )*8+4;
-    const int32_t rmul = ( r >> 52 ) & 0xF;
-    const auto rtbl = g_alpha[( r >> 48 ) & 0xF];
-
-    const int32_t gbase = ( g >> 56 )*8+4;
-    const int32_t gmul = ( g >> 52 ) & 0xF;
-    const auto gtbl = g_alpha[( g >> 48 ) & 0xF];
-
-    for( int i=0; i<4; i++ )
-    {
-        for( int j=0; j<4; j++ )
-        {
-            const auto rmod = rtbl[(r >> ( 45 - j*3 - i*12 )) & 0x7];
-            const uint32_t rc = clampu8( ( rbase + rmod * g_alpha11Mul[rmul] )/8 );
-
-            const auto gmod = gtbl[(g >> ( 45 - j*3 - i*12 )) & 0x7];
-            const uint32_t gc = clampu8( ( gbase + gmod * g_alpha11Mul[gmul] )/8 );
-
-            dst[j*w+i] = rc | (gc << 8) | 0xFF000000;
-        }
-    }
-}
-
-// GDRE Added
-
-static const int32_t g_table_non_opaque[8][4] = {
-	{ 0, 8, 0, -8 },
-	{ 0, 17, 0, -17 },
-	{ 0, 29, 0, -29 },
-	{ 0, 42, 0, -42 },
-	{ 0, 60, 0, -60 },
-	{ 0, 80, 0, -80 },
-	{ 0, 106, 0, -106 },
-	{ 0, 183, 0, -183 }
-};
-
-static etcpak_force_inline void DecodeRGBA1Part( uint64_t d, uint32_t* dst, uint32_t w )
-{
-    d = ConvertByteOrder( d );
-
-    uint32_t br[2], bg[2], bb[2];
-    uint8_t opaque = d & 0x2;
-
-    int32_t dr, dg, db;
-
-    uint32_t r0 = ( d & 0xF8000000 ) >> 27;
-    uint32_t g0 = ( d & 0x00F80000 ) >> 19;
-    uint32_t b0 = ( d & 0x0000F800 ) >> 11;
-
-    dr = ( int32_t(d) << 5 ) >> 29;
-    dg = ( int32_t(d) << 13 ) >> 29;
-    db = ( int32_t(d) << 21 ) >> 29;
-
-    int32_t r1 = int32_t(r0) + dr;
-    int32_t g1 = int32_t(g0) + dg;
-    int32_t b1a = int32_t(b0) + db;
-
-    // T mode
-    if ( (r1 < 0) || (r1 > 31) )
-    {
-        DecodeT( d, dst, w );
-        return;
-    }
-
-    // H mode
-    if ((g1 < 0) || (g1 > 31))
-    {
-        DecodeH( d, dst, w );
-        return;
-    }
-
-    // P mode
-    if(opaque && ((b1a < 0) || (b1a > 31)))
-    {
-        DecodePlanar( d, dst, w );
-        return;
-    }
-
-    br[0] = ( r0 << 3 ) | ( r0 >> 2 );
-    br[1] = ( r1 << 3 ) | ( r1 >> 2 );
-    bg[0] = ( g0 << 3 ) | ( g0 >> 2 );
-    bg[1] = ( g1 << 3 ) | ( g1 >> 2 );
-    bb[0] = ( b0 << 3 ) | ( b0 >> 2 );
-    bb[1] = ( b1a << 3 ) | ( b1a >> 2 );
-
-    unsigned int tcw[2];
-    tcw[0] = ( d & 0xE0 ) >> 5;
-    tcw[1] = ( d & 0x1C ) >> 2;
-
-    uint32_t b1 = ( d >> 32 ) & 0xFFFF;
-    uint32_t b2 = ( d >> 48 );
-
-    b1 = ( b1 | ( b1 << 8 ) ) & 0x00FF00FF;
-    b1 = ( b1 | ( b1 << 4 ) ) & 0x0F0F0F0F;
-    b1 = ( b1 | ( b1 << 2 ) ) & 0x33333333;
-    b1 = ( b1 | ( b1 << 1 ) ) & 0x55555555;
-
-    b2 = ( b2 | ( b2 << 8 ) ) & 0x00FF00FF;
-    b2 = ( b2 | ( b2 << 4 ) ) & 0x0F0F0F0F;
-    b2 = ( b2 | ( b2 << 2 ) ) & 0x33333333;
-    b2 = ( b2 | ( b2 << 1 ) ) & 0x55555555;
-
-    uint32_t idx = b1 | ( b2 << 1 );
-
-
-    const auto table = opaque ? g_table : g_table_non_opaque;
-    if( d & 0x1 )
-    {
-        for( int i=0; i<4; i++ )
-        {
-            for( int j=0; j<4; j++ )
-            {
-                // The alpha component is decoded using the ‘opaque’-bit, which is positioned in bit 33
-                // (see Table 22.7 part (b)). If the ‘opaque’-bit is set, alpha is always 255.
-                // However, if the ‘opaque’-bit is zero, the alpha-value depends on the pixel indices;
-                // if MSB==1 and LSB==0, the alpha value will be zero, otherwise it will be 255.
-                // Finally, if the alpha value equals 0, the red, green and blue components will also be zero.
-                if ((opaque == 0 && (idx & 0x3) == 2)) {
-                    dst[j*w+i] = 0;
-                } else {
-                    const auto mod = table[tcw[j/2]][idx & 0x3];
-                    const auto r = br[j/2] + mod;
-                    const auto g = bg[j/2] + mod;
-                    const auto b = bb[j/2] + mod;
-                    if( ( ( r | g | b ) & ~0xFF ) == 0 )
-                    {
-                        dst[j*w+i] = r | ( g << 8 ) | ( b << 16 ) | 0xFF000000;
-                    }
-                    else
-                    {
-                        const auto rc = clampu8( r );
-                        const auto gc = clampu8( g );
-                        const auto bc = clampu8( b );
-                        dst[j*w+i] = rc | ( gc << 8 ) | ( bc << 16 ) | 0xFF000000;
-                    }
-                }
-                idx >>= 2;
-            }
-        }
-    }
-    else
-    {
-        for( int i=0; i<4; i++ )
-        {
-            const auto tbl = table[tcw[i/2]];
-            const auto cr = br[i/2];
-            const auto cg = bg[i/2];
-            const auto cb = bb[i/2];
-
-            for( int j=0; j<4; j++ )
-            {
-                if ((opaque == 0 && (idx & 0x3) == 2)) {
-                    dst[j*w+i] = 0;
-                } else {
-                    const auto mod = tbl[idx & 0x3];
-                    const auto r = cr + mod;
-                    const auto g = cg + mod;
-                    const auto b = cb + mod;
-                    if( ( ( r | g | b ) & ~0xFF ) == 0 )
-                    {
-                        dst[j*w+i] = r | ( g << 8 ) | ( b << 16 ) | 0xFF000000;
-                    }
-                    else
-                    {
-                        const auto rc = clampu8( r );
-                        const auto gc = clampu8( g );
-                        const auto bc = clampu8( b );
-                        dst[j*w+i] = rc | ( gc << 8 ) | ( bc << 16 ) | 0xFF000000;
-                    }
-                }
-                idx >>= 2;
-            }
-        }
-    }
-}
-
-static etcpak_force_inline void DecodeRSignedPart( uint64_t r, uint32_t* dst, uint32_t w )
-{
-    r = _bswap64( r );
-
-    // Excerpted from section 22.7 Format Signed R11 EAC:
-    // The base codeword is stored in the first 8 bits as shown in Table 22.5 part (a). It is a two’s-complement value in the range
-    // [-127, 127], and where the value -128 is not allowed; however, if it should occur anyway it must be treated as -127.
-    // The base codeword is then multiplied by 8 by shifting it left three steps.
-    //
-    // This is the only difference between the signed and unsigned R11 EAC formats.
-    const int32_t base = (((int8_t)( r >> 56 )) <= -128 ? -127 : ((int8_t)( r >> 56 ))) * 8;
-    const int32_t mul = ( r >> 52 ) & 0xF;
-    const auto atbl = g_alpha[( r >> 48 ) & 0xF];
-
-    for( int i=0; i<4; i++ )
-    {
-        for ( int j=0; j<4; j++ )
-        {
-            const auto amod = atbl[(r >> ( 45 - j*3 - i*12 )) & 0x7];
-            const uint32_t rc = clampu8( ( base + amod * g_alpha11Mul[mul] )/8 );
-            dst[j*w+i] = rc | 0xFF000000;
-        }
-    }
-}
-
-static etcpak_force_inline void DecodeRGSignedPart( uint64_t r, uint64_t g, uint32_t* dst, uint32_t w )
-{
-    r = _bswap64( r );
-    g = _bswap64( g );
-
-    // Both 64-bit integers are decoded in the same way as signed R11 EAC described in Section 22.7
-    const int32_t rbase = (((int8_t)( r >> 56 )) <= -128 ? -127 : ((int8_t)( r >> 56 ))) * 8;
-    const int32_t rmul = ( r >> 52 ) & 0xF;
-    const auto rtbl = g_alpha[( r >> 48 ) & 0xF];
-
-    const int32_t gbase = (((int8_t)( g >> 56 )) <= -128 ? -127 : ((int8_t)( g >> 56 ))) * 8;
-    const int32_t gmul = ( g >> 52 ) & 0xF;
-    const auto gtbl = g_alpha[( g >> 48 ) & 0xF];
-
-    for( int i=0; i<4; i++ )
-    {
-        for( int j=0; j<4; j++ )
-        {
-            const auto rmod = rtbl[(r >> ( 45 - j*3 - i*12 )) & 0x7];
-            const uint32_t rc = clampu8( ( rbase + rmod * g_alpha11Mul[rmul] )/8 );
-
-            const auto gmod = gtbl[(g >> ( 45 - j*3 - i*12 )) & 0x7];
-            const uint32_t gc = clampu8( ( gbase + gmod * g_alpha11Mul[gmul] )/8 );
-
-            dst[j*w+i] = rc | (gc << 8) | 0xFF000000;
-        }
-    }
-}
-
-void etcpak_decompress::decompress_image(EtcFormat format, const void *dsrc, void *ddst, const uint64_t width, const uint64_t height, const int64_t total_size) {
-	const uint64_t *src = (const uint64_t *)(dsrc);
-	uint32_t *dst = (uint32_t *)ddst;
-
-	switch (format) {
-		case EtcFormat::Etc1:
-		case EtcFormat::Etc2_RGB: {
-			for (uint64_t y = 0; y < height / 4; y++) {
-				for (uint64_t x = 0; x < width / 4; x++) {
-					uint64_t d = *src++;
-					DecodeRGBPart(d, dst, width);
-					dst += 4;
-				}
-				dst += width * 3;
-			}
-		} break;
-        case EtcFormat::Etc2_RGBA1: {
-			for (uint64_t y = 0; y < height / 4; y++) {
-				for (uint64_t x = 0; x < width / 4; x++) {
-					uint64_t d = *src++;
-					DecodeRGBA1Part(d, dst, width);
-					dst += 4;
-				}
-				dst += width * 3;
-			}
-		} break;
-		case EtcFormat::Etc2_RGBA: {
-			for (uint64_t y = 0; y < height / 4; y++) {
-				for (uint64_t x = 0; x < width / 4; x++) {
-					uint64_t a = *src++;
-					uint64_t d = *src++;
-					DecodeRGBAPart(d, a, dst, width);
-					dst += 4;
-				}
-				dst += width * 3;
-			}
-
-		} break;
-		case EtcFormat::Etc2_R11: {
-			for (uint64_t y = 0; y < height / 4; y++) {
-				for (uint64_t x = 0; x < width / 4; x++) {
-					uint64_t r = *src++;
-					DecodeRPart(r, dst, width);
-					dst += 4;
-				}
-				dst += width * 3;
-			}
-		} break;
-        case EtcFormat::Etc2_R11S: {
-			for (uint64_t y = 0; y < height / 4; y++) {
-				for (uint64_t x = 0; x < width / 4; x++) {
-					uint64_t r = *src++;
-					DecodeRSignedPart(r, dst, width);
-					dst += 4;
-				}
-				dst += width * 3;
-			}
-		} break;
-
-		case EtcFormat::Etc2_RG11: {
-			for (uint64_t y = 0; y < height / 4; y++) {
-				for (uint64_t x = 0; x < width / 4; x++) {
-					uint64_t r = *src++;
-					uint64_t g = *src++;
-					DecodeRGPart(r, g, dst, width);
-					dst += 4;
-				}
-				dst += width * 3;
-			}
-		} break;
-        case EtcFormat::Etc2_RG11S: {
-			for (uint64_t y = 0; y < height / 4; y++) {
-				for (uint64_t x = 0; x < width / 4; x++) {
-					uint64_t r = *src++;
-					uint64_t g = *src++;
-					DecodeRGSignedPart(r, g, dst, width);
-					dst += 4;
-				}
-				dst += width * 3;
-			}
-		} break;
-
-	}
-}
diff --git a/external/etcpak-decompress/BlockData.hpp b/external/etcpak-decompress/BlockData.hpp
deleted file mode 100644
index 2adee327..00000000
--- a/external/etcpak-decompress/BlockData.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-// #ifndef __BLOCKDATA_HPP__
-// #define __BLOCKDATA_HPP__
-
-// #include <condition_variable>
-// #include <future>
-// #include <memory>
-// #include <mutex>
-// #include <stdint.h>
-// #include <stdio.h>
-// #include <vector>
-
-// #include "Bitmap.hpp"
-// #include "ForceInline.hpp"
-// #include "Vector.hpp"
-
-// struct bc7enc_compress_block_params;
-
-// class BlockData
-// {
-// public:
-//     enum Type
-//     {
-//         Etc1,
-//         Etc2_RGB,
-//         Etc2_RGBA,
-//         Etc2_R11,
-//         Etc2_RG11,
-//         Bc1,
-//         Bc3,
-//         Bc4,
-//         Bc5,
-//         Bc7
-//     };
-
-//     enum Format
-//     {
-//         Pvr,
-//         Dds
-//     };
-
-//     BlockData( const char* fn );
-//     BlockData( const char* fn, const v2i& size, bool mipmap, Type type, Format format );
-//     BlockData( const v2i& size, bool mipmap, Type type );
-//     ~BlockData();
-
-//     BitmapPtr Decode();
-
-//     void Process( const uint32_t* src, uint32_t blocks, size_t offset, size_t width, bool dither, bool useHeuristics );
-//     void ProcessRGBA( const uint32_t* src, uint32_t blocks, size_t offset, size_t width, bool useHeuristics, const bc7enc_compress_block_params* params );
-
-//     const v2i& Size() const { return m_size; }
-
-// private:
-//     etcpak_no_inline BitmapPtr DecodeRGB();
-//     etcpak_no_inline BitmapPtr DecodeRGBA();
-//     etcpak_no_inline BitmapPtr DecodeR();
-//     etcpak_no_inline BitmapPtr DecodeRG();
-//     etcpak_no_inline BitmapPtr DecodeBc1();
-//     etcpak_no_inline BitmapPtr DecodeBc3();
-//     etcpak_no_inline BitmapPtr DecodeBc4();
-//     etcpak_no_inline BitmapPtr DecodeBc5();
-//     etcpak_no_inline BitmapPtr DecodeBc7();
-
-//     uint8_t* m_data;
-//     v2i m_size;
-//     size_t m_dataOffset;
-//     FILE* m_file;
-//     size_t m_maplen;
-//     Type m_type;
-// };
-
-// typedef std::shared_ptr<BlockData> BlockDataPtr;
-
-
-
-// #endif
-
-#pragma once
-#include <cstdint>
-#include "etc_format.h"
-namespace etcpak_decompress{
-void decompress_image(EtcFormat format, const void *dsrc, void *ddst, const uint64_t width, const uint64_t height, const int64_t total_size);
-}; // namespace etcpak_decompress
\ No newline at end of file
diff --git a/external/etcpak-decompress/etc_format.h b/external/etcpak-decompress/etc_format.h
deleted file mode 100644
index 03265e3c..00000000
--- a/external/etcpak-decompress/etc_format.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-
-enum EtcFormat {
-	Etc1,
-	Etc2_RGB,
-	Etc2_RGBA,
-	Etc2_RGBA1,
-	Etc2_R11,
-	Etc2_R11S,
-	Etc2_RG11,
-	Etc2_RG11S
-};
diff --git a/godot-mono-decomp/GodotMonoDecomp/ProjectFileWriterGodotStyle.cs b/godot-mono-decomp/GodotMonoDecomp/ProjectFileWriterGodotStyle.cs
index 46d07a30..20c16aae 100644
--- a/godot-mono-decomp/GodotMonoDecomp/ProjectFileWriterGodotStyle.cs
+++ b/godot-mono-decomp/GodotMonoDecomp/ProjectFileWriterGodotStyle.cs
@@ -584,6 +584,8 @@ static void WriteEmbeddedResourceExcludes(XmlTextWriter xml, HashSet<string> exc
 		static void WriteReferences(XmlTextWriter xml, MetadataFile module, IProjectInfoProvider project,
 			ProjectType projectType, DotNetCoreDepInfo? deps, GodotMonoDecompSettings settings)
 		{
+			string copyToDir = Path.Combine(project.TargetDirectory, "_mono_referenced_assemblies");
+			// hashset of copied assemblies
 			bool isNetCoreApp = TargetServices.DetectTargetFramework(module).Identifier == ".NETCoreApp";
 			var targetPacks = new HashSet<string>();
 			if (isNetCoreApp)
@@ -686,21 +688,7 @@ bool DepExistsInPackages(AssemblyReference reference)
 
 			string GetNewRefOutputPath(string path)
 			{
-				string monoPart;
-				if (path.Contains("/.mono"))
-				{
-					// get the part of the path that begins with ".mono"
-					monoPart = path.Substring(path.IndexOf("/.mono") + 1);
-					// copy the file to the output directory
-				}
-				else if (path.Contains("\\.mono")) {
-					monoPart = path.Substring(path.IndexOf("\\.mono") + 1);
-				}
-				else
-				{
-					monoPart = Path.Combine(".mono", "referenced_assemblies", Path.GetFileName(path));
-				}
-				return Path.Combine(project.TargetDirectory, monoPart);
+				return Path.Combine(copyToDir, Path.GetFileName(path));
 			}
 
 			void CopyRef(MetadataFile asembly, string outputPath)
@@ -711,31 +699,46 @@ void CopyRef(MetadataFile asembly, string outputPath)
 					return;
 				}
 
-				// if it already exists, we don't need to copy it
-				if (!File.Exists(outputPath)) {
-					try
-					{
-						_ = Directory.CreateDirectory(Path.GetDirectoryName(outputPath) ?? "");
-					}
-					catch (Exception e)
-					{
-						Console.Error.WriteLine($"Error creating directory {Path.GetDirectoryName(outputPath)}: {e.Message}");
-					}
-					// copy the file to the output directory
+				try
+				{
+					_ = Directory.CreateDirectory(Path.GetDirectoryName(outputPath) ?? "");
+				}
+				catch (Exception e)
+				{
+					Console.Error.WriteLine($"Error creating directory {Path.GetDirectoryName(outputPath)}: {e.Message}");
+				}
+				// copy the file to the output directory
+				try
+				{
+					File.Copy(asembly.FileName, outputPath, true);
+				}
+				catch (Exception e)
+				{
+					Console.Error.WriteLine($"Error copying file {asembly.FileName} to {outputPath}: {e.Message}");
+				}
+
+				// create an empty file named ".gdignore" in the mono directory
+				if (!File.Exists(Path.Combine(copyToDir, ".gdignore")))
+				{
 					try
 					{
-						File.Copy(asembly.FileName, outputPath, true);
+						if (!Directory.Exists(copyToDir))
+						{
+							Directory.CreateDirectory(copyToDir);
+						}
+						File.Create(Path.Combine(copyToDir, ".gdignore")).Close();
 					}
 					catch (Exception e)
 					{
-						Console.Error.WriteLine($"Error copying file {asembly.FileName} to {outputPath}: {e.Message}");
+						Console.Error.WriteLine($"Error creating .gdignore file in {copyToDir}: {e.Message}");
 					}
-					// use the relative path to the output directory
 				}
+
+				// use the relative path to the output directory
 				// check if a pdb exists at the original path
 				var pdbPath = Path.ChangeExtension(asembly.FileName, ".pdb");
 				var pdbOutputPath = Path.ChangeExtension(outputPath, ".pdb");
-				if (File.Exists(pdbPath) && !File.Exists(pdbOutputPath))
+				if (File.Exists(pdbPath))
 				{
 					// copy the pdb file to the output directory
 					try
diff --git a/module_etc_decompress/image_decompress_etcpak.cpp b/module_etc_decompress/image_decompress_etcpak.cpp
deleted file mode 100644
index f9f52884..00000000
--- a/module_etc_decompress/image_decompress_etcpak.cpp
+++ /dev/null
@@ -1,139 +0,0 @@
-/**************************************************************************/
-/*  image_decompress_etcpak.cpp                                            */
-/**************************************************************************/
-/*                         This file is part of:                          */
-/*                             GODOT ENGINE                               */
-/*                        https://godotengine.org                         */
-/**************************************************************************/
-/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
-/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
-/*                                                                        */
-/* Permission is hereby granted, free of charge, to any person obtaining  */
-/* a copy of this software and associated documentation files (the        */
-/* "Software"), to deal in the Software without restriction, including    */
-/* without limitation the rights to use, copy, modify, merge, publish,    */
-/* distribute, sublicense, and/or sell copies of the Software, and to     */
-/* permit persons to whom the Software is furnished to do so, subject to  */
-/* the following conditions:                                              */
-/*                                                                        */
-/* The above copyright notice and this permission notice shall be         */
-/* included in all copies or substantial portions of the Software.        */
-/*                                                                        */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
-/**************************************************************************/
-
-#include "image_decompress_etcpak.h"
-
-#include "external/etcpak-decompress/BlockData.hpp"
-
-#include "core/os/os.h"
-#include "core/string/print_string.h"
-
-void image_decompress_etc(Image *p_image) {
-	uint64_t start_time = OS::get_singleton()->get_ticks_msec();
-
-	int width = p_image->get_width();
-	int height = p_image->get_height();
-
-	// Compressed images' dimensions should be padded to the upper multiple of 4.
-	// If they aren't, they need to be realigned (the actual data is correctly padded though).
-	if (width % 4 != 0 || height % 4 != 0) {
-		int new_width = width + (4 - (width % 4));
-		int new_height = height + (4 - (height % 4));
-
-		print_verbose(vformat("Compressed image's dimensions are not multiples of 4 (%dx%d), aligning to (%dx%d)", width, height, new_width, new_height));
-
-		width = new_width;
-		height = new_height;
-	}
-
-	Image::Format source_format = p_image->get_format();
-	Image::Format target_format = Image::FORMAT_MAX;
-
-	EtcFormat bcdec_format = EtcFormat::Etc1;
-
-	switch (source_format) {
-		case Image::FORMAT_ETC: {
-			bcdec_format = EtcFormat::Etc1;
-			target_format = Image::FORMAT_RGB8;
-		} break;
-		case Image::FORMAT_ETC2_RGB8: {
-			bcdec_format = EtcFormat::Etc2_RGB;
-			target_format = Image::FORMAT_RGB8;
-		} break;
-		case Image::FORMAT_ETC2_RA_AS_RG:
-		case Image::FORMAT_ETC2_RGBA8: {
-			bcdec_format = EtcFormat::Etc2_RGBA;
-			target_format = Image::FORMAT_RGBA8;
-		} break;
-		case Image::FORMAT_ETC2_R11: {
-			bcdec_format = EtcFormat::Etc2_R11;
-			target_format = Image::FORMAT_RGBA8;
-		} break;
-		case Image::FORMAT_ETC2_RG11: {
-			bcdec_format = EtcFormat::Etc2_RG11;
-			target_format = Image::FORMAT_RGBA8;
-		} break;
-		case Image::FORMAT_ETC2_R11S: {
-			bcdec_format = EtcFormat::Etc2_R11S;
-			target_format = Image::FORMAT_RGBA8;
-		} break;
-		case Image::FORMAT_ETC2_RG11S: {
-			bcdec_format = EtcFormat::Etc2_RG11S;
-			target_format = Image::FORMAT_RGBA8;
-		} break;
-		case Image::FORMAT_ETC2_RGB8A1: {
-			bcdec_format = EtcFormat::Etc2_RGBA1;
-			target_format = Image::FORMAT_RGBA8;
-		} break;
-
-		default:
-			ERR_FAIL_MSG("etcpak-decompress: Can't decompress unsupported format: " + Image::get_format_name(source_format) + ".");
-			break;
-	}
-
-	int mm_count = p_image->get_mipmap_count();
-	// the decoders always output RGBA8; we need to convert after the fact if it's RGB8
-	constexpr const Image::Format start_format = Image::FORMAT_RGBA8;
-	int64_t target_size = Image::get_image_data_size(width, height, start_format, p_image->has_mipmaps());
-
-	// Decompressed data.
-	Vector<uint8_t> data;
-	data.resize(target_size);
-	uint8_t *wb = data.ptrw();
-
-	// Source data.
-	const uint8_t *rb = p_image->get_data().ptr();
-
-	// Decompress mipmaps.
-	for (int i = 0; i <= mm_count; i++) {
-		int mipmap_w = 0, mipmap_h = 0;
-		int64_t src_ofs = Image::get_image_mipmap_offset_and_dimensions(width, height, source_format, i, mipmap_w, mipmap_h);
-		int64_t dst_ofs = Image::get_image_mipmap_offset(width, height, start_format, i);
-		etcpak_decompress::decompress_image(bcdec_format, rb + src_ofs, wb + dst_ofs, mipmap_w, mipmap_h, target_size);
-		// if (total_dest_written != target_size) {
-		// 	ERR_FAIL_MSG("etcpak-decompress: Decompression failed.");
-		// }
-	}
-
-	p_image->set_data(width, height, p_image->has_mipmaps(), start_format, data);
-
-	// convert to RGB8 if needed.
-	if (target_format == Image::FORMAT_RGB8) {
-		p_image->convert(Image::FORMAT_RGB8);
-	}
-
-	// Swap channels if the format is using a channel swizzle.
-	if (source_format == Image::FORMAT_ETC2_RA_AS_RG) {
-		p_image->convert_ra_rgba8_to_rg();
-	}
-
-	print_verbose(vformat("etcpak: Decompression of a %dx%d %s image with %d mipmaps took %d ms.",
-			p_image->get_width(), p_image->get_height(), Image::get_format_name(source_format), p_image->get_mipmap_count(), OS::get_singleton()->get_ticks_msec() - start_time));
-}
diff --git a/module_etc_decompress/image_decompress_etcpak.h b/module_etc_decompress/image_decompress_etcpak.h
deleted file mode 100644
index 66e8e080..00000000
--- a/module_etc_decompress/image_decompress_etcpak.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/**************************************************************************/
-/*  image_decompress_etcpak.h                                              */
-/**************************************************************************/
-/*                         This file is part of:                          */
-/*                             GODOT ENGINE                               */
-/*                        https://godotengine.org                         */
-/**************************************************************************/
-/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
-/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
-/*                                                                        */
-/* Permission is hereby granted, free of charge, to any person obtaining  */
-/* a copy of this software and associated documentation files (the        */
-/* "Software"), to deal in the Software without restriction, including    */
-/* without limitation the rights to use, copy, modify, merge, publish,    */
-/* distribute, sublicense, and/or sell copies of the Software, and to     */
-/* permit persons to whom the Software is furnished to do so, subject to  */
-/* the following conditions:                                              */
-/*                                                                        */
-/* The above copyright notice and this permission notice shall be         */
-/* included in all copies or substantial portions of the Software.        */
-/*                                                                        */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
-/**************************************************************************/
-
-#ifndef IMAGE_DECOMPRESS_ETCPAK_H
-#define IMAGE_DECOMPRESS_ETCPAK_H
-
-#include "core/io/image.h"
-
-void image_decompress_etc(Image *p_image);
-
-#endif // IMAGE_DECOMPRESS_ETCPAK_H
diff --git a/module_etc_decompress/register_types.cpp b/module_etc_decompress/register_types.cpp
deleted file mode 100644
index 84dd95df..00000000
--- a/module_etc_decompress/register_types.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-#include "register_types.h"
-
-#include "image_decompress_etcpak.h"
-
-#include "core/io/image.h"
-
-void initialize_etcpak_decompress_module(ModuleInitializationLevel p_level) {
-	if (p_level != MODULE_INITIALIZATION_LEVEL_SCENE) {
-		return;
-	}
-	Image::_image_decompress_etc1 = image_decompress_etc;
-	Image::_image_decompress_etc2 = image_decompress_etc;
-}
-
-void uninitialize_etcpak_decompress_module(ModuleInitializationLevel p_level) {
-	Image::_image_decompress_etc1 = nullptr;
-	Image::_image_decompress_etc2 = nullptr;
-}
\ No newline at end of file
diff --git a/module_etc_decompress/register_types.h b/module_etc_decompress/register_types.h
deleted file mode 100644
index ec2637fa..00000000
--- a/module_etc_decompress/register_types.h
+++ /dev/null
@@ -1,11 +0,0 @@
-/*************************************************************************/
-/*  register_types.h                                                     */
-/*************************************************************************/
-
-#pragma once
-#include "modules/register_module_types.h"
-
-void initialize_etcpak_decompress_module(ModuleInitializationLevel p_level);
-void uninitialize_etcpak_decompress_module(ModuleInitializationLevel p_level);
-void init_ver_regex();
-void free_ver_regex();
diff --git a/register_types.cpp b/register_types.cpp
index cc0b4a51..09c06333 100644
--- a/register_types.cpp
+++ b/register_types.cpp
@@ -73,8 +73,6 @@
 #include "utility/pck_dumper.h"
 #include "utility/task_manager.h"
 
-#include "module_etc_decompress/register_types.h"
-
 #ifdef TOOLS_ENABLED
 void gdsdecomp_init_callback() {
 	EditorNode *editor = EditorNode::get_singleton();
@@ -524,7 +522,6 @@ void initialize_gdsdecomp_module(ModuleInitializationLevel p_level) {
 #endif
 	init_loaders();
 	init_exporters();
-	initialize_etcpak_decompress_module(p_level);
 
 	// Register ICO image loader
 	ico_loader.instantiate();
@@ -535,7 +532,6 @@ void uninitialize_gdsdecomp_module(ModuleInitializationLevel p_level) {
 	if (p_level != MODULE_INITIALIZATION_LEVEL_SCENE) {
 		return;
 	}
-	uninitialize_etcpak_decompress_module(p_level);
 	if (ico_loader.is_valid()) {
 		ImageLoader::remove_image_format_loader(ico_loader);
 		ico_loader.unref();
diff --git a/standalone/gdre_icons/gdre_File.svg.import b/standalone/gdre_icons/gdre_File.svg.import
index 70b4b8e9..23ce45bf 100644
--- a/standalone/gdre_icons/gdre_File.svg.import
+++ b/standalone/gdre_icons/gdre_File.svg.import
@@ -1,43 +1,18 @@
 [remap]
 
-importer="texture"
-type="CompressedTexture2D"
+importer="svg"
+type="DPITexture"
 uid="uid://blinaucesmvhv"
-path="res://.godot/imported/gdre_File.svg-2a8ee674ab13ea3c8b688fd221f5e1f4.ctex"
-metadata={
-"vram_texture": false
-}
+path="res://.godot/imported/gdre_File.svg-2a8ee674ab13ea3c8b688fd221f5e1f4.dpitex"
 
 [deps]
 
 source_file="res://gdre_icons/gdre_File.svg"
-dest_files=["res://.godot/imported/gdre_File.svg-2a8ee674ab13ea3c8b688fd221f5e1f4.ctex"]
+dest_files=["res://.godot/imported/gdre_File.svg-2a8ee674ab13ea3c8b688fd221f5e1f4.dpitex"]
 
 [params]
 
-compress/mode=0
-compress/high_quality=false
-compress/lossy_quality=0.7
-compress/uastc_level=0
-compress/rdo_quality_loss=0.0
-compress/hdr_compression=1
-compress/normal_map=0
-compress/channel_pack=0
-mipmaps/generate=false
-mipmaps/limit=-1
-roughness/mode=0
-roughness/src_normal=""
-process/channel_remap/red=0
-process/channel_remap/green=1
-process/channel_remap/blue=2
-process/channel_remap/alpha=3
-process/fix_alpha_border=true
-process/premult_alpha=false
-process/normal_map_invert_y=false
-process/hdr_as_srgb=false
-process/hdr_clamp_exposure=false
-process/size_limit=0
-detect_3d/compress_to=1
-svg/scale=1.0
-editor/scale_with_editor_scale=false
-editor/convert_colors_with_editor_theme=false
+base_scale=1.0
+saturation=1.0
+color_map={}
+compress=true
diff --git a/standalone/gdre_icons/gdre_FileBroken.svg.import b/standalone/gdre_icons/gdre_FileBroken.svg.import
index 1e545dbf..484cff7a 100644
--- a/standalone/gdre_icons/gdre_FileBroken.svg.import
+++ b/standalone/gdre_icons/gdre_FileBroken.svg.import
@@ -1,43 +1,18 @@
 [remap]
 
-importer="texture"
-type="CompressedTexture2D"
+importer="svg"
+type="DPITexture"
 uid="uid://24tpf4ndjyht"
-path="res://.godot/imported/gdre_FileBroken.svg-47f2470a73614cd1e3f592d93dd1274d.ctex"
-metadata={
-"vram_texture": false
-}
+path="res://.godot/imported/gdre_FileBroken.svg-47f2470a73614cd1e3f592d93dd1274d.dpitex"
 
 [deps]
 
 source_file="res://gdre_icons/gdre_FileBroken.svg"
-dest_files=["res://.godot/imported/gdre_FileBroken.svg-47f2470a73614cd1e3f592d93dd1274d.ctex"]
+dest_files=["res://.godot/imported/gdre_FileBroken.svg-47f2470a73614cd1e3f592d93dd1274d.dpitex"]
 
 [params]
 
-compress/mode=0
-compress/high_quality=false
-compress/lossy_quality=0.7
-compress/uastc_level=0
-compress/rdo_quality_loss=0.0
-compress/hdr_compression=1
-compress/normal_map=0
-compress/channel_pack=0
-mipmaps/generate=false
-mipmaps/limit=-1
-roughness/mode=0
-roughness/src_normal=""
-process/channel_remap/red=0
-process/channel_remap/green=1
-process/channel_remap/blue=2
-process/channel_remap/alpha=3
-process/fix_alpha_border=true
-process/premult_alpha=false
-process/normal_map_invert_y=false
-process/hdr_as_srgb=false
-process/hdr_clamp_exposure=false
-process/size_limit=0
-detect_3d/compress_to=1
-svg/scale=1.0
-editor/scale_with_editor_scale=false
-editor/convert_colors_with_editor_theme=false
+base_scale=1.0
+saturation=1.0
+color_map={}
+compress=true
diff --git a/standalone/gdre_icons/gdre_FileBrowse.svg.import b/standalone/gdre_icons/gdre_FileBrowse.svg.import
index 50dac283..fddcba11 100644
--- a/standalone/gdre_icons/gdre_FileBrowse.svg.import
+++ b/standalone/gdre_icons/gdre_FileBrowse.svg.import
@@ -1,43 +1,18 @@
 [remap]
 
-importer="texture"
-type="CompressedTexture2D"
+importer="svg"
+type="DPITexture"
 uid="uid://bwbdnwnpkyycv"
-path="res://.godot/imported/gdre_FileBrowse.svg-85768795b621c9574e535334df57a501.ctex"
-metadata={
-"vram_texture": false
-}
+path="res://.godot/imported/gdre_FileBrowse.svg-85768795b621c9574e535334df57a501.dpitex"
 
 [deps]
 
 source_file="res://gdre_icons/gdre_FileBrowse.svg"
-dest_files=["res://.godot/imported/gdre_FileBrowse.svg-85768795b621c9574e535334df57a501.ctex"]
+dest_files=["res://.godot/imported/gdre_FileBrowse.svg-85768795b621c9574e535334df57a501.dpitex"]
 
 [params]
 
-compress/mode=0
-compress/high_quality=false
-compress/lossy_quality=0.7
-compress/uastc_level=0
-compress/rdo_quality_loss=0.0
-compress/hdr_compression=1
-compress/normal_map=0
-compress/channel_pack=0
-mipmaps/generate=false
-mipmaps/limit=-1
-roughness/mode=0
-roughness/src_normal=""
-process/channel_remap/red=0
-process/channel_remap/green=1
-process/channel_remap/blue=2
-process/channel_remap/alpha=3
-process/fix_alpha_border=true
-process/premult_alpha=false
-process/normal_map_invert_y=false
-process/hdr_as_srgb=false
-process/hdr_clamp_exposure=false
-process/size_limit=0
-detect_3d/compress_to=1
-svg/scale=1.0
-editor/scale_with_editor_scale=false
-editor/convert_colors_with_editor_theme=false
+base_scale=1.0
+saturation=1.0
+color_map={}
+compress=true
diff --git a/standalone/gdre_icons/gdre_FileEncrypted.svg.import b/standalone/gdre_icons/gdre_FileEncrypted.svg.import
index bdf70187..1da078fd 100644
--- a/standalone/gdre_icons/gdre_FileEncrypted.svg.import
+++ b/standalone/gdre_icons/gdre_FileEncrypted.svg.import
@@ -1,43 +1,18 @@
 [remap]
 
-importer="texture"
-type="CompressedTexture2D"
+importer="svg"
+type="DPITexture"
 uid="uid://bwafctgjs64to"
-path="res://.godot/imported/gdre_FileEncrypted.svg-8fc6ab154ff862f14557ffb68af80e04.ctex"
-metadata={
-"vram_texture": false
-}
+path="res://.godot/imported/gdre_FileEncrypted.svg-8fc6ab154ff862f14557ffb68af80e04.dpitex"
 
 [deps]
 
 source_file="res://gdre_icons/gdre_FileEncrypted.svg"
-dest_files=["res://.godot/imported/gdre_FileEncrypted.svg-8fc6ab154ff862f14557ffb68af80e04.ctex"]
+dest_files=["res://.godot/imported/gdre_FileEncrypted.svg-8fc6ab154ff862f14557ffb68af80e04.dpitex"]
 
 [params]
 
-compress/mode=0
-compress/high_quality=false
-compress/lossy_quality=0.7
-compress/uastc_level=0
-compress/rdo_quality_loss=0.0
-compress/hdr_compression=1
-compress/normal_map=0
-compress/channel_pack=0
-mipmaps/generate=false
-mipmaps/limit=-1
-roughness/mode=0
-roughness/src_normal=""
-process/channel_remap/red=0
-process/channel_remap/green=1
-process/channel_remap/blue=2
-process/channel_remap/alpha=3
-process/fix_alpha_border=true
-process/premult_alpha=false
-process/normal_map_invert_y=false
-process/hdr_as_srgb=false
-process/hdr_clamp_exposure=false
-process/size_limit=0
-detect_3d/compress_to=1
-svg/scale=1.0
-editor/scale_with_editor_scale=false
-editor/convert_colors_with_editor_theme=false
+base_scale=1.0
+saturation=1.0
+color_map={}
+compress=true
diff --git a/standalone/gdre_icons/gdre_FileOk.svg.import b/standalone/gdre_icons/gdre_FileOk.svg.import
index 415c35d9..a6f9cf36 100644
--- a/standalone/gdre_icons/gdre_FileOk.svg.import
+++ b/standalone/gdre_icons/gdre_FileOk.svg.import
@@ -1,43 +1,18 @@
 [remap]
 
-importer="texture"
-type="CompressedTexture2D"
+importer="svg"
+type="DPITexture"
 uid="uid://dviqasxa25kve"
-path="res://.godot/imported/gdre_FileOk.svg-6aa8e831f296fcecee3ec7b00dac9ed7.ctex"
-metadata={
-"vram_texture": false
-}
+path="res://.godot/imported/gdre_FileOk.svg-6aa8e831f296fcecee3ec7b00dac9ed7.dpitex"
 
 [deps]
 
 source_file="res://gdre_icons/gdre_FileOk.svg"
-dest_files=["res://.godot/imported/gdre_FileOk.svg-6aa8e831f296fcecee3ec7b00dac9ed7.ctex"]
+dest_files=["res://.godot/imported/gdre_FileOk.svg-6aa8e831f296fcecee3ec7b00dac9ed7.dpitex"]
 
 [params]
 
-compress/mode=0
-compress/high_quality=false
-compress/lossy_quality=0.7
-compress/uastc_level=0
-compress/rdo_quality_loss=0.0
-compress/hdr_compression=1
-compress/normal_map=0
-compress/channel_pack=0
-mipmaps/generate=false
-mipmaps/limit=-1
-roughness/mode=0
-roughness/src_normal=""
-process/channel_remap/red=0
-process/channel_remap/green=1
-process/channel_remap/blue=2
-process/channel_remap/alpha=3
-process/fix_alpha_border=true
-process/premult_alpha=false
-process/normal_map_invert_y=false
-process/hdr_as_srgb=false
-process/hdr_clamp_exposure=false
-process/size_limit=0
-detect_3d/compress_to=1
-svg/scale=1.0
-editor/scale_with_editor_scale=false
-editor/convert_colors_with_editor_theme=false
+base_scale=1.0
+saturation=1.0
+color_map={}
+compress=true
diff --git a/standalone/gdre_icons/gdre_FileWarning.svg.import b/standalone/gdre_icons/gdre_FileWarning.svg.import
index 5b6e16c2..c107bcc8 100644
--- a/standalone/gdre_icons/gdre_FileWarning.svg.import
+++ b/standalone/gdre_icons/gdre_FileWarning.svg.import
@@ -1,43 +1,18 @@
 [remap]
 
-importer="texture"
-type="CompressedTexture2D"
+importer="svg"
+type="DPITexture"
 uid="uid://cbo6qqwfetwm4"
-path="res://.godot/imported/gdre_FileWarning.svg-2689194bc355c9e337ec3d853a63d6d0.ctex"
-metadata={
-"vram_texture": false
-}
+path="res://.godot/imported/gdre_FileWarning.svg-2689194bc355c9e337ec3d853a63d6d0.dpitex"
 
 [deps]
 
 source_file="res://gdre_icons/gdre_FileWarning.svg"
-dest_files=["res://.godot/imported/gdre_FileWarning.svg-2689194bc355c9e337ec3d853a63d6d0.ctex"]
+dest_files=["res://.godot/imported/gdre_FileWarning.svg-2689194bc355c9e337ec3d853a63d6d0.dpitex"]
 
 [params]
 
-compress/mode=0
-compress/high_quality=false
-compress/lossy_quality=0.7
-compress/uastc_level=0
-compress/rdo_quality_loss=0.0
-compress/hdr_compression=1
-compress/normal_map=0
-compress/channel_pack=0
-mipmaps/generate=false
-mipmaps/limit=-1
-roughness/mode=0
-roughness/src_normal=""
-process/channel_remap/red=0
-process/channel_remap/green=1
-process/channel_remap/blue=2
-process/channel_remap/alpha=3
-process/fix_alpha_border=true
-process/premult_alpha=false
-process/normal_map_invert_y=false
-process/hdr_as_srgb=false
-process/hdr_clamp_exposure=false
-process/size_limit=0
-detect_3d/compress_to=1
-svg/scale=1.0
-editor/scale_with_editor_scale=false
-editor/convert_colors_with_editor_theme=false
+base_scale=1.0
+saturation=1.0
+color_map={}
+compress=true
diff --git a/standalone/gdre_icons/gdre_GuiTabMenuHl.svg.import b/standalone/gdre_icons/gdre_GuiTabMenuHl.svg.import
index d39eb750..58d6bebc 100644
--- a/standalone/gdre_icons/gdre_GuiTabMenuHl.svg.import
+++ b/standalone/gdre_icons/gdre_GuiTabMenuHl.svg.import
@@ -1,43 +1,18 @@
 [remap]
 
-importer="texture"
-type="CompressedTexture2D"
+importer="svg"
+type="DPITexture"
 uid="uid://70wmkccoq7gp"
-path="res://.godot/imported/gdre_GuiTabMenuHl.svg-6ed85db88d8026812387151d3cfba891.ctex"
-metadata={
-"vram_texture": false
-}
+path="res://.godot/imported/gdre_GuiTabMenuHl.svg-6ed85db88d8026812387151d3cfba891.dpitex"
 
 [deps]
 
 source_file="res://gdre_icons/gdre_GuiTabMenuHl.svg"
-dest_files=["res://.godot/imported/gdre_GuiTabMenuHl.svg-6ed85db88d8026812387151d3cfba891.ctex"]
+dest_files=["res://.godot/imported/gdre_GuiTabMenuHl.svg-6ed85db88d8026812387151d3cfba891.dpitex"]
 
 [params]
 
-compress/mode=0
-compress/high_quality=false
-compress/lossy_quality=0.7
-compress/uastc_level=0
-compress/rdo_quality_loss=0.0
-compress/hdr_compression=1
-compress/normal_map=0
-compress/channel_pack=0
-mipmaps/generate=false
-mipmaps/limit=-1
-roughness/mode=0
-roughness/src_normal=""
-process/channel_remap/red=0
-process/channel_remap/green=1
-process/channel_remap/blue=2
-process/channel_remap/alpha=3
-process/fix_alpha_border=true
-process/premult_alpha=false
-process/normal_map_invert_y=false
-process/hdr_as_srgb=false
-process/hdr_clamp_exposure=false
-process/size_limit=0
-detect_3d/compress_to=1
-svg/scale=1.0
-editor/scale_with_editor_scale=false
-editor/convert_colors_with_editor_theme=false
+base_scale=1.0
+saturation=1.0
+color_map={}
+compress=true
diff --git a/standalone/gdre_icons/gdre_Import.svg.import b/standalone/gdre_icons/gdre_Import.svg.import
index 1199d9bf..259536dc 100644
--- a/standalone/gdre_icons/gdre_Import.svg.import
+++ b/standalone/gdre_icons/gdre_Import.svg.import
@@ -1,43 +1,18 @@
 [remap]
 
-importer="texture"
-type="CompressedTexture2D"
+importer="svg"
+type="DPITexture"
 uid="uid://cwydijxu5bwo3"
-path="res://.godot/imported/gdre_Import.svg-1115eb7d8044d7d233fa4679f307db08.ctex"
-metadata={
-"vram_texture": false
-}
+path="res://.godot/imported/gdre_Import.svg-1115eb7d8044d7d233fa4679f307db08.dpitex"
 
 [deps]
 
 source_file="res://gdre_icons/gdre_Import.svg"
-dest_files=["res://.godot/imported/gdre_Import.svg-1115eb7d8044d7d233fa4679f307db08.ctex"]
+dest_files=["res://.godot/imported/gdre_Import.svg-1115eb7d8044d7d233fa4679f307db08.dpitex"]
 
 [params]
 
-compress/mode=0
-compress/high_quality=false
-compress/lossy_quality=0.7
-compress/uastc_level=0
-compress/rdo_quality_loss=0.0
-compress/hdr_compression=1
-compress/normal_map=0
-compress/channel_pack=0
-mipmaps/generate=false
-mipmaps/limit=-1
-roughness/mode=0
-roughness/src_normal=""
-process/channel_remap/red=0
-process/channel_remap/green=1
-process/channel_remap/blue=2
-process/channel_remap/alpha=3
-process/fix_alpha_border=true
-process/premult_alpha=false
-process/normal_map_invert_y=false
-process/hdr_as_srgb=false
-process/hdr_clamp_exposure=false
-process/size_limit=0
-detect_3d/compress_to=1
-svg/scale=1.0
-editor/scale_with_editor_scale=false
-editor/convert_colors_with_editor_theme=false
+base_scale=1.0
+saturation=1.0
+color_map={}
+compress=true
diff --git a/standalone/gdre_icons/gdre_Logo.svg.import b/standalone/gdre_icons/gdre_Logo.svg.import
index e53f6a78..2b50350e 100644
--- a/standalone/gdre_icons/gdre_Logo.svg.import
+++ b/standalone/gdre_icons/gdre_Logo.svg.import
@@ -1,43 +1,18 @@
 [remap]
 
-importer="texture"
-type="CompressedTexture2D"
+importer="svg"
+type="DPITexture"
 uid="uid://drxn4ollkvprv"
-path="res://.godot/imported/gdre_Logo.svg-03c78c677d3ee90e9fbfc520e5118ed6.ctex"
-metadata={
-"vram_texture": false
-}
+path="res://.godot/imported/gdre_Logo.svg-03c78c677d3ee90e9fbfc520e5118ed6.dpitex"
 
 [deps]
 
 source_file="res://gdre_icons/gdre_Logo.svg"
-dest_files=["res://.godot/imported/gdre_Logo.svg-03c78c677d3ee90e9fbfc520e5118ed6.ctex"]
+dest_files=["res://.godot/imported/gdre_Logo.svg-03c78c677d3ee90e9fbfc520e5118ed6.dpitex"]
 
 [params]
 
-compress/mode=0
-compress/high_quality=false
-compress/lossy_quality=0.7
-compress/uastc_level=0
-compress/rdo_quality_loss=0.0
-compress/hdr_compression=1
-compress/normal_map=0
-compress/channel_pack=0
-mipmaps/generate=false
-mipmaps/limit=-1
-roughness/mode=0
-roughness/src_normal=""
-process/channel_remap/red=0
-process/channel_remap/green=1
-process/channel_remap/blue=2
-process/channel_remap/alpha=3
-process/fix_alpha_border=true
-process/premult_alpha=false
-process/normal_map_invert_y=false
-process/hdr_as_srgb=false
-process/hdr_clamp_exposure=false
-process/size_limit=0
-detect_3d/compress_to=1
-svg/scale=2.0
-editor/scale_with_editor_scale=false
-editor/convert_colors_with_editor_theme=false
+base_scale=2.0
+saturation=1.0
+color_map={}
+compress=true
diff --git a/standalone/gdre_icons/gdre_LogoBig.svg.import b/standalone/gdre_icons/gdre_LogoBig.svg.import
index 721f0989..d022f71f 100644
--- a/standalone/gdre_icons/gdre_LogoBig.svg.import
+++ b/standalone/gdre_icons/gdre_LogoBig.svg.import
@@ -1,43 +1,18 @@
 [remap]
 
-importer="texture"
-type="CompressedTexture2D"
+importer="svg"
+type="DPITexture"
 uid="uid://b3l2iqhf34x5c"
-path="res://.godot/imported/gdre_LogoBig.svg-6ca6b5fcea192f7868ddf57e050b5fae.ctex"
-metadata={
-"vram_texture": false
-}
+path="res://.godot/imported/gdre_LogoBig.svg-6ca6b5fcea192f7868ddf57e050b5fae.dpitex"
 
 [deps]
 
 source_file="res://gdre_icons/gdre_LogoBig.svg"
-dest_files=["res://.godot/imported/gdre_LogoBig.svg-6ca6b5fcea192f7868ddf57e050b5fae.ctex"]
+dest_files=["res://.godot/imported/gdre_LogoBig.svg-6ca6b5fcea192f7868ddf57e050b5fae.dpitex"]
 
 [params]
 
-compress/mode=0
-compress/high_quality=false
-compress/lossy_quality=0.7
-compress/uastc_level=0
-compress/rdo_quality_loss=0.0
-compress/hdr_compression=1
-compress/normal_map=0
-compress/channel_pack=0
-mipmaps/generate=false
-mipmaps/limit=-1
-roughness/mode=0
-roughness/src_normal=""
-process/channel_remap/red=0
-process/channel_remap/green=1
-process/channel_remap/blue=2
-process/channel_remap/alpha=3
-process/fix_alpha_border=true
-process/premult_alpha=false
-process/normal_map_invert_y=false
-process/hdr_as_srgb=false
-process/hdr_clamp_exposure=false
-process/size_limit=0
-detect_3d/compress_to=1
-svg/scale=1.0
-editor/scale_with_editor_scale=false
-editor/convert_colors_with_editor_theme=false
+base_scale=1.0
+saturation=1.0
+color_map={}
+compress=true
diff --git a/standalone/gdre_icons/gdre_MaterialPreviewLight1.svg.import b/standalone/gdre_icons/gdre_MaterialPreviewLight1.svg.import
index 325695ee..d6115517 100644
--- a/standalone/gdre_icons/gdre_MaterialPreviewLight1.svg.import
+++ b/standalone/gdre_icons/gdre_MaterialPreviewLight1.svg.import
@@ -1,43 +1,18 @@
 [remap]
 
-importer="texture"
-type="CompressedTexture2D"
+importer="svg"
+type="DPITexture"
 uid="uid://bw33q7hum6mux"
-path="res://.godot/imported/gdre_MaterialPreviewLight1.svg-4cf0b0e5e2d2ef059862fe0e6465b452.ctex"
-metadata={
-"vram_texture": false
-}
+path="res://.godot/imported/gdre_MaterialPreviewLight1.svg-4cf0b0e5e2d2ef059862fe0e6465b452.dpitex"
 
 [deps]
 
 source_file="res://gdre_icons/gdre_MaterialPreviewLight1.svg"
-dest_files=["res://.godot/imported/gdre_MaterialPreviewLight1.svg-4cf0b0e5e2d2ef059862fe0e6465b452.ctex"]
+dest_files=["res://.godot/imported/gdre_MaterialPreviewLight1.svg-4cf0b0e5e2d2ef059862fe0e6465b452.dpitex"]
 
 [params]
 
-compress/mode=0
-compress/high_quality=false
-compress/lossy_quality=0.7
-compress/uastc_level=0
-compress/rdo_quality_loss=0.0
-compress/hdr_compression=1
-compress/normal_map=0
-compress/channel_pack=0
-mipmaps/generate=false
-mipmaps/limit=-1
-roughness/mode=0
-roughness/src_normal=""
-process/channel_remap/red=0
-process/channel_remap/green=1
-process/channel_remap/blue=2
-process/channel_remap/alpha=3
-process/fix_alpha_border=true
-process/premult_alpha=false
-process/normal_map_invert_y=false
-process/hdr_as_srgb=false
-process/hdr_clamp_exposure=false
-process/size_limit=0
-detect_3d/compress_to=1
-svg/scale=1.0
-editor/scale_with_editor_scale=false
-editor/convert_colors_with_editor_theme=false
+base_scale=1.0
+saturation=1.0
+color_map={}
+compress=true
diff --git a/standalone/gdre_icons/gdre_MaterialPreviewLight2.svg.import b/standalone/gdre_icons/gdre_MaterialPreviewLight2.svg.import
index 0e3e69a3..32f9e67b 100644
--- a/standalone/gdre_icons/gdre_MaterialPreviewLight2.svg.import
+++ b/standalone/gdre_icons/gdre_MaterialPreviewLight2.svg.import
@@ -1,43 +1,18 @@
 [remap]
 
-importer="texture"
-type="CompressedTexture2D"
+importer="svg"
+type="DPITexture"
 uid="uid://ducxthcvnkalf"
-path="res://.godot/imported/gdre_MaterialPreviewLight2.svg-2709caafd924ed432248682be650c1e2.ctex"
-metadata={
-"vram_texture": false
-}
+path="res://.godot/imported/gdre_MaterialPreviewLight2.svg-2709caafd924ed432248682be650c1e2.dpitex"
 
 [deps]
 
 source_file="res://gdre_icons/gdre_MaterialPreviewLight2.svg"
-dest_files=["res://.godot/imported/gdre_MaterialPreviewLight2.svg-2709caafd924ed432248682be650c1e2.ctex"]
+dest_files=["res://.godot/imported/gdre_MaterialPreviewLight2.svg-2709caafd924ed432248682be650c1e2.dpitex"]
 
 [params]
 
-compress/mode=0
-compress/high_quality=false
-compress/lossy_quality=0.7
-compress/uastc_level=0
-compress/rdo_quality_loss=0.0
-compress/hdr_compression=1
-compress/normal_map=0
-compress/channel_pack=0
-mipmaps/generate=false
-mipmaps/limit=-1
-roughness/mode=0
-roughness/src_normal=""
-process/channel_remap/red=0
-process/channel_remap/green=1
-process/channel_remap/blue=2
-process/channel_remap/alpha=3
-process/fix_alpha_border=true
-process/premult_alpha=false
-process/normal_map_invert_y=false
-process/hdr_as_srgb=false
-process/hdr_clamp_exposure=false
-process/size_limit=0
-detect_3d/compress_to=1
-svg/scale=1.0
-editor/scale_with_editor_scale=false
-editor/convert_colors_with_editor_theme=false
+base_scale=1.0
+saturation=1.0
+color_map={}
+compress=true
diff --git a/standalone/gdre_icons/gdre_Pack.svg.import b/standalone/gdre_icons/gdre_Pack.svg.import
index 4ba94637..78e5bdb7 100644
--- a/standalone/gdre_icons/gdre_Pack.svg.import
+++ b/standalone/gdre_icons/gdre_Pack.svg.import
@@ -1,43 +1,18 @@
 [remap]
 
-importer="texture"
-type="CompressedTexture2D"
+importer="svg"
+type="DPITexture"
 uid="uid://bp8yf7a2dd6nu"
-path="res://.godot/imported/gdre_Pack.svg-d44c57dd9ce66a00aa09c1dfae57e62c.ctex"
-metadata={
-"vram_texture": false
-}
+path="res://.godot/imported/gdre_Pack.svg-d44c57dd9ce66a00aa09c1dfae57e62c.dpitex"
 
 [deps]
 
 source_file="res://gdre_icons/gdre_Pack.svg"
-dest_files=["res://.godot/imported/gdre_Pack.svg-d44c57dd9ce66a00aa09c1dfae57e62c.ctex"]
+dest_files=["res://.godot/imported/gdre_Pack.svg-d44c57dd9ce66a00aa09c1dfae57e62c.dpitex"]
 
 [params]
 
-compress/mode=0
-compress/high_quality=false
-compress/lossy_quality=0.7
-compress/uastc_level=0
-compress/rdo_quality_loss=0.0
-compress/hdr_compression=1
-compress/normal_map=0
-compress/channel_pack=0
-mipmaps/generate=false
-mipmaps/limit=-1
-roughness/mode=0
-roughness/src_normal=""
-process/channel_remap/red=0
-process/channel_remap/green=1
-process/channel_remap/blue=2
-process/channel_remap/alpha=3
-process/fix_alpha_border=true
-process/premult_alpha=false
-process/normal_map_invert_y=false
-process/hdr_as_srgb=false
-process/hdr_clamp_exposure=false
-process/size_limit=0
-detect_3d/compress_to=1
-svg/scale=2.0
-editor/scale_with_editor_scale=false
-editor/convert_colors_with_editor_theme=false
+base_scale=2.0
+saturation=1.0
+color_map={}
+compress=true
diff --git a/standalone/gdre_icons/gdre_Pause.svg.import b/standalone/gdre_icons/gdre_Pause.svg.import
index da2d5ab9..6392be42 100644
--- a/standalone/gdre_icons/gdre_Pause.svg.import
+++ b/standalone/gdre_icons/gdre_Pause.svg.import
@@ -1,43 +1,18 @@
 [remap]
 
-importer="texture"
-type="CompressedTexture2D"
+importer="svg"
+type="DPITexture"
 uid="uid://b2l0m3p42t05e"
-path="res://.godot/imported/gdre_Pause.svg-370ca5d2688558a108c081589218a42c.ctex"
-metadata={
-"vram_texture": false
-}
+path="res://.godot/imported/gdre_Pause.svg-370ca5d2688558a108c081589218a42c.dpitex"
 
 [deps]
 
 source_file="res://gdre_icons/gdre_Pause.svg"
-dest_files=["res://.godot/imported/gdre_Pause.svg-370ca5d2688558a108c081589218a42c.ctex"]
+dest_files=["res://.godot/imported/gdre_Pause.svg-370ca5d2688558a108c081589218a42c.dpitex"]
 
 [params]
 
-compress/mode=0
-compress/high_quality=false
-compress/lossy_quality=0.7
-compress/uastc_level=0
-compress/rdo_quality_loss=0.0
-compress/hdr_compression=1
-compress/normal_map=0
-compress/channel_pack=0
-mipmaps/generate=false
-mipmaps/limit=-1
-roughness/mode=0
-roughness/src_normal=""
-process/channel_remap/red=0
-process/channel_remap/green=1
-process/channel_remap/blue=2
-process/channel_remap/alpha=3
-process/fix_alpha_border=true
-process/premult_alpha=false
-process/normal_map_invert_y=false
-process/hdr_as_srgb=false
-process/hdr_clamp_exposure=false
-process/size_limit=0
-detect_3d/compress_to=1
-svg/scale=2.0
-editor/scale_with_editor_scale=false
-editor/convert_colors_with_editor_theme=false
+base_scale=2.0
+saturation=1.0
+color_map={}
+compress=true
diff --git a/standalone/gdre_icons/gdre_Play.svg.import b/standalone/gdre_icons/gdre_Play.svg.import
index 70c7db67..1eb7bc0b 100644
--- a/standalone/gdre_icons/gdre_Play.svg.import
+++ b/standalone/gdre_icons/gdre_Play.svg.import
@@ -1,43 +1,18 @@
 [remap]
 
-importer="texture"
-type="CompressedTexture2D"
+importer="svg"
+type="DPITexture"
 uid="uid://fk0s8roleyid"
-path="res://.godot/imported/gdre_Play.svg-c9be634537fad3835afce9acf68d1bc7.ctex"
-metadata={
-"vram_texture": false
-}
+path="res://.godot/imported/gdre_Play.svg-c9be634537fad3835afce9acf68d1bc7.dpitex"
 
 [deps]
 
 source_file="res://gdre_icons/gdre_Play.svg"
-dest_files=["res://.godot/imported/gdre_Play.svg-c9be634537fad3835afce9acf68d1bc7.ctex"]
+dest_files=["res://.godot/imported/gdre_Play.svg-c9be634537fad3835afce9acf68d1bc7.dpitex"]
 
 [params]
 
-compress/mode=0
-compress/high_quality=false
-compress/lossy_quality=0.7
-compress/uastc_level=0
-compress/rdo_quality_loss=0.0
-compress/hdr_compression=1
-compress/normal_map=0
-compress/channel_pack=0
-mipmaps/generate=false
-mipmaps/limit=-1
-roughness/mode=0
-roughness/src_normal=""
-process/channel_remap/red=0
-process/channel_remap/green=1
-process/channel_remap/blue=2
-process/channel_remap/alpha=3
-process/fix_alpha_border=true
-process/premult_alpha=false
-process/normal_map_invert_y=false
-process/hdr_as_srgb=false
-process/hdr_clamp_exposure=false
-process/size_limit=0
-detect_3d/compress_to=1
-svg/scale=2.0
-editor/scale_with_editor_scale=false
-editor/convert_colors_with_editor_theme=false
+base_scale=2.0
+saturation=1.0
+color_map={}
+compress=true
diff --git a/standalone/gdre_icons/gdre_Reload.svg.import b/standalone/gdre_icons/gdre_Reload.svg.import
index 06d96128..0efaa547 100644
--- a/standalone/gdre_icons/gdre_Reload.svg.import
+++ b/standalone/gdre_icons/gdre_Reload.svg.import
@@ -1,43 +1,18 @@
 [remap]
 
-importer="texture"
-type="CompressedTexture2D"
+importer="svg"
+type="DPITexture"
 uid="uid://bck3jnqva5utd"
-path="res://.godot/imported/gdre_Reload.svg-f61f040c5c388c741094b60afdb58dbf.ctex"
-metadata={
-"vram_texture": false
-}
+path="res://.godot/imported/gdre_Reload.svg-f61f040c5c388c741094b60afdb58dbf.dpitex"
 
 [deps]
 
 source_file="res://gdre_icons/gdre_Reload.svg"
-dest_files=["res://.godot/imported/gdre_Reload.svg-f61f040c5c388c741094b60afdb58dbf.ctex"]
+dest_files=["res://.godot/imported/gdre_Reload.svg-f61f040c5c388c741094b60afdb58dbf.dpitex"]
 
 [params]
 
-compress/mode=0
-compress/high_quality=false
-compress/lossy_quality=0.7
-compress/uastc_level=0
-compress/rdo_quality_loss=0.0
-compress/hdr_compression=1
-compress/normal_map=0
-compress/channel_pack=0
-mipmaps/generate=false
-mipmaps/limit=-1
-roughness/mode=0
-roughness/src_normal=""
-process/channel_remap/red=0
-process/channel_remap/green=1
-process/channel_remap/blue=2
-process/channel_remap/alpha=3
-process/fix_alpha_border=true
-process/premult_alpha=false
-process/normal_map_invert_y=false
-process/hdr_as_srgb=false
-process/hdr_clamp_exposure=false
-process/size_limit=0
-detect_3d/compress_to=1
-svg/scale=1.6
-editor/scale_with_editor_scale=false
-editor/convert_colors_with_editor_theme=false
+base_scale=1.6
+saturation=1.0
+color_map={}
+compress=true
diff --git a/standalone/gdre_icons/gdre_ResBT.svg.import b/standalone/gdre_icons/gdre_ResBT.svg.import
index 7d7931b9..bed06665 100644
--- a/standalone/gdre_icons/gdre_ResBT.svg.import
+++ b/standalone/gdre_icons/gdre_ResBT.svg.import
@@ -1,43 +1,18 @@
 [remap]
 
-importer="texture"
-type="CompressedTexture2D"
+importer="svg"
+type="DPITexture"
 uid="uid://c2sxanw32gbqf"
-path="res://.godot/imported/gdre_ResBT.svg-f69b579f4913cd80591ac91026e46d3d.ctex"
-metadata={
-"vram_texture": false
-}
+path="res://.godot/imported/gdre_ResBT.svg-f69b579f4913cd80591ac91026e46d3d.dpitex"
 
 [deps]
 
 source_file="res://gdre_icons/gdre_ResBT.svg"
-dest_files=["res://.godot/imported/gdre_ResBT.svg-f69b579f4913cd80591ac91026e46d3d.ctex"]
+dest_files=["res://.godot/imported/gdre_ResBT.svg-f69b579f4913cd80591ac91026e46d3d.dpitex"]
 
 [params]
 
-compress/mode=0
-compress/high_quality=false
-compress/lossy_quality=0.7
-compress/uastc_level=0
-compress/rdo_quality_loss=0.0
-compress/hdr_compression=1
-compress/normal_map=0
-compress/channel_pack=0
-mipmaps/generate=false
-mipmaps/limit=-1
-roughness/mode=0
-roughness/src_normal=""
-process/channel_remap/red=0
-process/channel_remap/green=1
-process/channel_remap/blue=2
-process/channel_remap/alpha=3
-process/fix_alpha_border=true
-process/premult_alpha=false
-process/normal_map_invert_y=false
-process/hdr_as_srgb=false
-process/hdr_clamp_exposure=false
-process/size_limit=0
-detect_3d/compress_to=1
-svg/scale=2.0
-editor/scale_with_editor_scale=false
-editor/convert_colors_with_editor_theme=false
+base_scale=2.0
+saturation=1.0
+color_map={}
+compress=true
diff --git a/standalone/gdre_icons/gdre_ResOther.svg.import b/standalone/gdre_icons/gdre_ResOther.svg.import
index abfb925a..1cc5fadd 100644
--- a/standalone/gdre_icons/gdre_ResOther.svg.import
+++ b/standalone/gdre_icons/gdre_ResOther.svg.import
@@ -1,43 +1,18 @@
 [remap]
 
-importer="texture"
-type="CompressedTexture2D"
+importer="svg"
+type="DPITexture"
 uid="uid://d0rufkchgyodv"
-path="res://.godot/imported/gdre_ResOther.svg-67d527b79a9c135b8e85c8ed2f5bed4e.ctex"
-metadata={
-"vram_texture": false
-}
+path="res://.godot/imported/gdre_ResOther.svg-67d527b79a9c135b8e85c8ed2f5bed4e.dpitex"
 
 [deps]
 
 source_file="res://gdre_icons/gdre_ResOther.svg"
-dest_files=["res://.godot/imported/gdre_ResOther.svg-67d527b79a9c135b8e85c8ed2f5bed4e.ctex"]
+dest_files=["res://.godot/imported/gdre_ResOther.svg-67d527b79a9c135b8e85c8ed2f5bed4e.dpitex"]
 
 [params]
 
-compress/mode=0
-compress/high_quality=false
-compress/lossy_quality=0.7
-compress/uastc_level=0
-compress/rdo_quality_loss=0.0
-compress/hdr_compression=1
-compress/normal_map=0
-compress/channel_pack=0
-mipmaps/generate=false
-mipmaps/limit=-1
-roughness/mode=0
-roughness/src_normal=""
-process/channel_remap/red=0
-process/channel_remap/green=1
-process/channel_remap/blue=2
-process/channel_remap/alpha=3
-process/fix_alpha_border=true
-process/premult_alpha=false
-process/normal_map_invert_y=false
-process/hdr_as_srgb=false
-process/hdr_clamp_exposure=false
-process/size_limit=0
-detect_3d/compress_to=1
-svg/scale=2.0
-editor/scale_with_editor_scale=false
-editor/convert_colors_with_editor_theme=false
+base_scale=2.0
+saturation=1.0
+color_map={}
+compress=true
diff --git a/standalone/gdre_icons/gdre_ResTB.svg.import b/standalone/gdre_icons/gdre_ResTB.svg.import
index 2f37a64e..63d82b43 100644
--- a/standalone/gdre_icons/gdre_ResTB.svg.import
+++ b/standalone/gdre_icons/gdre_ResTB.svg.import
@@ -1,43 +1,18 @@
 [remap]
 
-importer="texture"
-type="CompressedTexture2D"
+importer="svg"
+type="DPITexture"
 uid="uid://hb6tx3lfaps7"
-path="res://.godot/imported/gdre_ResTB.svg-f441a2a09b3b59642aa6947531d27aa9.ctex"
-metadata={
-"vram_texture": false
-}
+path="res://.godot/imported/gdre_ResTB.svg-f441a2a09b3b59642aa6947531d27aa9.dpitex"
 
 [deps]
 
 source_file="res://gdre_icons/gdre_ResTB.svg"
-dest_files=["res://.godot/imported/gdre_ResTB.svg-f441a2a09b3b59642aa6947531d27aa9.ctex"]
+dest_files=["res://.godot/imported/gdre_ResTB.svg-f441a2a09b3b59642aa6947531d27aa9.dpitex"]
 
 [params]
 
-compress/mode=0
-compress/high_quality=false
-compress/lossy_quality=0.7
-compress/uastc_level=0
-compress/rdo_quality_loss=0.0
-compress/hdr_compression=1
-compress/normal_map=0
-compress/channel_pack=0
-mipmaps/generate=false
-mipmaps/limit=-1
-roughness/mode=0
-roughness/src_normal=""
-process/channel_remap/red=0
-process/channel_remap/green=1
-process/channel_remap/blue=2
-process/channel_remap/alpha=3
-process/fix_alpha_border=true
-process/premult_alpha=false
-process/normal_map_invert_y=false
-process/hdr_as_srgb=false
-process/hdr_clamp_exposure=false
-process/size_limit=0
-detect_3d/compress_to=1
-svg/scale=2.0
-editor/scale_with_editor_scale=false
-editor/convert_colors_with_editor_theme=false
+base_scale=2.0
+saturation=1.0
+color_map={}
+compress=true
diff --git a/standalone/gdre_icons/gdre_Script.svg.import b/standalone/gdre_icons/gdre_Script.svg.import
index 8023233e..3088c136 100644
--- a/standalone/gdre_icons/gdre_Script.svg.import
+++ b/standalone/gdre_icons/gdre_Script.svg.import
@@ -1,43 +1,18 @@
 [remap]
 
-importer="texture"
-type="CompressedTexture2D"
+importer="svg"
+type="DPITexture"
 uid="uid://bwlk10i2ftpri"
-path="res://.godot/imported/gdre_Script.svg-4c68c9c5e02f5e7a41dddea59a95e245.ctex"
-metadata={
-"vram_texture": false
-}
+path="res://.godot/imported/gdre_Script.svg-4c68c9c5e02f5e7a41dddea59a95e245.dpitex"
 
 [deps]
 
 source_file="res://gdre_icons/gdre_Script.svg"
-dest_files=["res://.godot/imported/gdre_Script.svg-4c68c9c5e02f5e7a41dddea59a95e245.ctex"]
+dest_files=["res://.godot/imported/gdre_Script.svg-4c68c9c5e02f5e7a41dddea59a95e245.dpitex"]
 
 [params]
 
-compress/mode=0
-compress/high_quality=false
-compress/lossy_quality=0.7
-compress/uastc_level=0
-compress/rdo_quality_loss=0.0
-compress/hdr_compression=1
-compress/normal_map=0
-compress/channel_pack=0
-mipmaps/generate=false
-mipmaps/limit=-1
-roughness/mode=0
-roughness/src_normal=""
-process/channel_remap/red=0
-process/channel_remap/green=1
-process/channel_remap/blue=2
-process/channel_remap/alpha=3
-process/fix_alpha_border=true
-process/premult_alpha=false
-process/normal_map_invert_y=false
-process/hdr_as_srgb=false
-process/hdr_clamp_exposure=false
-process/size_limit=0
-detect_3d/compress_to=1
-svg/scale=2.0
-editor/scale_with_editor_scale=false
-editor/convert_colors_with_editor_theme=false
+base_scale=2.0
+saturation=1.0
+color_map={}
+compress=true
diff --git a/standalone/gdre_icons/gdre_Search.svg.import b/standalone/gdre_icons/gdre_Search.svg.import
index b6afd025..9e871aa7 100644
--- a/standalone/gdre_icons/gdre_Search.svg.import
+++ b/standalone/gdre_icons/gdre_Search.svg.import
@@ -1,43 +1,18 @@
 [remap]
 
-importer="texture"
-type="CompressedTexture2D"
+importer="svg"
+type="DPITexture"
 uid="uid://byablbp3l8foe"
-path="res://.godot/imported/gdre_Search.svg-db6d735e485abd390d4286d5e840e431.ctex"
-metadata={
-"vram_texture": false
-}
+path="res://.godot/imported/gdre_Search.svg-db6d735e485abd390d4286d5e840e431.dpitex"
 
 [deps]
 
 source_file="res://gdre_icons/gdre_Search.svg"
-dest_files=["res://.godot/imported/gdre_Search.svg-db6d735e485abd390d4286d5e840e431.ctex"]
+dest_files=["res://.godot/imported/gdre_Search.svg-db6d735e485abd390d4286d5e840e431.dpitex"]
 
 [params]
 
-compress/mode=0
-compress/high_quality=false
-compress/lossy_quality=0.7
-compress/uastc_level=0
-compress/rdo_quality_loss=0.0
-compress/hdr_compression=1
-compress/normal_map=0
-compress/channel_pack=0
-mipmaps/generate=false
-mipmaps/limit=-1
-roughness/mode=0
-roughness/src_normal=""
-process/channel_remap/red=0
-process/channel_remap/green=1
-process/channel_remap/blue=2
-process/channel_remap/alpha=3
-process/fix_alpha_border=true
-process/premult_alpha=false
-process/normal_map_invert_y=false
-process/hdr_as_srgb=false
-process/hdr_clamp_exposure=false
-process/size_limit=0
-detect_3d/compress_to=1
-svg/scale=1.0
-editor/scale_with_editor_scale=false
-editor/convert_colors_with_editor_theme=false
+base_scale=1.0
+saturation=1.0
+color_map={}
+compress=true
diff --git a/standalone/gdre_icons/gdre_Stop.svg.import b/standalone/gdre_icons/gdre_Stop.svg.import
index 1bf241a4..68e1d4e4 100644
--- a/standalone/gdre_icons/gdre_Stop.svg.import
+++ b/standalone/gdre_icons/gdre_Stop.svg.import
@@ -1,43 +1,18 @@
 [remap]
 
-importer="texture"
-type="CompressedTexture2D"
+importer="svg"
+type="DPITexture"
 uid="uid://cdhnddtchuo2h"
-path="res://.godot/imported/gdre_Stop.svg-5e008734a41f86d1d6dd922429f3373b.ctex"
-metadata={
-"vram_texture": false
-}
+path="res://.godot/imported/gdre_Stop.svg-5e008734a41f86d1d6dd922429f3373b.dpitex"
 
 [deps]
 
 source_file="res://gdre_icons/gdre_Stop.svg"
-dest_files=["res://.godot/imported/gdre_Stop.svg-5e008734a41f86d1d6dd922429f3373b.ctex"]
+dest_files=["res://.godot/imported/gdre_Stop.svg-5e008734a41f86d1d6dd922429f3373b.dpitex"]
 
 [params]
 
-compress/mode=0
-compress/high_quality=false
-compress/lossy_quality=0.7
-compress/uastc_level=0
-compress/rdo_quality_loss=0.0
-compress/hdr_compression=1
-compress/normal_map=0
-compress/channel_pack=0
-mipmaps/generate=false
-mipmaps/limit=-1
-roughness/mode=0
-roughness/src_normal=""
-process/channel_remap/red=0
-process/channel_remap/green=1
-process/channel_remap/blue=2
-process/channel_remap/alpha=3
-process/fix_alpha_border=true
-process/premult_alpha=false
-process/normal_map_invert_y=false
-process/hdr_as_srgb=false
-process/hdr_clamp_exposure=false
-process/size_limit=0
-detect_3d/compress_to=1
-svg/scale=2.0
-editor/scale_with_editor_scale=false
-editor/convert_colors_with_editor_theme=false
+base_scale=2.0
+saturation=1.0
+color_map={}
+compress=true
diff --git a/standalone/gdre_icons/gdre_Translation.svg.import b/standalone/gdre_icons/gdre_Translation.svg.import
index 8a71e4ab..2f6498c9 100644
--- a/standalone/gdre_icons/gdre_Translation.svg.import
+++ b/standalone/gdre_icons/gdre_Translation.svg.import
@@ -1,43 +1,18 @@
 [remap]
 
-importer="texture"
-type="CompressedTexture2D"
+importer="svg"
+type="DPITexture"
 uid="uid://ditgs1iq4qkup"
-path="res://.godot/imported/gdre_Translation.svg-46b428564f905f308174bad7bee6b44f.ctex"
-metadata={
-"vram_texture": false
-}
+path="res://.godot/imported/gdre_Translation.svg-46b428564f905f308174bad7bee6b44f.dpitex"
 
 [deps]
 
 source_file="res://gdre_icons/gdre_Translation.svg"
-dest_files=["res://.godot/imported/gdre_Translation.svg-46b428564f905f308174bad7bee6b44f.ctex"]
+dest_files=["res://.godot/imported/gdre_Translation.svg-46b428564f905f308174bad7bee6b44f.dpitex"]
 
 [params]
 
-compress/mode=0
-compress/high_quality=false
-compress/lossy_quality=0.7
-compress/uastc_level=0
-compress/rdo_quality_loss=0.0
-compress/hdr_compression=1
-compress/normal_map=0
-compress/channel_pack=0
-mipmaps/generate=false
-mipmaps/limit=-1
-roughness/mode=0
-roughness/src_normal=""
-process/channel_remap/red=0
-process/channel_remap/green=1
-process/channel_remap/blue=2
-process/channel_remap/alpha=3
-process/fix_alpha_border=true
-process/premult_alpha=false
-process/normal_map_invert_y=false
-process/hdr_as_srgb=false
-process/hdr_clamp_exposure=false
-process/size_limit=0
-detect_3d/compress_to=1
-svg/scale=1.0
-editor/scale_with_editor_scale=false
-editor/convert_colors_with_editor_theme=false
+base_scale=1.0
+saturation=1.0
+color_map={}
+compress=true
diff --git a/standalone/gdre_main.gd b/standalone/gdre_main.gd
index 0c01bb49..afe6e118 100644
--- a/standalone/gdre_main.gd
+++ b/standalone/gdre_main.gd
@@ -11,9 +11,9 @@ var isHiDPI = false
 var gdre_recover = preload("res://gdre_recover.tscn")
 var gdre_new_pck = preload("res://gdre_new_pck.tscn")
 var gdre_patch_pck = preload("res://gdre_patch_pck.tscn")
-var RECOVERY_DIALOG: GDRERecoverDialog = null
-var NEW_PCK_DIALOG: GDRENewPck = null
-var PATCH_PCK_DIALOG: GDREPatchPCK = null
+@onready var RECOVERY_DIALOG: GDRERecoverDialog = %GdreRecover
+@onready var NEW_PCK_DIALOG: GDRENewPck = %GdreNewPck
+@onready var PATCH_PCK_DIALOG: GDREPatchPCK = %GdrePatchPck
 var _file_dialog: Window = null
 var last_dir: String = ""
 var REAL_ROOT_WINDOW = null
@@ -71,10 +71,7 @@ func _on_re_editor_standalone_dropped_files(files: PackedStringArray):
 const ERR_SKIP = 45
 
 func _on_recovery_done():
-	if RECOVERY_DIALOG:
-		RECOVERY_DIALOG.hide_win()
-		#get_tree().get_root().remove_child(RECOVERY_DIALOG)
-		#RECOVERY_DIALOG = null
+	RECOVERY_DIALOG.hide_win()
 
 
 
@@ -188,11 +185,6 @@ func close_recover_file_dialog():
 
 
 func launch_recovery_window(paths: PackedStringArray):
-	setup_new_pck_window()
-	#RECOVERY_DIALOG = gdre_recover.instantiate()
-	#RECOVERY_DIALOG.set_root_window(REAL_ROOT_WINDOW)
-	#REAL_ROOT_WINDOW.add_child(RECOVERY_DIALOG)
-	#REAL_ROOT_WINDOW.move_child(RECOVERY_DIALOG, self.get_index() -1)
 	var err = RECOVERY_DIALOG.add_project(paths)
 	if err != OK:
 		var error_msg = GDRESettings.get_recent_error_string()
@@ -203,24 +195,10 @@ func launch_recovery_window(paths: PackedStringArray):
 
 	RECOVERY_DIALOG.show_win()
 
-func setup_new_pck_window():
-	pass
-
-	if not RECOVERY_DIALOG:
-		RECOVERY_DIALOG = $GdreRecover
-	if not NEW_PCK_DIALOG:
-		NEW_PCK_DIALOG = $GdreNewPck
-	if not PATCH_PCK_DIALOG:
-		PATCH_PCK_DIALOG = $GdrePatchPck
-
-
-
 func launch_new_pck_window():
-	setup_new_pck_window()
 	NEW_PCK_DIALOG.show_win()
 
 func launch_patch_pck_window():
-	setup_new_pck_window()
 	PATCH_PCK_DIALOG.show_win()
 
 func _on_recover_project_files_selected(paths: PackedStringArray):
@@ -257,7 +235,6 @@ func open_setenc_window():
 
 
 func setup_file_dialog():
-	setup_new_pck_window()
 	# pop open a file dialog
 	_file_dialog = FileDialog.new()
 	_file_dialog.set_use_native_dialog(true)
diff --git a/standalone/gdre_main.tscn b/standalone/gdre_main.tscn
index 2595313d..d443b8db 100644
--- a/standalone/gdre_main.tscn
+++ b/standalone/gdre_main.tscn
@@ -1,4 +1,4 @@
-[gd_scene load_steps=20 format=3 uid="uid://el6o5uk15g2c"]
+[gd_scene format=3 uid="uid://el6o5uk15g2c"]
 
 [ext_resource type="Theme" uid="uid://crq1fwn0ajw7b" path="res://gdre_theme.tres" id="1"]
 [ext_resource type="Script" uid="uid://bqpxqjfn2qt1g" path="res://gdre_main.gd" id="2"]
@@ -21,7 +21,7 @@
 
 [sub_resource type="ButtonGroup" id="ButtonGroup_x51e8"]
 
-[node name="root" type="GodotREEditorStandalone"]
+[node name="root" type="GodotREEditorStandalone" unique_id=1603667437]
 anchors_preset = 15
 anchor_right = 1.0
 anchor_bottom = 1.0
@@ -32,14 +32,14 @@ grow_vertical = 2
 theme = ExtResource("1")
 script = ExtResource("2")
 
-[node name="SetEncryptionKeyWindow" type="GDREWindow" parent="."]
+[node name="SetEncryptionKeyWindow" type="GDREWindow" parent="." unique_id=1303077086]
 oversampling_override = 1.0
 title = "Set Encryption Key"
 position = Vector2i(144, 24)
 size = Vector2i(800, 150)
 visible = false
 
-[node name="VBoxContainer" type="VBoxContainer" parent="SetEncryptionKeyWindow"]
+[node name="VBoxContainer" type="VBoxContainer" parent="SetEncryptionKeyWindow" unique_id=1675930274]
 anchors_preset = 5
 anchor_left = 0.5
 anchor_right = 0.5
@@ -49,40 +49,40 @@ offset_right = 324.0
 offset_bottom = 103.0
 grow_horizontal = 2
 
-[node name="Label" type="Label" parent="SetEncryptionKeyWindow/VBoxContainer"]
+[node name="Label" type="Label" parent="SetEncryptionKeyWindow/VBoxContainer" unique_id=600271049]
 custom_minimum_size = Vector2(2.08165e-12, 2.08165e-12)
 layout_mode = 2
 text = "Set Encryption Key (64 char hex string...)"
 
-[node name="KeyText" type="TextEdit" parent="SetEncryptionKeyWindow/VBoxContainer"]
+[node name="KeyText" type="TextEdit" parent="SetEncryptionKeyWindow/VBoxContainer" unique_id=931078826]
 custom_minimum_size = Vector2(2.08165e-12, 36)
 layout_mode = 2
 placeholder_text = "<e.g. 000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F>"
 
-[node name="Container" type="Container" parent="SetEncryptionKeyWindow/VBoxContainer"]
+[node name="Container" type="Container" parent="SetEncryptionKeyWindow/VBoxContainer" unique_id=1558141142]
 custom_minimum_size = Vector2(2.08165e-12, 10)
 layout_mode = 2
 
-[node name="HBoxContainer" type="HBoxContainer" parent="SetEncryptionKeyWindow/VBoxContainer"]
+[node name="HBoxContainer" type="HBoxContainer" parent="SetEncryptionKeyWindow/VBoxContainer" unique_id=18974792]
 layout_mode = 2
 
-[node name="Container" type="Container" parent="SetEncryptionKeyWindow/VBoxContainer/HBoxContainer"]
+[node name="Container" type="Container" parent="SetEncryptionKeyWindow/VBoxContainer/HBoxContainer" unique_id=1735791787]
 custom_minimum_size = Vector2(175, 2.08165e-12)
 layout_mode = 2
 
-[node name="CancelButton" type="Button" parent="SetEncryptionKeyWindow/VBoxContainer/HBoxContainer"]
+[node name="CancelButton" type="Button" parent="SetEncryptionKeyWindow/VBoxContainer/HBoxContainer" unique_id=390060981]
 layout_mode = 2
 text = "Cancel"
 
-[node name="Container2" type="Container" parent="SetEncryptionKeyWindow/VBoxContainer/HBoxContainer"]
+[node name="Container2" type="Container" parent="SetEncryptionKeyWindow/VBoxContainer/HBoxContainer" unique_id=1959883497]
 custom_minimum_size = Vector2(200, 2.08165e-12)
 layout_mode = 2
 
-[node name="OK Button" type="Button" parent="SetEncryptionKeyWindow/VBoxContainer/HBoxContainer"]
+[node name="OK Button" type="Button" parent="SetEncryptionKeyWindow/VBoxContainer/HBoxContainer" unique_id=1473968314]
 layout_mode = 2
 text = "OK"
 
-[node name="log_window" type="RichTextLabel" parent="."]
+[node name="log_window" type="RichTextLabel" parent="." unique_id=1743829169]
 z_index = -1
 layout_mode = 1
 anchors_preset = 15
@@ -96,19 +96,19 @@ theme_override_constants/line_separation = 5
 scroll_following = true
 selection_enabled = true
 
-[node name="menu_background" type="Panel" parent="."]
+[node name="menu_background" type="Panel" parent="." unique_id=1505017727]
 layout_mode = 1
 anchors_preset = -1
 anchor_right = 1.0
 offset_top = -40.0
 grow_horizontal = 2
 
-[node name="MenuContainer" type="HBoxContainer" parent="."]
+[node name="MenuContainer" type="HBoxContainer" parent="." unique_id=2071708150]
 layout_mode = 0
 offset_top = -40.0
 offset_right = 1152.0
 
-[node name="REToolsMenu" type="MenuButton" parent="MenuContainer"]
+[node name="REToolsMenu" type="MenuButton" parent="MenuContainer" unique_id=407090115]
 layout_mode = 2
 button_group = SubResource("ButtonGroup_x51e8")
 text = "RE Tools"
@@ -137,7 +137,7 @@ popup/item_7/text = "Quit"
 popup/item_7/icon = ExtResource("3_bc0t5")
 popup/item_7/id = 4
 
-[node name="PCKMenu" type="MenuButton" parent="MenuContainer"]
+[node name="PCKMenu" type="MenuButton" parent="MenuContainer" unique_id=520600070]
 layout_mode = 2
 text = "PCK"
 icon = ExtResource("4_nesr8")
@@ -154,7 +154,7 @@ popup/item_3/text = "Patch Translation..."
 popup/item_3/icon = ExtResource("5_mjm1x")
 popup/item_3/id = 3
 
-[node name="GDScriptMenu" type="MenuButton" parent="MenuContainer"]
+[node name="GDScriptMenu" type="MenuButton" parent="MenuContainer" unique_id=1716885362]
 layout_mode = 2
 text = "GDScript"
 icon = ExtResource("5_wms7f")
@@ -166,7 +166,7 @@ popup/item_1/text = "Compile .GD script files..."
 popup/item_1/icon = ExtResource("5_wms7f")
 popup/item_1/id = 1
 
-[node name="ResourcesMenu" type="MenuButton" parent="MenuContainer"]
+[node name="ResourcesMenu" type="MenuButton" parent="MenuContainer" unique_id=103840578]
 layout_mode = 2
 text = "Resources"
 icon = ExtResource("6_ql2ay")
@@ -192,7 +192,7 @@ popup/item_6/text = "Convert WAV Samples to WAV..."
 popup/item_6/icon = ExtResource("6_ql2ay")
 popup/item_6/id = 6
 
-[node name="version_lbl" type="Button" parent="."]
+[node name="version_lbl" type="Button" parent="." unique_id=383392563]
 layout_mode = 1
 anchors_preset = -1
 anchor_left = 1.0
@@ -206,13 +206,13 @@ theme_override_font_sizes/font_size = 18
 text = "$$$"
 flat = true
 
-[node name="LegalNoticeWindow" type="Window" parent="."]
+[node name="LegalNoticeWindow" type="Window" parent="." unique_id=1615274239]
 title = "Important: Legal Notice"
 position = Vector2i(0, 36)
 size = Vector2i(650, 431)
 visible = false
 
-[node name="Label" type="Label" parent="LegalNoticeWindow"]
+[node name="Label" type="Label" parent="LegalNoticeWindow" unique_id=1908396518]
 offset_left = 100.0
 offset_top = 20.0
 offset_right = 614.0
@@ -225,45 +225,50 @@ Please report any bugs to the GitHub repository.
 "
 autowrap_mode = 3
 
-[node name="OkButton" type="Button" parent="LegalNoticeWindow"]
+[node name="OkButton" type="Button" parent="LegalNoticeWindow" unique_id=1810211307]
 offset_left = 277.0
 offset_top = 378.0
 offset_right = 368.0
 offset_bottom = 411.0
 text = "OK"
 
-[node name="TextureRect" type="TextureRect" parent="LegalNoticeWindow"]
+[node name="TextureRect" type="TextureRect" parent="LegalNoticeWindow" unique_id=1236455254]
 offset_left = 15.0
 offset_top = 164.0
 offset_right = 79.0
 offset_bottom = 228.0
 texture = ExtResource("4_vsto2")
 
-[node name="GdreNewPck" parent="." instance=ExtResource("6_kct41")]
+[node name="GdreNewPck" parent="." unique_id=29398735 instance=ExtResource("6_kct41")]
+unique_name_in_owner = true
 visible = false
 
-[node name="GdrePatchPck" parent="." instance=ExtResource("7_ubmam")]
+[node name="GdrePatchPck" parent="." unique_id=687943564 instance=ExtResource("7_ubmam")]
+unique_name_in_owner = true
 visible = false
 
-[node name="GdreRecover" parent="." instance=ExtResource("8_xa6jx")]
+[node name="GdreRecover" parent="." unique_id=50904804 instance=ExtResource("8_xa6jx")]
 unique_name_in_owner = true
 visible = false
 
-[node name="GdreDecompile" parent="." instance=ExtResource("13_ql2ay")]
+[node name="GdreDecompile" parent="." unique_id=484747495 instance=ExtResource("13_ql2ay")]
+unique_name_in_owner = true
 visible = false
 
-[node name="GdreCompile" parent="." instance=ExtResource("14_8cc8u")]
+[node name="GdreCompile" parent="." unique_id=1219892304 instance=ExtResource("14_8cc8u")]
+unique_name_in_owner = true
 visible = false
 
-[node name="GdreExportReport" parent="." instance=ExtResource("16_htlpu")]
+[node name="GdreExportReport" parent="." unique_id=38944258 instance=ExtResource("16_htlpu")]
 unique_name_in_owner = true
 visible = false
 
-[node name="GdrePatchTranslation" parent="." instance=ExtResource("16_mjm1x")]
+[node name="GdrePatchTranslation" parent="." unique_id=698216953 instance=ExtResource("16_mjm1x")]
 unique_name_in_owner = true
 visible = false
 
-[node name="TextToBinFileDialog" type="FileDialog" parent="."]
+[node name="TextToBinFileDialog" type="FileDialog" parent="." unique_id=22111780]
+unique_name_in_owner = true
 auto_translate_mode = 1
 title = "Open File(s)"
 ok_button_text = "Open"
@@ -273,7 +278,8 @@ filters = PackedStringArray("*.escn,*.tscn,*.tres,*.godot,engine.cfg;Text resour
 show_hidden_files = true
 use_native_dialog = true
 
-[node name="BinToTextFileDialog" type="FileDialog" parent="."]
+[node name="BinToTextFileDialog" type="FileDialog" parent="." unique_id=157356456]
+unique_name_in_owner = true
 title = "Open File(s)"
 ok_button_text = "Open"
 file_mode = 1
@@ -281,7 +287,8 @@ access = 2
 show_hidden_files = true
 use_native_dialog = true
 
-[node name="TextureToPNGFileDialog" type="FileDialog" parent="."]
+[node name="TextureToPNGFileDialog" type="FileDialog" parent="." unique_id=392200930]
+unique_name_in_owner = true
 title = "Open File(s)"
 ok_button_text = "Open"
 file_mode = 1
@@ -290,7 +297,8 @@ filters = PackedStringArray("*.ctex,*.stex,*.tex;Stream texture files")
 show_hidden_files = true
 use_native_dialog = true
 
-[node name="OggStreamToOGGFileDialog" type="FileDialog" parent="."]
+[node name="OggStreamToOGGFileDialog" type="FileDialog" parent="." unique_id=219429950]
+unique_name_in_owner = true
 title = "Open File(s)"
 ok_button_text = "Open"
 file_mode = 1
@@ -299,7 +307,8 @@ filters = PackedStringArray("*.oggstr,*.oggvorbisstr;OGG Sample files")
 show_hidden_files = true
 use_native_dialog = true
 
-[node name="MP3StreamToMP3FileDialog" type="FileDialog" parent="."]
+[node name="MP3StreamToMP3FileDialog" type="FileDialog" parent="." unique_id=984739678]
+unique_name_in_owner = true
 auto_translate_mode = 1
 title = "Open File(s)"
 ok_button_text = "Open"
@@ -309,11 +318,12 @@ filters = PackedStringArray("*.mp3str;MP3 Sample files")
 show_hidden_files = true
 use_native_dialog = true
 
-[node name="GdreConfigDialog" parent="." instance=ExtResource("16_7bfsg")]
+[node name="GdreConfigDialog" parent="." unique_id=1973918773 instance=ExtResource("16_7bfsg")]
 unique_name_in_owner = true
 visible = false
 
-[node name="SampleToWAVFileDialog" type="FileDialog" parent="."]
+[node name="SampleToWAVFileDialog" type="FileDialog" parent="." unique_id=1244434354]
+unique_name_in_owner = true
 title = "Open File(s)"
 ok_button_text = "Open"
 file_mode = 1
diff --git a/utility/gdre_config.cpp b/utility/gdre_config.cpp
index cd52b46b..fd45d335 100644
--- a/utility/gdre_config.cpp
+++ b/utility/gdre_config.cpp
@@ -249,6 +249,16 @@ Vector<Ref<GDREConfigSetting>> GDREConfig::_init_default_settings() {
 				"Use scene view by default",
 				"Use scene view by default instead of the text preview.\nWARNING: Scene view is still experimental and certain scenes may cause the program to become unresponsive.",
 				false)),
+		memnew(GDREConfigSetting(
+				"Recovery/git/create_git_repo",
+				"Create git repo in recovered project",
+				"Create a git repo in the output directory after exporting.\nRequires git to be installed on the system.",
+				false)),
+		memnew(GDREConfigSetting(
+				"Recovery/git/add_imports_to_git_repo",
+				"Add imports to git repo",
+				"Add .godot/imported/ (or .import/ for Godot 3) to the git repo.",
+				false)),
 		memnew(GDREConfigSetting_BytecodeForceBytecodeRevision()),
 		memnew(GDREConfigSetting_LoadCustomBytecode()),
 #if !GODOT_MONO_DECOMP_DISABLED
diff --git a/utility/gdre_settings.cpp b/utility/gdre_settings.cpp
index 026a21a5..7b412bb6 100644
--- a/utility/gdre_settings.cpp
+++ b/utility/gdre_settings.cpp
@@ -1356,21 +1356,26 @@ Vector<String> GDRESettings::get_pack_paths() const {
 
 String GDRESettings::localize_path(const String &p_path, const String &resource_dir) const {
 	String res_path = resource_dir != "" ? resource_dir : project_path;
+#ifdef TOOLS_ENABLED
+	if (res_path.is_empty() && Engine::get_singleton()->is_editor_hint()) {
+		res_path = ProjectSettings::get_singleton()->get_resource_path();
+	}
+#endif
 
 	if (p_path.begins_with("res://") || p_path.begins_with("user://")) {
 		return p_path.simplify_path();
 	}
 	if (!res_path.is_empty() && p_path.simplify_path().begins_with(res_path)) {
-		return p_path.replace(res_path, "res://");
+		return p_path.replace(res_path, "res://").simplify_path();
 	}
 	if ((p_path.is_absolute_path())) {
 		if (!res_path.is_empty()) {
 			if (p_path.begins_with(res_path)) {
-				return p_path.replace(res_path, "res://");
+				return p_path.replace(res_path, "res://").simplify_path();
 			}
 			String path = p_path.simplify_path();
 			if (path.begins_with(res_path)) {
-				return path.replace(res_path, "res://");
+				return path.replace(res_path, "res://").simplify_path();
 			}
 		}
 		if (is_pack_loaded() && (res_path == "" || !p_path.begins_with(res_path))) {
@@ -1399,7 +1404,7 @@ String GDRESettings::localize_path(const String &p_path, const String &resource_
 			//just tack on a "res://" here
 			return "res://" + p_path;
 		}
-		return p_path;
+		return p_path.simplify_path();
 	}
 
 	Ref<DirAccess> dir = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
@@ -1443,6 +1448,11 @@ String GDRESettings::localize_path(const String &p_path, const String &resource_
 
 String GDRESettings::globalize_path(const String &p_path, const String &resource_dir) const {
 	String res_path = resource_dir != "" ? resource_dir : project_path;
+#ifdef TOOLS_ENABLED
+	if (res_path.is_empty() && Engine::get_singleton()->is_editor_hint()) {
+		res_path = ProjectSettings::get_singleton()->get_resource_path();
+	}
+#endif
 
 	if (p_path.begins_with("res://")) {
 		if (res_path != "") {
@@ -1573,20 +1583,22 @@ String GDRESettings::get_mapped_path(const String &p_src) const {
 		String dep_path;
 		if (FileAccess::exists(iinfo_path)) {
 			iinfo = ImportInfo::load_from_file(iinfo_path, 0, 0);
-			if (FileAccess::exists(iinfo->get_path())) {
-				return iinfo->get_path();
-			}
-			auto dests = iinfo->get_dest_files();
-			for (int i = 0; i < dests.size(); i++) {
-				if (FileAccess::exists(dests[i])) {
-					return dests[i];
+			if (iinfo.is_valid()) {
+				if (FileAccess::exists(iinfo->get_path())) {
+					return iinfo->get_path();
+				}
+				auto dests = iinfo->get_dest_files();
+				for (int i = 0; i < dests.size(); i++) {
+					if (FileAccess::exists(dests[i])) {
+						return dests[i];
+					}
 				}
 			}
 		}
 		iinfo_path = src + ".remap";
 		if (FileAccess::exists(iinfo_path)) {
 			iinfo = ImportInfo::load_from_file(iinfo_path, 0, 0);
-			if (FileAccess::exists(iinfo->get_path())) {
+			if (iinfo.is_valid() && FileAccess::exists(iinfo->get_path())) {
 				return iinfo->get_path();
 			}
 		}
@@ -1949,6 +1961,11 @@ ResourceUID::ID GDRESettings::get_uid_for_path(const String &p_path) const {
 	path_to_uid.if_contains(p_path, [&](const ParallelFlatHashMap<String, ResourceUID::ID>::value_type &e) {
 		id = e.second;
 	});
+#ifdef TOOLS_ENABLED
+	if (id == ResourceUID::INVALID_ID && Engine::get_singleton()->is_editor_hint()) {
+		id = ResourceUID::get_singleton()->get_path_id(p_path);
+	}
+#endif
 	//
 	// if (id == ResourceUID::INVALID_ID) {
 	// 	auto src_iinfo = get_import_info_by_dest(p_path);
diff --git a/utility/image_saver.cpp b/utility/image_saver.cpp
index 83057b27..81b81890 100644
--- a/utility/image_saver.cpp
+++ b/utility/image_saver.cpp
@@ -19,7 +19,7 @@ bool ImageSaver::dest_format_supports_mipmaps(const String &ext) {
 	return ext == "dds" || ext == "exr";
 }
 
-const Vector<String> ImageSaver::supported_extensions = { "tga", "svg", "bmp", "gif", "hdr", "exr", "dds", "png", "jpg", "jpeg", "webp" };
+const Vector<String> ImageSaver::supported_extensions = { "png", "jpg", "jpeg", "webp", "tga", "svg", "bmp", "hdr", "exr", "dds", "gif" };
 
 Vector<String> ImageSaver::get_supported_extensions() {
 	return supported_extensions;
diff --git a/utility/import_exporter.cpp b/utility/import_exporter.cpp
index 889ddf1e..cd6cda3e 100644
--- a/utility/import_exporter.cpp
+++ b/utility/import_exporter.cpp
@@ -821,7 +821,7 @@ struct ProcessRunnerStruct : public TaskRunnerStruct {
 	}
 
 	// We have to start the process on the main thread because of inscrutable WINPROC stuff.
-	bool pre_run() {
+	virtual bool pre_run() override {
 		List<String> args;
 		for (const String &arg : arguments) {
 			args.push_back(arg);
@@ -976,12 +976,7 @@ Error ImportExporter::export_imports(const String &p_out_dir, const Vector<Strin
 					if (get_ver_major() >= 4 && OS::get_singleton()->execute("dotnet", { "--version" }, nullptr, &ret_code) == OK && ret_code == 0) {
 						String solution_path = csproj_path.get_basename() + ".sln";
 						process_runner = std::make_shared<ProcessRunnerStruct>("dotnet", Vector<String>({ "build", solution_path, "--property", "WarningLevel=0" }));
-						if (process_runner->pre_run()) {
-							process_runner_task_id = TaskManager::get_singleton()->add_task(process_runner, nullptr, "Compiling C# project...", -1, true, true);
-						} else {
-							// process failed to start
-							process_runner = nullptr;
-						}
+						process_runner_task_id = TaskManager::get_singleton()->add_task(process_runner, nullptr, "Compiling C# project...", -1, true, true);
 					} else {
 						print_line("Unable to compile C# project; ensure that the project is built in the editor before making any changes.");
 					}
@@ -1578,6 +1573,9 @@ Error ImportExporter::export_imports(const String &p_out_dir, const Vector<Strin
 		ERR_FAIL_COND_V_MSG(err || f.is_null(), ERR_FILE_CANT_WRITE, "can't open report.json for writing");
 		f->store_string(JSON::stringify(report->to_json(), "\t", false, true));
 	}
+	if (GDREConfig::get_singleton()->get_setting("Recovery/git/create_git_repo", false)) {
+		make_git_repo();
+	}
 	return OK;
 }
 
@@ -1721,6 +1719,111 @@ Error ImportExporter::recreate_plugin_configs() {
 	return OK;
 }
 
+void ImportExporter::make_git_repo() {
+	if (DirAccess::dir_exists_absolute(output_dir.path_join(".git"))) {
+		print_line("Git repo already exists!");
+		return;
+	}
+	// check if git exists on the path
+	int exit_code = 0;
+	if (OS::get_singleton()->execute("git", { "--version" }, nullptr, &exit_code, true) != OK || exit_code != 0) {
+		ERR_FAIL_MSG("git not found!");
+	}
+	// create the git repo
+	String output;
+	OS::get_singleton()->execute("git", { "-C", output_dir, "init" }, &output, &exit_code, true);
+	if (exit_code != 0) {
+		ERR_FAIL_MSG("Failed to create git repo: " + output);
+	}
+
+	// set core.autocrlf to input
+	OS::get_singleton()->execute("git", { "-C", output_dir, "config", "set", "--local", "core.autocrlf", "input" }, &output, &exit_code, true);
+	if (exit_code != 0) {
+		ERR_FAIL_MSG("Failed to set core.autocrlf to input: " + output);
+	}
+	String gitignore_path = output_dir.path_join(".gitignore");
+	HashSet<String> gitignore_lines = {
+		"# System files",
+		"**/.DS_Store",
+		"Thumbs.db",
+		"**/Thumbs.db",
+		"# GDRE specific ignores",
+		".gltf_copy/",
+		".untouched_gltf_copy/",
+		".tscn_copy/",
+		".tscn_manip/",
+		".autoconverted/",
+		"gdre_export.json",
+		"gdre_export.log",
+		"# Mono build directory",
+		".mono/",
+		".godot/*",
+	};
+	auto da = DirAccess::create(DirAccess::ACCESS_FILESYSTEM);
+	ERR_FAIL_COND_MSG(da.is_null(), "Failed to create DirAccess for " + output_dir);
+	bool include_imports = GDREConfig::get_singleton()->get_setting("Recovery/git/add_imports_to_git_repo", true);
+	Vector<String> files_to_add = { ".gitignore" };
+	if (DirAccess::dir_exists_absolute(output_dir.path_join(".assets"))) {
+		files_to_add.push_back(".assets/");
+	}
+	int ver_major = get_ver_major();
+	if (!include_imports && ver_major == 3) {
+		gitignore_lines.insert(".import/");
+	} else if (include_imports) {
+		if (ver_major >= 4) {
+			gitignore_lines.insert("!.godot/imported/");
+			files_to_add.push_back(".godot/imported/");
+		} else if (ver_major == 3) {
+			files_to_add.push_back(".import/");
+		}
+	}
+	da->change_dir(output_dir);
+	da->set_include_hidden(false);
+	da->list_dir_begin();
+	String file = da->get_next();
+	while (file != "") {
+		if (file[0] != '.' && !gitignore_lines.has(file) && !gitignore_lines.has(file + "/")) {
+			files_to_add.push_back(file);
+		}
+		file = da->get_next();
+	}
+	da->list_dir_end();
+
+	if (!FileAccess::exists(gitignore_path)) {
+		Ref<FileAccess> gitignore = FileAccess::open(gitignore_path, FileAccess::WRITE);
+		if (gitignore.is_null()) {
+			ERR_FAIL_MSG("Failed to open .gitignore for writing");
+		}
+		for (auto &line : gitignore_lines) {
+			gitignore->store_line(line);
+		}
+		gitignore->flush();
+		gitignore->close();
+	}
+
+	Vector<String> add_args = { "-C", output_dir, "add" };
+	for (int i = 0; i < files_to_add.size(); i++) {
+		add_args.push_back(files_to_add[i]);
+	}
+	auto add_runner = std::make_shared<ProcessRunnerStruct>("git", add_args);
+	Error err = TaskManager::get_singleton()->run_task(add_runner, nullptr, "Adding files to git repo...", -1, true, true);
+	if (err == ERR_SKIP) {
+		return;
+	}
+	if (err != OK || add_runner->error_code != 0) {
+		ERR_FAIL_MSG("Failed to add files to git repo: " + add_runner->output);
+	}
+	// commit the files
+	auto commit_runner = std::make_shared<ProcessRunnerStruct>("git", Vector<String>{ "-C", output_dir, "commit", "-m", "Initial commit" });
+	err = TaskManager::get_singleton()->run_task(commit_runner, nullptr, "Committing files to git repo...", -1, true, true);
+	if (err == ERR_SKIP) {
+		return;
+	}
+	if (err != OK || commit_runner->error_code != 0) {
+		ERR_FAIL_MSG("Failed to commit files to git repo: " + commit_runner->output);
+	}
+}
+
 // Godot import data rewriting
 // TODO: For Godot v3-v4, we have to rewrite any resources that have this resource as a dependency to remap to the new destination
 // However, we currently only rewrite the import data if the source file was recorded as an absolute file path,
diff --git a/utility/import_exporter.h b/utility/import_exporter.h
index c4ab994e..2b1d6b8b 100644
--- a/utility/import_exporter.h
+++ b/utility/import_exporter.h
@@ -162,6 +162,7 @@ class ImportExporter : public RefCounted {
 	void recreate_uid_file(const String &src_path, bool is_import, const HashSet<String> &files_to_export_set);
 	Error recreate_plugin_config(const String &plugin_cfg_path);
 	Error recreate_plugin_configs();
+	void make_git_repo();
 
 	void _do_test_recovered_resource(uint32_t i, Ref<ExportReport> *reports);
 	String get_test_recovered_resource_description(uint32_t i, Ref<ExportReport> *reports);
diff --git a/utility/task_manager.cpp b/utility/task_manager.cpp
index 1ff08121..547161ed 100644
--- a/utility/task_manager.cpp
+++ b/utility/task_manager.cpp
@@ -258,9 +258,16 @@ Error TaskManager::wait_for_task_completion(TaskManagerID p_group_id, uint64_t t
 }
 
 bool TaskManager::update_progress_bg(bool p_force_refresh, bool called_from_process) {
-	if (updating_bg || group_id_to_description.empty()) {
+	if (updating_bg || (group_id_to_description.empty() && !Thread::is_main_thread())) {
 		return false;
 	}
+	if (Thread::is_main_thread()) {
+		std::shared_ptr<BaseMainThreadDispatchData> data;
+		// only once per loop
+		if (main_thread_dispatch_queue.try_pop(data)) {
+			data->callback();
+		}
+	}
 	updating_bg = true;
 	bool main_loop_iterating = false;
 	bool has_non_waiting_tasks = false;
diff --git a/utility/task_manager.h b/utility/task_manager.h
index e392cd4b..08a44d97 100644
--- a/utility/task_manager.h
+++ b/utility/task_manager.h
@@ -9,6 +9,7 @@
 #include <memory>
 
 struct TaskRunnerStruct {
+	virtual bool pre_run() { return true; }
 	virtual int get_current_task_step_value() = 0;
 	virtual String get_current_task_step_description() = 0;
 	virtual void cancel() = 0;
@@ -28,6 +29,36 @@ class TaskManager : public Object {
 	static inline bool is_memory_usage_too_high() {
 		return (int64_t)OS::get_singleton()->get_static_memory_usage() > TaskManager::maximum_memory_usage;
 	}
+
+	class BaseMainThreadDispatchData {
+	public:
+		virtual ~BaseMainThreadDispatchData() = default;
+		virtual void callback() = 0;
+		virtual void wait_for_completion() = 0;
+	};
+
+	// This is a helper class to dispatch a callback to the main thread.
+	template <typename C, typename M, typename U>
+	class MainThreadDispatchData : public BaseMainThreadDispatchData {
+		C *instance;
+		M method;
+		U userdata;
+		Semaphore semaphore;
+		bool done = false;
+
+	public:
+		MainThreadDispatchData(C *p_instance, M p_method, U p_userdata) :
+				instance(p_instance), method(p_method), userdata(p_userdata) {}
+		void callback() override {
+			(instance->*method)(userdata);
+			semaphore.post();
+		}
+
+		void wait_for_completion() override {
+			semaphore.wait();
+		}
+	};
+
 	class BaseTemplateTaskData {
 	protected:
 		bool dont_update_progress_bg = false;
@@ -230,6 +261,7 @@ class TaskManager : public Object {
 	protected:
 		virtual void wait_for_task_completion_internal() override {
 			if (!runs_current_thread) {
+				ERR_FAIL_COND_MSG(task_id == -1, "Task not started");
 				WorkerThreadPool::get_singleton()->wait_for_task_completion(task_id);
 			} else {
 				run_on_current_thread();
@@ -261,13 +293,13 @@ class TaskManager : public Object {
 		}
 
 		void run_internal(void *p_data) {
+			if (canceled || done) {
+				return;
+			}
 			cb_struct->run(p_data);
 			done = true;
 		}
 		virtual void run_on_current_thread() override {
-			if (canceled) {
-				return;
-			}
 			run_internal(userdata);
 		}
 		virtual int get_current_task_step_value() override {
@@ -280,9 +312,13 @@ class TaskManager : public Object {
 			return done;
 		}
 		void start_internal() override {
-			if (task_id != -1) {
+			if (task_id != -1 || done || canceled) {
 				return;
 			}
+			if (!cb_struct->pre_run()) {
+				done = true;
+				ERR_FAIL_MSG("Failed to pre-run task: " + description);
+			}
 			if (runs_current_thread) {
 				// random group id
 				task_id = abs(rand());
@@ -358,6 +394,7 @@ class TaskManager : public Object {
 protected:
 	static TaskManager *singleton;
 	ParallelFlatHashMap<TaskManagerID, std::shared_ptr<BaseTemplateTaskData>> group_id_to_description;
+	StaticParallelQueue<std::shared_ptr<BaseMainThreadDispatchData>, 256> main_thread_dispatch_queue;
 	DownloadQueueThread download_thread;
 	std::atomic<TaskManagerID> current_task_id = 0;
 	bool updating_bg = false;
@@ -479,6 +516,19 @@ class TaskManager : public Object {
 		return wait_for_task_completion(task_id);
 	}
 
+	template <typename C, typename M, typename U>
+	void dispatch_to_main_thread(C *p_instance, M p_method, U p_userdata) {
+		if (Thread::is_main_thread()) {
+			(p_instance->*p_method)(p_userdata);
+			return;
+		}
+		std::shared_ptr<BaseMainThreadDispatchData> data = std::make_shared<MainThreadDispatchData<C, M, U>>(p_instance, p_method, p_userdata);
+		while (!main_thread_dispatch_queue.try_push(data)) {
+			OS::get_singleton()->delay_usec(10000); // wait for a slot to become available
+		}
+		data->wait_for_completion();
+	}
+
 	DownloadTaskID add_download_task(const String &p_download_url, const String &p_save_path, bool silent = false);
 	Error wait_for_download_task_completion(DownloadTaskID p_task_id);
 	Error wait_for_task_completion(TaskManagerID p_task_id, uint64_t timeout_s_no_progress = 0);