From 929c6c6ae9f715f573272690c72ea3a1582d8e31 Mon Sep 17 00:00:00 2001
From: b-guild <148972828+b-guild@users.noreply.github.com>
Date: Mon, 13 Oct 2025 02:49:27 -0700
Subject: [PATCH 1/5] Improved load error reporting for FormattedText

---
 fyrox-ui/src/formatted_text.rs | 53 +++++++++++++++++++++++++++++++---
 1 file changed, 49 insertions(+), 4 deletions(-)

diff --git a/fyrox-ui/src/formatted_text.rs b/fyrox-ui/src/formatted_text.rs
index 74734a25e..49d7e105a 100644
--- a/fyrox-ui/src/formatted_text.rs
+++ b/fyrox-ui/src/formatted_text.rs
@@ -29,9 +29,12 @@ use crate::{
     HorizontalAlignment, VerticalAlignment,
 };
 use fyrox_core::log::Log;
-use fyrox_resource::state::LoadError;
+use fyrox_resource::state::{LoadError, ResourceState};
 pub use run::*;
-use std::ops::{Range, RangeBounds};
+use std::{
+    ops::{Range, RangeBounds},
+    path::PathBuf,
+};
 use strum_macros::{AsRefStr, EnumString, VariantNames};
 use textwrapper::*;
 
@@ -804,14 +807,56 @@ impl FormattedText {
         true
     }
 
+    pub fn are_fonts_loading(&self) -> bool {
+        if !self.font.is_loading() {
+            return true;
+        }
+        for run in self.runs.iter() {
+            if let Some(font) = run.font() {
+                if !font.is_loading() {
+                    return true;
+                }
+            }
+        }
+        false
+    }
+
+    pub fn font_load_error_list(&self) -> Vec<(PathBuf, LoadError)> {
+        let mut list = vec![];
+        if let ResourceState::LoadError { path, error } = &self.font.header().state {
+            list.push((path.clone(), error.clone()));
+        }
+        for run in self.runs.iter() {
+            if let Some(font) = run.font() {
+                if let ResourceState::LoadError { path, error } = &font.header().state {
+                    list.push((path.clone(), error.clone()));
+                }
+            }
+        }
+        list
+    }
+
+    pub fn font_loading_summary(&self) -> String {
+        use std::fmt::Write;
+        let mut result = String::default();
+        writeln!(result, "Primary font: {:?}", self.font.header().state).unwrap();
+        for run in self.runs.iter() {
+            if let Some(font) = run.font() {
+                writeln!(result, "Run {:?}: {:?}", run.range, font.header().state).unwrap();
+            }
+        }
+        result
+    }
+
     pub fn build(&mut self) -> Vector2<f32> {
         let mut lines = std::mem::take(&mut self.lines);
         lines.clear();
         // Fail early if any font is not available.
         if !self.are_fonts_loaded() {
             Log::err(format!(
-                "Text failed to build due to unloaded fonts. {:?}",
-                self.text()
+                "Text failed to build due to unloaded fonts. {:?}.\n{}",
+                self.text(),
+                self.font_loading_summary(),
             ));
             return Vector2::default();
         }

From 75b873d72bc869a0ab1de4135a92378ed84cf5bf Mon Sep 17 00:00:00 2001
From: b-guild <148972828+b-guild@users.noreply.github.com>
Date: Mon, 8 Sep 2025 21:09:09 -0700
Subject: [PATCH 2/5] Making resource handles UUID-based instead of path-based.

---
 editor/src/asset/preview/cache.rs        |    2 +-
 editor/src/asset/selection.rs            |    8 +-
 editor/src/asset/selector.rs             |    2 +-
 editor/src/lib.rs                        |   16 +
 editor/src/plugins/material/editor.rs    |    4 +-
 fyrox-core/src/visitor/mod.rs            |   10 +
 fyrox-graph/src/lib.rs                   |    3 +
 fyrox-impl/src/engine/executor.rs        |    3 +
 fyrox-impl/src/engine/mod.rs             |   72 +-
 fyrox-impl/src/renderer/cache/texture.rs |   10 +-
 fyrox-impl/src/resource/model/mod.rs     |   16 +-
 fyrox-impl/src/scene/base.rs             |    6 +-
 fyrox-impl/src/scene/dim2/physics.rs     |    6 +-
 fyrox-impl/src/scene/graph/mod.rs        |   50 +-
 fyrox-impl/src/scene/graph/physics.rs    |    6 +-
 fyrox-impl/src/scene/mesh/mod.rs         |    7 +-
 fyrox-impl/src/scene/mesh/surface.rs     |    6 +-
 fyrox-impl/src/scene/mod.rs              |    7 +-
 fyrox-impl/src/scene/node/mod.rs         |    2 +-
 fyrox-impl/src/scene/sound/mod.rs        |    5 +-
 fyrox-material/src/lib.rs                |   22 +-
 fyrox-resource/src/builtin.rs            |   11 +-
 fyrox-resource/src/graph.rs              |    9 +-
 fyrox-resource/src/lib.rs                |  145 +--
 fyrox-resource/src/manager.rs            | 1095 +++++++++++++++-------
 fyrox-resource/src/registry.rs           |  202 ++--
 fyrox-resource/src/state.rs              |  217 ++---
 fyrox-resource/src/untyped.rs            |  741 ++++++++++-----
 fyrox-sound/src/buffer/generic.rs        |    3 +
 fyrox-ui/src/file_browser/mod.rs         |   10 +-
 fyrox-ui/src/formatted_text.rs           |    4 +-
 fyrox-ui/src/lib.rs                      |   14 +-
 32 files changed, 1709 insertions(+), 1005 deletions(-)

diff --git a/editor/src/asset/preview/cache.rs b/editor/src/asset/preview/cache.rs
index a2023aa70..de05a3656 100644
--- a/editor/src/asset/preview/cache.rs
+++ b/editor/src/asset/preview/cache.rs
@@ -77,7 +77,7 @@ impl AssetPreviewCache {
         generated_counter: &mut usize,
         engine: &mut Engine,
     ) -> Option<AssetPreviewTexture> {
-        let resource_uuid = resource.resource_uuid()?;
+        let resource_uuid = resource.resource_uuid();
 
         if let (false, Some(cached_preview)) = (force_update, self.container.get(&resource_uuid)) {
             return Some(cached_preview.clone());
diff --git a/editor/src/asset/selection.rs b/editor/src/asset/selection.rs
index b91409086..0986c4814 100644
--- a/editor/src/asset/selection.rs
+++ b/editor/src/asset/selection.rs
@@ -59,7 +59,7 @@ struct SaveResourceCommand {
 
 impl SaveResourceCommand {
     fn save(&self) {
-        let mut guard = self.resource.0.safe_lock();
+        let mut guard = self.resource.lock();
         if let Some(data) = guard.state.data_mut() {
             Log::verify(data.save(&self.path));
         }
@@ -163,7 +163,7 @@ impl SelectionContainer for AssetSelection {
                 block_on(self.resource_manager.request_untyped(&resource.path))
             {
                 if !self.resource_manager.is_built_in_resource(&resource) {
-                    let guard = resource.0.safe_lock();
+                    let guard = resource.lock();
                     if let Some(data) = guard.state.data_ref() {
                         callback(&*data.0 as &dyn Reflect, false)
                     }
@@ -205,7 +205,7 @@ impl SelectionContainer for AssetSelection {
                 let resource2 = resource.clone();
                 if !self.resource_manager.is_built_in_resource(&resource) {
                     if let Some(command) = make_command(args, move |_| {
-                        let mut guard = resource.0.safe_lock();
+                        let mut guard = resource.lock();
                         let data = &mut **guard.state.data_mut()?;
                         // SAFETY: This is safe, because the closure owns its own copy of
                         // resource strong ref, and the entity getter is used only once per
@@ -264,7 +264,7 @@ impl SelectionContainer for AssetSelection {
                             path.to_string(),
                             value,
                             move |_| {
-                                let mut guard = resource.0.safe_lock();
+                                let mut guard = resource.lock();
                                 let data = &mut **guard.state.data_mut()?;
                                 // SAFETY: This is safe, because the closure owns its own copy of
                                 // resource strong ref, and the entity getter is used only once per
diff --git a/editor/src/asset/selector.rs b/editor/src/asset/selector.rs
index 223ff8994..00579fe8c 100644
--- a/editor/src/asset/selector.rs
+++ b/editor/src/asset/selector.rs
@@ -337,7 +337,7 @@ impl<'a> AssetSelectorBuilder<'a> {
             .collect::<Vec<_>>();
 
         supported_resource_paths.extend(state.built_in_resources.values().filter_map(|res| {
-            let resource_state = res.resource.0.safe_lock();
+            let resource_state = res.resource.lock();
             if self
                 .asset_types
                 .contains(&resource_state.state.data_ref()?.type_uuid())
diff --git a/editor/src/lib.rs b/editor/src/lib.rs
index 2295225ca..063c21754 100644
--- a/editor/src/lib.rs
+++ b/editor/src/lib.rs
@@ -2313,6 +2313,9 @@ impl Editor {
 
         let current_working_directory = std::env::current_dir().unwrap();
         if current_working_directory != working_directory {
+            Log::info(format!(
+                "Changing working directory to {working_directory:?}"
+            ));
             std::env::set_current_dir(working_directory.clone()).unwrap();
             self.engine.resource_manager.update_or_load_registry();
             self.reload_settings();
@@ -2964,7 +2967,19 @@ impl Editor {
         self.engine.destroy_graphics_context().unwrap();
     }
 
+    fn on_focus_changed(&mut self) {
+        if self.focused {
+            self.engine
+                .resource_manager
+                .state()
+                .process_filesystem_events();
+        }
+    }
+
     pub fn run(mut self, event_loop: EventLoop<()>) {
+        Log::info("Initializing resource registry.");
+        self.engine.resource_manager.update_or_load_registry();
+
         for_each_plugin!(self.plugins => on_start(&mut self));
 
         event_loop
@@ -3041,6 +3056,7 @@ impl Editor {
                         }
                         WindowEvent::Focused(focused) => {
                             self.focused = *focused;
+                            self.on_focus_changed();
                         }
                         WindowEvent::Moved(new_position) => {
                             // Allow the window to go outside the screen bounds by a little. This
diff --git a/editor/src/plugins/material/editor.rs b/editor/src/plugins/material/editor.rs
index 31547169c..2a5c93588 100644
--- a/editor/src/plugins/material/editor.rs
+++ b/editor/src/plugins/material/editor.rs
@@ -218,9 +218,10 @@ pub struct MaterialFieldEditorBuilder {
 }
 
 fn make_name(resource_manager: &ResourceManager, material: &MaterialResource) -> String {
+    let resource_uuid = material.resource_uuid();
     let header = material.header();
     match header.state {
-        ResourceState::Ok { resource_uuid, .. } => {
+        ResourceState::Ok { .. } => {
             if let Some(path) = resource_manager
                 .state()
                 .resource_registry
@@ -241,6 +242,7 @@ fn make_name(resource_manager: &ResourceManager, material: &MaterialResource) ->
                 )
             }
         }
+        ResourceState::Unloaded => "Material not loading".into(),
         ResourceState::LoadError { ref error, .. } => {
             format!("Loading failed: {error:?}")
         }
diff --git a/fyrox-core/src/visitor/mod.rs b/fyrox-core/src/visitor/mod.rs
index 6b614b739..e5f567519 100644
--- a/fyrox-core/src/visitor/mod.rs
+++ b/fyrox-core/src/visitor/mod.rs
@@ -628,6 +628,16 @@ impl Visitor {
         self.version
     }
 
+    /// Returns true of a region with the given name exists as a child of the current node.
+    /// When reading, `has_region` returning true means that `enter_region` will succeed.
+    /// When writing, `has_region` returning true means that `enter_region` will fail.
+    pub fn has_region(&self, name: &str) -> bool {
+        let node = self.nodes.borrow(self.current_node);
+        node.children
+            .iter()
+            .any(|child| self.nodes.borrow(*child).name == name)
+    }
+
     /// If [Visitor::is_reading], find a node with the given name that is a child of the current
     /// node, and return a Visitor for the found node. Return an error if no node with that name exists.
     ///
diff --git a/fyrox-graph/src/lib.rs b/fyrox-graph/src/lib.rs
index 8448f7ccf..d6818a747 100644
--- a/fyrox-graph/src/lib.rs
+++ b/fyrox-graph/src/lib.rs
@@ -1273,6 +1273,9 @@ pub trait SceneGraph: BaseSceneGraph {
         instances
     }
 
+    // Iterate through every node and try to find a corresponding node in the parent resource for that node.
+    // If a node has a parent resource but no correspoding node in the parent resource, then delete the node.
+    // Otherwise, use reflection to make the unmodified variables of the node match the values in the corresponding node.
     fn restore_original_handles_and_inherit_properties<F>(
         &mut self,
         ignored_types: &[TypeId],
diff --git a/fyrox-impl/src/engine/executor.rs b/fyrox-impl/src/engine/executor.rs
index dd0a8ac2a..e4ba49c2d 100644
--- a/fyrox-impl/src/engine/executor.rs
+++ b/fyrox-impl/src/engine/executor.rs
@@ -207,6 +207,9 @@ impl Executor {
 
     /// Runs the executor - starts your game.
     pub fn run(self) {
+        Log::info("Initializing resource registry.");
+        self.engine.resource_manager.update_or_load_registry();
+
         let engine = self.engine;
         let event_loop = self.event_loop;
         let throttle_threshold = self.throttle_threshold;
diff --git a/fyrox-impl/src/engine/mod.rs b/fyrox-impl/src/engine/mod.rs
index a4d35bb3f..12bb3e29d 100644
--- a/fyrox-impl/src/engine/mod.rs
+++ b/fyrox-impl/src/engine/mod.rs
@@ -40,7 +40,6 @@ use crate::{
         manager::{ResourceManager, ResourceWaitContext},
         state::ResourceState,
         untyped::{ResourceKind, UntypedResource},
-        Resource,
     },
     core::{
         algebra::Vector2,
@@ -51,6 +50,7 @@ use crate::{
         reflect::Reflect,
         task::TaskPool,
         variable::try_inherit_properties,
+        SafeLock,
     },
     engine::{error::EngineError, task::TaskPoolHandler},
     event::Event,
@@ -360,6 +360,7 @@ struct LoadingScene {
 }
 
 struct SceneLoadingResult {
+    uuid: Uuid,
     path: PathBuf,
     result: Result<(Scene, Vec<u8>), VisitError>,
 }
@@ -399,6 +400,7 @@ impl AsyncSceneLoader {
             let sender = self.sender.clone();
             let serialization_context = self.serialization_context.clone();
             let resource_manager = self.resource_manager.clone();
+            let uuid = resource_manager.find::<Model>(&path).resource_uuid();
 
             // Aquire the resource IO from the resource manager
             let io = resource_manager.resource_io();
@@ -415,12 +417,14 @@ impl AsyncSceneLoader {
                     Ok((loader, data)) => {
                         let scene = loader.finish().await;
                         Log::verify(sender.send(SceneLoadingResult {
+                            uuid,
                             path,
                             result: Ok((scene, data)),
                         }));
                     }
                     Err(e) => {
                         Log::verify(sender.send(SceneLoadingResult {
+                            uuid,
                             path,
                             result: Err(e),
                         }));
@@ -1059,7 +1063,7 @@ impl ResourceGraphVertex {
 
     pub fn resolve(&self) {
         Log::info(format!(
-            "Resolving {:?} resource from dependency graph...",
+            "Resolving {} resource from dependency graph...",
             self.resource.resource_uuid()
         ));
 
@@ -1351,7 +1355,7 @@ pub(crate) fn initialize_resource_manager_loaders(
     state.constructors_container.add::<AnimationTracksData>();
     state.constructors_container.add::<Style>();
 
-    let mut loaders = state.loaders.lock();
+    let mut loaders = state.loaders.safe_lock();
     let gltf_loader = super::resource::gltf::GltfLoader {
         resource_manager: resource_manager.clone(),
         default_import_options: Default::default(),
@@ -1483,8 +1487,6 @@ impl Engine {
         let user_interfaces =
             UiContainer::new_with_ui(UserInterface::new(Vector2::new(100.0, 100.0)));
 
-        resource_manager.update_or_load_registry();
-
         Ok(Self {
             graphics_context: GraphicsContext::Uninitialized(graphics_context_params),
             model_events_receiver: tx,
@@ -1745,31 +1747,26 @@ impl Engine {
                 match loading_result.result {
                     Ok((mut scene, data)) => {
                         if request.options.derived {
+                            let model = self
+                                .resource_manager
+                                .find_uuid::<Model>(loading_result.uuid);
                             // Create a resource, that will point to the scene we've loaded the
                             // scene from and force scene nodes to inherit data from them.
-                            let model = Resource::new_ok(
-                                Uuid::new_v4(),
-                                ResourceKind::External,
-                                Model {
-                                    mapping: NodeMapping::UseHandles,
-                                    // We have to create a full copy of the scene, because otherwise
-                                    // some methods (`Base::root_resource` in particular) won't work
-                                    // correctly.
-                                    scene: scene
-                                        .clone_ex(
-                                            scene.graph.get_root(),
-                                            &mut |_, _| true,
-                                            &mut |_, _| {},
-                                            &mut |_, _, _| {},
-                                        )
-                                        .0,
-                                },
-                            );
-
-                            Log::verify(
-                                self.resource_manager
-                                    .register(model.clone().into_untyped(), request.path.clone()),
-                            );
+                            let data = Model {
+                                mapping: NodeMapping::UseHandles,
+                                // We have to create a full copy of the scene, because otherwise
+                                // some methods (`Base::root_resource` in particular) won't work
+                                // correctly.
+                                scene: scene
+                                    .clone_ex(
+                                        scene.graph.get_root(),
+                                        &mut |_, _| true,
+                                        &mut |_, _| {},
+                                        &mut |_, _, _| {},
+                                    )
+                                    .0,
+                            };
+                            model.header().state.commit_ok(data);
 
                             for (handle, node) in scene.graph.pair_iter_mut() {
                                 node.set_inheritance_data(handle, model.clone());
@@ -1835,9 +1832,8 @@ impl Engine {
                         // Notify plugins about a scene, that is failed to load.
                         if self.plugins_enabled {
                             Log::err(format!(
-                                "Unable to load scene {}. Reason: {:?}",
-                                loading_result.path.display(),
-                                error
+                                "Unable to load scene {:?}. Reason: {}",
+                                loading_result.path, error
                             ));
 
                             for plugin in self.plugins.iter_mut() {
@@ -2417,7 +2413,7 @@ impl Engine {
             if let ResourceEvent::Reloaded(resource) = event {
                 if let Some(model) = resource.try_cast::<Model>() {
                     Log::info(format!(
-                        "A model resource {:?} was reloaded, propagating changes...",
+                        "A model resource {} was reloaded, propagating changes...",
                         model.resource_uuid()
                     ));
 
@@ -2545,10 +2541,6 @@ impl Engine {
             widget_constructors,
             resource_manager,
         });
-
-        // New plugins may add custom resources and we must re-scan the data folder to include
-        // such resources in the registry.
-        resource_manager.update_or_load_registry();
     }
 
     fn register_plugin(&self, plugin: &dyn Plugin) {
@@ -2717,7 +2709,7 @@ impl Engine {
             let mut resources_to_reload = FxHashSet::default();
             let mut state = self.resource_manager.state();
             for resource in state.resources().iter() {
-                let data = resource.0.lock();
+                let data = resource.lock();
                 if let ResourceState::Ok { ref data, .. } = data.state {
                     data.as_reflect(&mut |reflect| {
                         if reflect.assembly_name() == plugin_assembly_name {
@@ -2784,6 +2776,10 @@ impl Engine {
                 plugin,
             );
 
+            // New plugins may add custom resources and we must re-scan the data folder to include
+            // such resources in the registry.
+            self.resource_manager.update_or_load_registry();
+
             let mut visitor = hotreload::make_reading_visitor(
                 &binary_blob,
                 &self.serialization_context,
@@ -2801,7 +2797,7 @@ impl Engine {
         // Deserialize prefab scene content.
         for (model, scene_state) in prefab_scenes {
             Log::info(format!(
-                "Deserializing {:?} prefab content...",
+                "Deserializing {} prefab content...",
                 model.resource_uuid()
             ));
 
diff --git a/fyrox-impl/src/renderer/cache/texture.rs b/fyrox-impl/src/renderer/cache/texture.rs
index c893acfb6..7c8779ba1 100644
--- a/fyrox-impl/src/renderer/cache/texture.rs
+++ b/fyrox-impl/src/renderer/cache/texture.rs
@@ -195,12 +195,13 @@ impl TextureCache {
         resource_manager: &ResourceManager,
         texture: &TextureResource,
     ) -> Result<(), FrameworkError> {
+        let uuid = texture.resource_uuid();
         let texture = texture.state();
-        if let Some((texture, uuid)) = texture.data_ref_with_id() {
+        if let Some(texture) = texture.data_ref() {
             self.cache.get_entry_mut_or_insert_with(
                 &texture.cache_index,
                 Default::default(),
-                || create_gpu_texture(server, resource_manager, uuid, texture),
+                || create_gpu_texture(server, resource_manager, &uuid, texture),
             )?;
             Ok(())
         } else {
@@ -216,12 +217,13 @@ impl TextureCache {
         resource_manager: &ResourceManager,
         texture_resource: &TextureResource,
     ) -> Option<&TextureRenderData> {
+        let uuid = texture_resource.resource_uuid();
         let texture_data_guard = texture_resource.state();
-        if let Some((texture, uuid)) = texture_data_guard.data_ref_with_id() {
+        if let Some(texture) = texture_data_guard.data_ref() {
             match self.cache.get_mut_or_insert_with(
                 &texture.cache_index,
                 Default::default(),
-                || create_gpu_texture(server, resource_manager, uuid, texture),
+                || create_gpu_texture(server, resource_manager, &uuid, texture),
             ) {
                 Ok(entry) => {
                     // Check if some value has changed in resource.
diff --git a/fyrox-impl/src/resource/model/mod.rs b/fyrox-impl/src/resource/model/mod.rs
index e92523c94..ccf561c54 100644
--- a/fyrox-impl/src/resource/model/mod.rs
+++ b/fyrox-impl/src/resource/model/mod.rs
@@ -353,7 +353,8 @@ pub type ModelResource = Resource<Model>;
 
 /// Extension trait for model resources.
 pub trait ModelResourceExtension: Sized {
-    /// Tries to instantiate model from given resource.
+    /// Tries to instantiate model from given resource. This is for internal use only and does not
+    /// set `is_resource_instance_root`.
     fn instantiate_from<Pre>(
         model: ModelResource,
         model_data: &Model,
@@ -465,6 +466,18 @@ impl AnimationSource for UserInterface {
 }
 
 impl ModelResourceExtension for ModelResource {
+    /// Copy the given model into the given graph.
+    /// * `model`: The resource handle of the model, which put into the created nodes as their
+    ///   [`Base::resource`](crate::scene::base::Base::resource) to indicate which model
+    ///   the node was instantiated from.
+    /// * `model_data`: A borrow of the data contained in `model`.
+    /// * `handle`: The handle of the node within `model` that should be instantiated, typically
+    ///   the root of the model.
+    /// * `dest_graph`: A mutable borrow of the node graph that will contain the newly created copy.
+    /// * `pre_processing_callback`: A function that takes a node handle and a mutable node.
+    ///   The handle belongs to the original node in the model. The node is a copy of the original
+    ///   node, except that parent handle and child handles have been removed. This is a node
+    ///   that will be inserted into `dest_graph`.
     fn instantiate_from<Pre>(
         model: ModelResource,
         model_data: &Model,
@@ -495,7 +508,6 @@ impl ModelResourceExtension for ModelResource {
             Log::err(format!(
                 "Instantiating a model from a resource that is not loaded: {self:?}"
             ));
-            panic!();
         }
         InstantiationContext {
             model: self,
diff --git a/fyrox-impl/src/scene/base.rs b/fyrox-impl/src/scene/base.rs
index 0618ee751..89ad35156 100644
--- a/fyrox-impl/src/scene/base.rs
+++ b/fyrox-impl/src/scene/base.rs
@@ -486,9 +486,9 @@ pub struct Base {
     #[reflect(setter = "set_frustum_culling")]
     frustum_culling: InheritableVariable<bool>,
 
-    // When `true` it means that this node is instance of `resource`.
-    // More precisely - this node is root of whole descendant nodes
-    // hierarchy which was instantiated from resource.
+    /// When `true` it means that this node is instance of `resource`.
+    /// More precisely - this node is root of whole descendant nodes
+    /// hierarchy which was instantiated from resource.
     #[reflect(read_only)]
     pub(crate) is_resource_instance_root: bool,
 
diff --git a/fyrox-impl/src/scene/dim2/physics.rs b/fyrox-impl/src/scene/dim2/physics.rs
index 00c5a9dd6..8d838306a 100644
--- a/fyrox-impl/src/scene/dim2/physics.rs
+++ b/fyrox-impl/src/scene/dim2/physics.rs
@@ -36,7 +36,7 @@ use crate::{
         reflect::prelude::*,
         variable::{InheritableVariable, VariableFlags},
         visitor::prelude::*,
-        BiDirHashMap, ImmutableString,
+        BiDirHashMap, ImmutableString, SafeLock,
     },
     graph::{BaseSceneGraph, SceneGraphNode},
     scene::{
@@ -741,7 +741,7 @@ impl PhysicsWorld {
     /// Draws physics world. Very useful for debugging, it allows you to see where are
     /// rigid bodies, which colliders they have and so on.
     pub fn draw(&self, context: &mut SceneDrawingContext) {
-        self.debug_render_pipeline.lock().render(
+        self.debug_render_pipeline.safe_lock().render(
             context,
             &self.bodies,
             &self.colliders,
@@ -966,7 +966,7 @@ impl PhysicsWorld {
         // 1) `get_mut` is **very** expensive because it forces physics engine to recalculate contacts
         //    and a lot of other stuff, this is why we need `anything_changed` flag.
         if rigid_body_node.native.get() != RigidBodyHandle::invalid() {
-            let mut actions = rigid_body_node.actions.lock();
+            let mut actions = rigid_body_node.actions.safe_lock();
             if rigid_body_node.need_sync_model() || !actions.is_empty() {
                 if let Some(native) = self.bodies.get_mut(rigid_body_node.native.get()) {
                     // Sync native rigid body's properties with scene node's in case if they
diff --git a/fyrox-impl/src/scene/graph/mod.rs b/fyrox-impl/src/scene/graph/mod.rs
index 6e5c62e69..a20d5df29 100644
--- a/fyrox-impl/src/scene/graph/mod.rs
+++ b/fyrox-impl/src/scene/graph/mod.rs
@@ -243,6 +243,9 @@ pub struct SubGraph {
     pub parent: Handle<Node>,
 }
 
+/// Perform remapping for every node in the destination graph that is included
+/// in the given `old_new_mapping`. This uses reflection to update every node handle
+/// that is part of the data of each node.
 fn remap_handles(old_new_mapping: &NodeHandleMap<Node>, dest_graph: &mut Graph) {
     // Iterate over instantiated nodes and remap handles.
     for (_, &new_node_handle) in old_new_mapping.inner().iter() {
@@ -611,6 +614,20 @@ impl Graph {
     /// and when you fire from rocket launcher you just need to create a copy of such
     /// "prefab".
     ///
+    /// * `node_handle`: The handle of the node to copy.
+    /// * `dest_graph`: A mutable borrow of the node graph that will contain the newly created copy.
+    /// * `filter`: A function that takes a node handle and a borrow of a node and returns a bool.
+    ///   The is called with the handle and node of each child of `node_handle` to determine if
+    ///   that child should be recursively copied, and then the same filter is applied to each recursive step.
+    /// * `pre_processing_callback`: A function that takes a node handle and a mutable node.
+    ///   The handle belongs to the original node in this graph. The node is a copy of the original
+    ///   node, except that parent handle and child handles have been removed. This is a node
+    ///   that will be inserted into `dest_graph`.
+    /// * `post_processing_callback`: A function much like `pre_processing_callback` except that
+    ///   it is called after the new node and all its children have been inserted into the graph.
+    ///   The function takes (new handle, original handle, node) as parameters. The node has handles
+    ///   for its newly copied children, but no handle for its parent.
+    ///
     /// # Implementation notes
     ///
     /// Returns tuple where first element is handle to copy of node, and second element -
@@ -722,6 +739,21 @@ impl Graph {
         clone
     }
 
+    /// * `node_handle`: The handle of the node to copy.
+    /// * `dest_graph`: A mutable borrow of the node graph that will contain the newly created copy.
+    /// * `old_new_mapping`: A mutable hashmap of node handles which records which original nodes were copied to
+    ///   become which new nodes.
+    /// * `filter`: A function that takes a node handle and a borrow of a node and returns a bool.
+    ///   The is called with the handle and node of each child of `node_handle` to determine if
+    ///   that child should be recursively copied, and then the same filter is applied to each recursive step.
+    /// * `pre_processing_callback`: A function that takes a node handle and a mutable node.
+    ///   The handle belongs to the original node in this graph. The node is a copy of the original
+    ///   node, except that parent handle and child handles have been removed. This is a node
+    ///   that will be inserted into `dest_graph`.
+    /// * `post_processing_callback`: A function much like `pre_processing_callback` except that
+    ///   it is called after the new node and all its children have been inserted into the graph.
+    ///   The function takes (new handle, original handle, node) as parameters. The node has handles
+    ///   for its newly copied children, but no handle for its parent.
     fn copy_node_raw<F, Pre, Post>(
         &self,
         root_handle: Handle<Node>,
@@ -764,6 +796,8 @@ impl Graph {
         dest_copy_handle
     }
 
+    /// Reconnects every node to the graph by calling its [`Base::on_connected_to_graph`](crate::scene::base::Base::on_connected_to_graph)
+    /// method, giving the node its `self_handle` and the graph's `message_sender` and `script_message_sender`.
     fn restore_dynamic_node_data(&mut self) {
         for (handle, node) in self.pool.pair_iter_mut() {
             node.on_connected_to_graph(
@@ -774,8 +808,8 @@ impl Graph {
         }
     }
 
-    // Fix property flags for scenes made before inheritance system was fixed. By default, all inheritable properties
-    // must be marked as modified in nodes without any parent resource.
+    /// Fix property flags for scenes made before inheritance system was fixed. By default, all inheritable properties
+    /// must be marked as modified in nodes without any parent resource.
     pub(crate) fn mark_ancestor_nodes_as_modified(&mut self) {
         for node in self.linear_iter_mut() {
             if node.resource.is_none() {
@@ -784,11 +818,15 @@ impl Graph {
         }
     }
 
+    /// Synchronizes the state of the graph with external resources.
     pub(crate) fn resolve(&mut self) {
         Log::writeln(MessageKind::Information, "Resolving graph...");
 
         self.restore_dynamic_node_data();
         self.mark_ancestor_nodes_as_modified();
+        // Since the parent resources may have changed, iterate through every node and try to find
+        // the corresponding node in its resource, either by name or by handle depending on the resource's
+        // 'NodeMapping`. If a corresponding node cannot be found in the resource, then delete the node.
         self.restore_original_handles_and_inherit_properties(
             &[TypeId::of::<navmesh::Container>()],
             |resource_node, node| {
@@ -796,9 +834,17 @@ impl Graph {
             },
         );
         self.update_hierarchical_data();
+        // Create a list of (handle, resource) pairs where the handle points to a node that is the root of some instance
+        // of the resource within this graph. At the same time, modify each node so that its unmodified values match the
+        // corresponding values from within the instance's resource, so if the resource has changed the nodes will now
+        // reflect that change.
         let instances = self.restore_integrity(|model, model_data, handle, dest_graph| {
             ModelResource::instantiate_from(model, model_data, handle, dest_graph, &mut |_, _| {})
         });
+        // Iterate through the list of (handle, resource) pairs and use reflection to replace each handle within each instance
+        // with the handle that corresponds to the associated copy in this graph. This is necessary because after
+        // `restore_original_handles_and_inherit_properties` the handles will have been reset back to their original values
+        // which refer to nodes *within* the resource instead of nodes in this graph.
         self.remap_handles(&instances);
 
         self.apply_lightmap();
diff --git a/fyrox-impl/src/scene/graph/physics.rs b/fyrox-impl/src/scene/graph/physics.rs
index ae859622a..fb29e9f5e 100644
--- a/fyrox-impl/src/scene/graph/physics.rs
+++ b/fyrox-impl/src/scene/graph/physics.rs
@@ -36,7 +36,7 @@ use crate::{
         uuid_provider,
         variable::{InheritableVariable, VariableFlags},
         visitor::prelude::*,
-        BiDirHashMap,
+        BiDirHashMap, SafeLock,
     },
     scene::{
         self,
@@ -1228,7 +1228,7 @@ impl PhysicsWorld {
     /// Draws physics world. Very useful for debugging, it allows you to see where are
     /// rigid bodies, which colliders they have and so on.
     pub fn draw(&self, context: &mut SceneDrawingContext) {
-        self.debug_render_pipeline.lock().render(
+        self.debug_render_pipeline.safe_lock().render(
             context,
             &self.bodies,
             &self.colliders,
@@ -1456,7 +1456,7 @@ impl PhysicsWorld {
         // 1) `get_mut` is **very** expensive because it forces physics engine to recalculate contacts
         //    and a lot of other stuff, this is why we need `anything_changed` flag.
         if rigid_body_node.native.get() != RigidBodyHandle::invalid() {
-            let mut actions = rigid_body_node.actions.lock();
+            let mut actions = rigid_body_node.actions.safe_lock();
             if rigid_body_node.need_sync_model() || !actions.is_empty() {
                 if let Some(native) = self.bodies.get_mut(rigid_body_node.native.get()) {
                     // Sync native rigid body's properties with scene node's in case if they
diff --git a/fyrox-impl/src/scene/mesh/mod.rs b/fyrox-impl/src/scene/mesh/mod.rs
index 3c7831561..46cb8f138 100644
--- a/fyrox-impl/src/scene/mesh/mod.rs
+++ b/fyrox-impl/src/scene/mesh/mod.rs
@@ -32,6 +32,7 @@ use crate::{
         type_traits::prelude::*,
         variable::InheritableVariable,
         visitor::prelude::*,
+        SafeLock,
     },
     graph::{BaseSceneGraph, SceneGraph},
     graphics::ElementRange,
@@ -196,7 +197,7 @@ struct BatchContainerWrapper(Mutex<BatchContainer>);
 
 impl Clone for BatchContainerWrapper {
     fn clone(&self) -> Self {
-        Self(Mutex::new(self.0.lock().clone()))
+        Self(Mutex::new(self.0.safe_lock().clone()))
     }
 }
 
@@ -631,7 +632,7 @@ impl NodeTrait for Mesh {
             let mut bounding_box = AxisAlignedBoundingBox::default();
 
             if let BatchingMode::Static = *self.batching_mode {
-                let container = self.batch_container.0.lock();
+                let container = self.batch_container.0.safe_lock();
                 for batch in container.batches.values() {
                     let data = batch.data.data_ref();
                     extend_aabb_from_vertex_buffer(&data.vertex_buffer, &mut bounding_box);
@@ -698,7 +699,7 @@ impl NodeTrait for Mesh {
         let sorting_index = ctx.calculate_sorting_index(self.global_position());
 
         if let BatchingMode::Static = *self.batching_mode {
-            let mut container = self.batch_container.0.lock();
+            let mut container = self.batch_container.0.safe_lock();
 
             if container.batches.is_empty() {
                 container.fill(self.handle(), ctx);
diff --git a/fyrox-impl/src/scene/mesh/surface.rs b/fyrox-impl/src/scene/mesh/surface.rs
index eb0335ff0..a2ab23afe 100644
--- a/fyrox-impl/src/scene/mesh/surface.rs
+++ b/fyrox-impl/src/scene/mesh/surface.rs
@@ -1162,7 +1162,11 @@ pub trait SurfaceResourceExtension {
 
 impl SurfaceResourceExtension for SurfaceResource {
     fn deep_clone(&self) -> Self {
-        Self::new_ok(Uuid::new_v4(), self.kind(), self.data_ref().clone())
+        Self::new_ok(
+            Uuid::new_v4(),
+            ResourceKind::Embedded,
+            self.data_ref().clone(),
+        )
     }
 }
 
diff --git a/fyrox-impl/src/scene/mod.rs b/fyrox-impl/src/scene/mod.rs
index a6d407352..4a5860956 100644
--- a/fyrox-impl/src/scene/mod.rs
+++ b/fyrox-impl/src/scene/mod.rs
@@ -65,6 +65,7 @@ use crate::{
         type_traits::prelude::*,
         variable::InheritableVariable,
         visitor::{error::VisitError, Visit, VisitResult, Visitor},
+        SafeLock,
     },
     engine::SerializationContext,
     graph::NodeHandleMap,
@@ -82,7 +83,6 @@ use crate::{
     utils::navmesh::Navmesh,
 };
 use fxhash::FxHashSet;
-use fyrox_core::SafeLock;
 use std::{
     fmt::{Display, Formatter},
     ops::{Index, IndexMut},
@@ -417,8 +417,8 @@ impl SceneLoader {
                 .filter(|res| {
                     let uuid = res.resource_uuid();
                     let state = self.resource_manager.state();
-                    let registry = state.resource_registry.lock();
-                    uuid.and_then(|uuid| registry.uuid_to_path(uuid)) == Some(&path)
+                    let registry = state.resource_registry.safe_lock();
+                    registry.uuid_to_path(uuid) == Some(&path)
                 })
                 .cloned()
                 .collect::<Vec<_>>();
@@ -577,7 +577,6 @@ impl Scene {
         let mut region = visitor.enter_region(region_name)?;
 
         self.graph.visit("Graph", &mut region)?;
-
         self.enabled.visit("Enabled", &mut region)?;
         let _ = self
             .rendering_options
diff --git a/fyrox-impl/src/scene/node/mod.rs b/fyrox-impl/src/scene/node/mod.rs
index 559fd51bc..d4da62930 100644
--- a/fyrox-impl/src/scene/node/mod.rs
+++ b/fyrox-impl/src/scene/node/mod.rs
@@ -826,7 +826,7 @@ mod test {
             let registry = resource_manager.state().resource_registry.clone();
             let mut registry = registry.safe_lock();
             let mut ctx = registry.modify();
-            ctx.write_metadata(Uuid::new_v4(), derived_asset_path)
+            ctx.write_metadata(Uuid::new_v4(), derived_asset_path.to_path_buf())
                 .unwrap();
         }
 
diff --git a/fyrox-impl/src/scene/sound/mod.rs b/fyrox-impl/src/scene/sound/mod.rs
index 2989c762e..1368a0481 100644
--- a/fyrox-impl/src/scene/sound/mod.rs
+++ b/fyrox-impl/src/scene/sound/mod.rs
@@ -267,7 +267,7 @@ impl Sound {
         *self.panning
     }
 
-    /// Sets playback status.    
+    /// Sets playback status.
     pub fn set_status(&mut self, status: Status) -> Status {
         let prev = self.status();
         match status {
@@ -456,6 +456,9 @@ impl NodeTrait for Sound {
                 let header = buffer.header();
                 match header.state {
                     ResourceState::Pending { .. } | ResourceState::Ok { .. } => Ok(()),
+                    ResourceState::Unloaded => {
+                        Err("Sound buffer is unloaded because it was never requested.".to_string())
+                    }
                     ResourceState::LoadError { ref error, .. } => {
                         match &error.0 {
                             None => Err("Sound buffer is failed to load, the reason is unknown!"
diff --git a/fyrox-material/src/lib.rs b/fyrox-material/src/lib.rs
index 846cebb2a..c6ee1bfa4 100644
--- a/fyrox-material/src/lib.rs
+++ b/fyrox-material/src/lib.rs
@@ -9,6 +9,7 @@ use fxhash::FxHashMap;
 use fyrox_core::{
     algebra::{Matrix2, Matrix3, Matrix4, Vector2, Vector3, Vector4},
     color::Color,
+    futures::executor::block_on,
     io::FileError,
     parking_lot::Mutex,
     reflect::prelude::*,
@@ -31,7 +32,7 @@ use std::{
     any::Any,
     error::Error,
     fmt::{Display, Formatter},
-    path::Path,
+    path::{Path, PathBuf},
     sync::Arc,
 };
 use strum_macros::{AsRefStr, EnumString, VariantNames};
@@ -1142,18 +1143,23 @@ impl MaterialResourceExtension for MaterialResource {
     }
 
     fn deep_copy(&self) -> MaterialResource {
+        if let Err(error) = block_on(self.clone()) {
+            return MaterialResource::new_load_error(
+                ResourceKind::Embedded,
+                PathBuf::default(),
+                error,
+            );
+        }
         let material_state = self.header();
-        let kind = material_state.kind;
         match material_state.state {
-            ResourceState::Pending { ref path, .. } => {
-                MaterialResource::new_pending(path.clone(), kind)
-            }
-            ResourceState::LoadError { ref error, .. } => {
-                MaterialResource::new_load_error(kind, error.clone())
+            ResourceState::Pending { .. }
+            | ResourceState::Unloaded
+            | ResourceState::LoadError { .. } => {
+                unreachable!("The resource should be loaded by now")
             }
             ResourceState::Ok { ref data, .. } => MaterialResource::new_ok(
                 Uuid::new_v4(),
-                kind,
+                ResourceKind::Embedded,
                 (&**data as &dyn Any)
                     .downcast_ref::<Material>()
                     .unwrap()
diff --git a/fyrox-resource/src/builtin.rs b/fyrox-resource/src/builtin.rs
index dfde45e02..0a7d50f3c 100644
--- a/fyrox-resource/src/builtin.rs
+++ b/fyrox-resource/src/builtin.rs
@@ -146,8 +146,6 @@ where
     pub id: PathBuf,
     /// Initial data, from which the resource is created from.
     pub data_source: Option<DataSource>,
-    /// Uuid of the resource.
-    pub resource_uuid: Uuid,
     /// Ready-to-use ("loaded") resource.
     pub resource: Resource<T>,
 }
@@ -157,7 +155,6 @@ impl<T: TypedResourceData> Clone for BuiltInResource<T> {
         Self {
             id: self.id.clone(),
             data_source: self.data_source.clone(),
-            resource_uuid: self.resource_uuid,
             resource: self.resource.clone(),
         }
     }
@@ -173,9 +170,6 @@ impl<T: TypedResourceData> BuiltInResource<T> {
         let resource = make(&data_source.bytes);
         Self {
             id: id.as_ref().to_path_buf(),
-            resource_uuid: resource
-                .resource_uuid()
-                .expect("the resource must be in ok state"),
             resource,
             data_source: Some(data_source),
         }
@@ -186,9 +180,6 @@ impl<T: TypedResourceData> BuiltInResource<T> {
         Self {
             id: id.as_ref().to_path_buf(),
             data_source: None,
-            resource_uuid: resource
-                .resource_uuid()
-                .expect("the resource must be in ok state"),
             resource,
         }
     }
@@ -204,7 +195,7 @@ impl<T: TypedResourceData> From<BuiltInResource<T>> for UntypedBuiltInResource {
         Self {
             id: value.id,
             data_source: value.data_source,
-            resource_uuid: value.resource_uuid,
+            resource_uuid: value.resource.resource_uuid(),
             resource: value.resource.into(),
         }
     }
diff --git a/fyrox-resource/src/graph.rs b/fyrox-resource/src/graph.rs
index cd3dca54b..43ade6712 100644
--- a/fyrox-resource/src/graph.rs
+++ b/fyrox-resource/src/graph.rs
@@ -22,7 +22,6 @@
 
 use crate::{collect_used_resources, state::ResourceState, untyped::UntypedResource};
 use fxhash::FxHashSet;
-use fyrox_core::SafeLock;
 
 /// A node of [`ResourceDependencyGraph`].
 pub struct ResourceGraphNode {
@@ -41,7 +40,7 @@ impl ResourceGraphNode {
         // Look for dependent resources.
         let mut dependent_resources = FxHashSet::default();
 
-        let header = resource.0.safe_lock();
+        let header = resource.lock();
         if let ResourceState::Ok { ref data, .. } = header.state {
             (**data).as_reflect(&mut |entity| {
                 collect_used_resources(entity, &mut dependent_resources);
@@ -116,6 +115,8 @@ impl ResourceDependencyGraph {
 }
 #[cfg(test)]
 mod test {
+    use fyrox_core::Uuid;
+
     use super::*;
     use crate::untyped::ResourceKind;
 
@@ -132,11 +133,11 @@ mod test {
     fn resource_graph_node_pretty_print() {
         let mut s = String::new();
         let mut node = ResourceGraphNode::new(&UntypedResource::new_pending(
-            Default::default(),
+            Uuid::new_v4(),
             ResourceKind::External,
         ));
         let node2 = ResourceGraphNode::new(&UntypedResource::new_pending(
-            Default::default(),
+            Uuid::new_v4(),
             ResourceKind::External,
         ));
         node.children.push(node2);
diff --git a/fyrox-resource/src/lib.rs b/fyrox-resource/src/lib.rs
index a1c3aee7e..9f8340f73 100644
--- a/fyrox-resource/src/lib.rs
+++ b/fyrox-resource/src/lib.rs
@@ -27,6 +27,7 @@
 
 use crate::{
     core::{
+        combine_uuids,
         parking_lot::MutexGuard,
         reflect::prelude::*,
         uuid::{uuid, Uuid},
@@ -38,17 +39,17 @@ use crate::{
 };
 use fxhash::FxHashSet;
 pub use fyrox_core as core;
-use fyrox_core::{combine_uuids, log::Log, SafeLock};
-use std::path::PathBuf;
-use std::{any::Any, fmt::Display};
 use std::{
+    any::Any,
     error::Error,
+    fmt::Display,
     fmt::{Debug, Formatter},
     future::Future,
     hash::{Hash, Hasher},
     marker::PhantomData,
     ops::{Deref, DerefMut},
     path::Path,
+    path::PathBuf,
     pin::Pin,
     task::{Context, Poll},
 };
@@ -77,6 +78,10 @@ pub const SOUND_BUFFER_RESOURCE_UUID: Uuid = uuid!("f6a077b7-c8ff-4473-a95b-0289
 pub const SHADER_RESOURCE_UUID: Uuid = uuid!("f1346417-b726-492a-b80f-c02096c6c019");
 /// Type UUID of curve resource. It is defined here to load old versions of resources.
 pub const CURVE_RESOURCE_UUID: Uuid = uuid!("f28b949f-28a2-4b68-9089-59c234f58b6b");
+/// Type UUID of HRIR sphere resource. It is defined here to load old versions of resources.
+pub const HRIR_SPHERE_RESOURCE_UUID: Uuid = uuid!("c92a0fa3-0ed3-49a9-be44-8f06271c6be2");
+/// Type UUID of font resource. It is defined here to load old versions of resources.
+pub const FONT_RESOURCE_UUID: Uuid = uuid!("692fec79-103a-483c-bb0b-9fc3a349cb48");
 
 /// A trait for resource data.
 pub trait ResourceData: Debug + Visit + Send + Reflect {
@@ -123,10 +128,27 @@ where
     phantom: PhantomData<T>,
 }
 
+impl<'a, T> From<MutexGuard<'a, ResourceHeader>> for ResourceHeaderGuard<'a, T>
+where
+    T: TypedResourceData,
+{
+    fn from(guard: MutexGuard<'a, ResourceHeader>) -> Self {
+        Self {
+            guard,
+            phantom: PhantomData,
+        }
+    }
+}
+
 impl<T> ResourceHeaderGuard<'_, T>
 where
     T: TypedResourceData,
 {
+    /// The UUID that universally identifies the resource.
+    pub fn resource_uuid(&self) -> Uuid {
+        self.guard.uuid
+    }
+
     /// Returns resource kind of the locked resource.
     pub fn kind(&self) -> ResourceKind {
         self.guard.kind
@@ -158,14 +180,11 @@ where
     /// locked resource is not in [`ResourceState::Ok`] or if its actual data does not match the
     /// type of the resource.
     pub fn data_ref_with_id(&self) -> Option<(&T, &Uuid)> {
-        if let ResourceState::Ok {
-            ref data,
-            ref resource_uuid,
-        } = self.guard.state
-        {
+        let uuid = &self.guard.uuid;
+        if let ResourceState::Ok { ref data } = self.guard.state {
             (&**data as &dyn Any)
                 .downcast_ref::<T>()
-                .map(|typed| (typed, resource_uuid))
+                .map(|typed| (typed, uuid))
         } else {
             None
         }
@@ -222,44 +241,8 @@ where
     T: TypedResourceData,
 {
     fn visit(&mut self, name: &str, visitor: &mut Visitor) -> VisitResult {
-        // Untyped -> Typed compatibility. Useful in cases when a field was UntypedResource, and
-        // then it changed to the typed version. Strictly speaking, there's no real separation
-        // between typed and untyped resources on serialization/deserialization and this operation
-        // is valid until data types are matching.
-        if visitor.is_reading() {
-            let mut untyped = UntypedResource::default();
-            if untyped.visit(name, visitor).is_ok() {
-                let untyped_data_type = untyped.type_uuid();
-                if untyped_data_type == Some(<T as TypeUuidProvider>::type_uuid()) {
-                    self.untyped = untyped;
-                    return Ok(());
-                } else {
-                    Log::err(format!(
-                        "Unable to deserialize untyped resource into its typed \
-                     version, because types do not match! Untyped resource has \
-                     {:?} type, but the required type is {}",
-                        untyped_data_type,
-                        <T as TypeUuidProvider>::type_uuid(),
-                    ))
-                }
-            }
-        }
-
-        let mut region = visitor.enter_region(name)?;
-
-        // Backward compatibility.
-        if region.is_reading() {
-            let mut old_option_wrapper: Option<UntypedResource> = None;
-            if old_option_wrapper.visit("State", &mut region).is_ok() {
-                self.untyped = old_option_wrapper.unwrap();
-            } else {
-                self.untyped.visit("State", &mut region)?;
-            }
-        } else {
-            self.untyped.visit("State", &mut region)?;
-        }
-
-        Ok(())
+        self.untyped
+            .visit_with_type_uuid(name, Some(<T as TypeUuidProvider>::type_uuid()), visitor)
     }
 }
 
@@ -293,9 +276,9 @@ where
     }
     /// Creates new resource in pending state.
     #[inline]
-    pub fn new_pending(path: PathBuf, kind: ResourceKind) -> Self {
+    pub fn new_pending(uuid: Uuid, kind: ResourceKind) -> Self {
         Self {
-            untyped: UntypedResource::new_pending(path, kind),
+            untyped: UntypedResource::new_pending(uuid, kind),
             phantom: PhantomData,
         }
     }
@@ -320,9 +303,9 @@ where
 
     /// Creates new resource in error state.
     #[inline]
-    pub fn new_load_error(kind: ResourceKind, error: LoadError) -> Self {
+    pub fn new_load_error(kind: ResourceKind, path: PathBuf, error: LoadError) -> Self {
         Self {
-            untyped: UntypedResource::new_load_error(kind, error),
+            untyped: UntypedResource::new_load_error(kind, path, error),
             phantom: PhantomData,
         }
     }
@@ -336,44 +319,37 @@ where
     /// Locks internal mutex provides access to the state.
     #[inline]
     pub fn state(&self) -> ResourceHeaderGuard<'_, T> {
-        let guard = self.untyped.0.lock();
-        ResourceHeaderGuard {
-            guard,
-            phantom: Default::default(),
-        }
+        self.untyped.typed_lock()
     }
 
     /// Tries to lock internal mutex provides access to the state.
     #[inline]
     pub fn try_acquire_state(&self) -> Option<ResourceHeaderGuard<'_, T>> {
-        self.untyped.0.try_lock().map(|guard| ResourceHeaderGuard {
-            guard,
-            phantom: Default::default(),
-        })
+        self.untyped.try_typed_lock()
     }
 
     /// Locks the resource and provides access to its header. See [`ResourceHeader`] docs for more info.
     #[inline]
     pub fn header(&self) -> MutexGuard<'_, ResourceHeader> {
-        self.untyped.0.lock()
+        self.untyped.lock()
     }
 
     /// Returns true if the resource is still loading.
     #[inline]
     pub fn is_loading(&self) -> bool {
-        matches!(self.untyped.0.lock().state, ResourceState::Pending { .. })
+        self.untyped.is_loading()
     }
 
     /// Returns true if the resource is fully loaded and ready for use.
     #[inline]
     pub fn is_ok(&self) -> bool {
-        matches!(self.untyped.0.lock().state, ResourceState::Ok { .. })
+        self.untyped.is_ok()
     }
 
     /// Returns true if the resource is failed to load.
     #[inline]
     pub fn is_failed_to_load(&self) -> bool {
-        matches!(self.untyped.0.lock().state, ResourceState::LoadError { .. })
+        self.untyped.is_failed_to_load()
     }
 
     /// Returns exact amount of users of the resource.
@@ -385,19 +361,19 @@ where
     /// Returns a pointer as numeric value which can be used as a hash.
     #[inline]
     pub fn key(&self) -> u64 {
-        self.untyped.key() as u64
+        self.untyped.key()
     }
 
-    /// Returns kind of the resource.
+    /// Returns kind of the resource, if the resource is registered.
     #[inline]
     pub fn kind(&self) -> ResourceKind {
         self.untyped.kind()
     }
 
-    /// Tries to get a resource uuid (if any). Uuid is available only for fully loaded resources
-    /// (in [`ResourceState::Ok`] state).
+    /// The UUID of the resource. All resources must have a UUID, even if they are not loaded
+    /// because the UUID is how the resource manager knows the path to load from.
     #[inline]
-    pub fn resource_uuid(&self) -> Option<Uuid> {
+    pub fn resource_uuid(&self) -> Uuid {
         self.untyped.resource_uuid()
     }
 
@@ -423,7 +399,7 @@ where
     #[inline]
     pub fn data_ref(&self) -> ResourceDataRef<'_, T> {
         ResourceDataRef {
-            guard: self.untyped.0.safe_lock(),
+            guard: self.untyped.lock(),
             phantom: Default::default(),
         }
     }
@@ -441,7 +417,7 @@ where
     #[inline]
     fn default() -> Self {
         Self {
-            untyped: UntypedResource::new_ok(Default::default(), Default::default(), T::default()),
+            untyped: UntypedResource::new_ok(Uuid::new_v4(), ResourceKind::Embedded, T::default()),
             phantom: Default::default(),
         }
     }
@@ -457,6 +433,15 @@ impl<T: Debug> Clone for Resource<T> {
     }
 }
 
+impl<T> From<Uuid> for Resource<T>
+where
+    T: TypedResourceData,
+{
+    fn from(uuid: Uuid) -> Self {
+        UntypedResource::from(uuid).into()
+    }
+}
+
 impl<T> From<UntypedResource> for Resource<T>
 where
     T: TypedResourceData,
@@ -535,6 +520,12 @@ where
 {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self.guard.state {
+            ResourceState::Unloaded => {
+                write!(
+                    f,
+                    "Attempt to get reference to resource data while it is unloaded!"
+                )
+            }
             ResourceState::Pending { .. } => {
                 write!(
                     f,
@@ -560,6 +551,12 @@ where
 
     fn deref(&self) -> &Self::Target {
         match self.guard.state {
+            ResourceState::Unloaded => {
+                panic!(
+                    "Attempt to get reference to resource data while it is unloaded! Type {}",
+                    std::any::type_name::<T>()
+                )
+            }
             ResourceState::Pending { .. } => {
                 panic!(
                     "Attempt to get reference to resource data while it is loading! Type {}",
@@ -577,7 +574,7 @@ where
                 };
                 panic!("Attempt to get reference to resource data which failed to load! Type {}. Path: {path}. Error: {error:?}", std::any::type_name::<T>())
             }
-            ResourceState::Ok { ref data, .. } => (&**data as &dyn Any)
+            ResourceState::Ok { ref data } => (&**data as &dyn Any)
                 .downcast_ref()
                 .expect("Type mismatch!"),
         }
@@ -591,6 +588,9 @@ where
     fn deref_mut(&mut self) -> &mut Self::Target {
         let header = &mut *self.guard;
         match header.state {
+            ResourceState::Unloaded => {
+                panic!("Attempt to get reference to resource data while it is unloaded!")
+            }
             ResourceState::Pending { .. } => {
                 panic!("Attempt to get reference to resource data while it is loading!")
             }
@@ -704,6 +704,7 @@ pub fn collect_used_resources(
 
 #[cfg(test)]
 mod tests {
+    use super::*;
     use crate::{
         io::{FsResourceIo, ResourceIo},
         loader::{BoxedLoaderFuture, LoaderPayload, ResourceLoader, ResourceLoadersContainer},
diff --git a/fyrox-resource/src/manager.rs b/fyrox-resource/src/manager.rs
index b8d0c689f..8f3aa00a9 100644
--- a/fyrox-resource/src/manager.rs
+++ b/fyrox-resource/src/manager.rs
@@ -34,7 +34,7 @@ use crate::{
         parking_lot::{Mutex, MutexGuard},
         task::TaskPool,
         watcher::FileSystemWatcher,
-        TypeUuidProvider, Uuid,
+        SafeLock, TypeUuidProvider, Uuid,
     },
     entry::{TimedEntry, DEFAULT_RESOURCE_LIFETIME},
     event::{ResourceEvent, ResourceEventBroadcaster},
@@ -42,13 +42,15 @@ use crate::{
     loader::{ResourceLoader, ResourceLoadersContainer},
     metadata::ResourceMetadata,
     options::OPTIONS_EXTENSION,
-    registry::{ResourceRegistry, ResourceRegistryStatus},
+    registry::{RegistryUpdate, ResourceRegistry, ResourceRegistryRefMut, ResourceRegistryStatus},
     state::{LoadError, ResourceDataWrapper, ResourceState},
     untyped::ResourceKind,
     Resource, TypedResourceData, UntypedResource,
 };
-use fxhash::FxHashSet;
-use fyrox_core::{make_relative_path, some_or_continue, some_or_return};
+use fyrox_core::{
+    futures::executor::block_on, make_relative_path, notify::Event, ok_or_return, some_or_continue,
+    some_or_return,
+};
 use std::{
     fmt::{Debug, Display, Formatter},
     io::Error,
@@ -69,13 +71,12 @@ impl ResourceWaitContext {
     /// Wait until all resources are loaded (or failed to load).
     #[must_use]
     pub fn is_all_loaded(&self) -> bool {
-        let mut loaded_count = 0;
         for resource in self.resources.iter() {
-            if !matches!(resource.0.lock().state, ResourceState::Pending { .. }) {
-                loaded_count += 1;
+            if resource.is_loading() {
+                return false;
             }
         }
-        loaded_count == self.resources.len()
+        true
     }
 }
 
@@ -382,7 +383,7 @@ impl ResourceManager {
     /// method and it may deadlock if used incorrectly (trying to get the state lock one more time
     /// when there's an existing lock in the same thread, multi-threading-related deadlock and so on).
     pub fn state(&self) -> MutexGuard<'_, ResourceManagerState> {
-        self.state.lock()
+        self.state.safe_lock()
     }
 
     /// Returns a guarded reference to the internal state of resource manager. This method will try
@@ -411,6 +412,122 @@ impl ResourceManager {
         self.state().register_built_in_resource(resource)
     }
 
+    /// The same as [`Self::find`], but returns [`None`] if type UUID of `T` does not match the actual type UUID
+    /// of the resource.
+    ///
+    /// ## Panic
+    ///
+    /// This method does not panic.
+    pub fn try_find<T>(&self, path: impl AsRef<Path>) -> Option<Resource<T>>
+    where
+        T: TypedResourceData,
+    {
+        let mut state = self.state();
+
+        let untyped = state.find(path.as_ref());
+
+        let data_type_uuid_matches = untyped
+            .type_uuid_non_blocking()
+            .is_some_and(|uuid| uuid == <T as TypeUuidProvider>::type_uuid());
+
+        if !data_type_uuid_matches {
+            let has_loader_for_extension = state
+                .loaders
+                .safe_lock()
+                .is_extension_matches_type::<T>(path.as_ref());
+
+            if !has_loader_for_extension {
+                return None;
+            }
+        }
+
+        Some(Resource {
+            untyped,
+            phantom: PhantomData::<T>,
+        })
+    }
+
+    /// Find the resource for the given path without loading the resource.
+    /// A new unloaded resource is created if one does not already exist.
+    /// If the path is not in the registry then a new UUID is generated and
+    /// the path is added to the registry.
+    /// If the resource is not already loading, then it will be returned in
+    /// the [`ResourceState::Unloaded`] state, and [`Self::request_resource`] may
+    /// be used to begin the loading process.
+    ///
+    /// ## Panic
+    ///
+    /// This method will panic if type UUID of `T` does not match the actual type UUID of the resource. If this
+    /// is undesirable, use [`Self::try_find`] instead.
+    pub fn find<T>(&self, path: impl AsRef<Path>) -> Resource<T>
+    where
+        T: TypedResourceData,
+    {
+        let path = path.as_ref();
+        let mut state = self.state();
+
+        let untyped = state.find(path);
+
+        let data_type_uuid_matches = untyped
+            .type_uuid_non_blocking()
+            .is_some_and(|uuid| uuid == <T as TypeUuidProvider>::type_uuid());
+
+        if !data_type_uuid_matches {
+            let has_loader_for_extension = state
+                .loaders
+                .safe_lock()
+                .is_extension_matches_type::<T>(path);
+
+            if !has_loader_for_extension {
+                panic!(
+                    "Unable to get a resource of type {} from {path:?}! The resource has no \
+                    associated loader for its extension and its actual data has some other \
+                    data type!",
+                    <T as TypeUuidProvider>::type_uuid(),
+                )
+            }
+        }
+
+        Resource {
+            untyped,
+            phantom: PhantomData::<T>,
+        }
+    }
+
+    /// Find the resource for the given UUID without loading the resource.
+    /// A new unloaded resource is created if one does not already exist.
+    /// If the resource is not already loading, then it will be returned in
+    /// the [`ResourceState::Unloaded`] state, and [`Self::request_resource`] may
+    /// be used to begin the loading process.
+    ///
+    /// ## Panic
+    ///
+    /// This method will panic if type UUID of `T` does not match the actual type UUID of the resource. If this
+    /// is undesirable, use [`Self::try_find`] instead.
+    pub fn find_uuid<T>(&self, uuid: Uuid) -> Resource<T>
+    where
+        T: TypedResourceData,
+    {
+        let mut state = self.state();
+
+        let untyped = state.find_uuid(uuid);
+
+        if let Some(type_uuid) = untyped.type_uuid_non_blocking() {
+            if type_uuid != <T as TypeUuidProvider>::type_uuid() {
+                panic!(
+                    "Unable to get a resource of type {} from {uuid} UUID! Its actual data has some other \
+                    data type with type UUID {type_uuid}!",
+                    <T as TypeUuidProvider>::type_uuid(),
+                )
+            }
+        }
+
+        Resource {
+            untyped,
+            phantom: PhantomData::<T>,
+        }
+    }
+
     /// Requests a resource of the given type located at the given path. This method is non-blocking, instead
     /// it immediately returns the typed resource wrapper. Loading of the resource is managed automatically in
     /// a separate thread (or thread pool) on PC, and JS micro-task (the same thread) on WebAssembly.
@@ -453,9 +570,10 @@ impl ResourceManager {
     where
         T: TypedResourceData,
     {
+        let path = path.as_ref();
         let mut state = self.state();
 
-        let untyped = state.request(path.as_ref());
+        let untyped = state.request(path);
 
         let data_type_uuid_matches = untyped
             .type_uuid_non_blocking()
@@ -464,26 +582,104 @@ impl ResourceManager {
         if !data_type_uuid_matches {
             let has_loader_for_extension = state
                 .loaders
-                .lock()
-                .is_extension_matches_type::<T>(path.as_ref());
+                .safe_lock()
+                .is_extension_matches_type::<T>(path);
 
             if !has_loader_for_extension {
                 panic!(
-                    "Unable to get a resource of type {} from {} path! The resource has no \
+                    "Unable to get a resource of type {} from {path:?}! The resource has no \
                     associated loader for its extension and its actual data has some other \
                     data type!",
                     <T as TypeUuidProvider>::type_uuid(),
-                    path.as_ref().display()
                 )
             }
         }
 
         Resource {
-            untyped: state.request(path),
+            untyped,
             phantom: PhantomData::<T>,
         }
     }
 
+    /// Requests that given resource should begin loading, if not already loading or loaded.
+    /// This method is non-blocking, instead it modifies the given resource and returns.
+    /// Loading of the resource is managed automatically in a separate thread (or thread pool) on PC,
+    /// and JS micro-task (the same thread) on WebAssembly.
+    ///
+    /// ## Type Guarantees
+    ///
+    /// There's no strict guarantees that the requested resource will be of the requested type. This
+    /// is because the resource system is fully async and does not have access to type information in
+    /// most cases. Initial type checking is not very reliable and can be "fooled" pretty easily,
+    /// simply because it just checks if there's a registered loader for a specific extension.
+    ///
+    /// ## Sharing
+    ///
+    /// If a resource with given resource's UUID was already requested (no matter in which state the actual resource
+    /// is), this method will modify the given resource to be a shared reference to the already loading resource.
+    /// This way the resource manager guarantees that the actual resource data will be loaded once, and it can be shared.
+    ///
+    /// ## Resource state
+    ///
+    /// Keep in mind, that the resource itself is a small state machine. It could be in these states:
+    ///
+    /// - [`ResourceState::Unloaded`] - a resource that has not started loading. Calling this method
+    ///   updates the resource into the `Pending` state.
+    /// - [`ResourceState::Pending`] - a resource is in the queue to load or still loading.
+    /// - [`ResourceState::LoadError`] - a resource is failed to load.
+    /// - [`ResourceState::Ok`] - a resource is successfully loaded.
+    ///
+    /// Actual resource state can be fetched by [`Resource::state`] method. If you know for sure that the resource
+    /// is already loaded, then you can use [`Resource::data_ref`] to obtain a reference to the actual resource data.
+    /// Keep in mind, that this method will panic if the resource non in `Ok` state.
+    ///
+    /// ## Panic
+    ///
+    /// This method will panic, if type UUID of `T` does not match the actual type UUID of the resource. If this
+    /// is undesirable, use [`Self::try_request`] instead.
+    pub fn request_resource<T>(&self, resource: &mut Resource<T>)
+    where
+        T: TypedResourceData,
+    {
+        let mut state = self.state();
+
+        state.request_resource(&mut resource.untyped);
+
+        if let Some(type_uuid) = resource.untyped.type_uuid_non_blocking() {
+            let needed_type_uuid = <T as TypeUuidProvider>::type_uuid();
+            if type_uuid != needed_type_uuid {
+                panic!(
+                    "Unable to get a resource of type {needed_type_uuid} from resource UUID {}! The resource is \
+                    loaded but its actual data has type {type_uuid}!",
+                    resource.resource_uuid(),
+                );
+            }
+        }
+    }
+
+    /// Add the given resource to the resource manager, based on the resource's UUID,
+    /// without initiating the loading of the resource. The given resource is modified
+    /// to be a reference to the shared data of an existing resource with the same UUID.
+    pub fn add_resource<T>(&self, resource: &mut Resource<T>)
+    where
+        T: TypedResourceData,
+    {
+        let mut state = self.state();
+
+        state.add_resource(&mut resource.untyped);
+
+        if let Some(type_uuid) = resource.untyped.type_uuid_non_blocking() {
+            let needed_type_uuid = <T as TypeUuidProvider>::type_uuid();
+            if type_uuid != needed_type_uuid {
+                panic!(
+                    "Unable to add a resource of type {needed_type_uuid} from resource UUID {}! The resource is \
+                    loaded but its actual data has type {type_uuid}!",
+                    resource.resource_uuid(),
+                );
+            }
+        }
+    }
+
     /// The same as [`Self::request`], but returns [`None`] if type UUID of `T` does not match the actual type UUID
     /// of the resource.
     ///
@@ -501,7 +697,7 @@ impl ResourceManager {
             .is_some_and(|uuid| uuid == <T as TypeUuidProvider>::type_uuid())
             || state
                 .loaders
-                .lock()
+                .safe_lock()
                 .is_extension_matches_type::<T>(path.as_ref())
         {
             Some(Resource {
@@ -519,7 +715,7 @@ impl ResourceManager {
     /// 2) The resource wasn't registered in the resource registry.
     /// 3) The resource registry wasn't loaded.
     pub fn resource_path(&self, resource: impl AsRef<UntypedResource>) -> Option<PathBuf> {
-        self.state().resource_path(resource)
+        self.state().resource_path(resource.as_ref())
     }
 
     /// Tries to fetch a resource path associated with the given UUID. Returns [`None`] if there's
@@ -550,8 +746,12 @@ impl ResourceManager {
         self.state().add_loader(loader)
     }
 
-    /// Saves given resources in the specified path and registers it in resource manager, so
-    /// it will be accessible through it later.
+    /// Add the given resource to the manager and registers the resource as an external resource with the given
+    /// path, updating the metadata file with the resource's UUID and updating the registry file with the resource's path.
+    /// Calling this should only be necessary after newly creating the file in the given path by saving the resource
+    /// to the file, otherwise the resource's path should already have been discovered by
+    /// [`ResourceManager::update_or_load_registry`].
+    /// If the manager already has a resource with this resource's UUID, return [`ResourceRegistrationError::AlreadyRegistered`].
     pub fn register(
         &self,
         resource: UntypedResource,
@@ -685,17 +885,12 @@ impl ResourceManagerState {
         let resource_io = self.resource_io.clone();
         let resource_registry = self.resource_registry.clone();
         #[allow(unused_variables)]
-        let excluded_folders = resource_registry.lock().excluded_folders.clone();
-        let registry_status = resource_registry.lock().status_flag();
+        let excluded_folders = resource_registry.safe_lock().excluded_folders.clone();
+        let registry_status = resource_registry.safe_lock().status_flag();
         registry_status.mark_as_loading();
         #[allow(unused_variables)]
         let task_loaders = self.loaders.clone();
-        let path = resource_registry.lock().path().to_path_buf();
-
-        info!(
-            "Trying to load or update the registry at {}...",
-            path.display()
-        );
+        let path = resource_registry.safe_lock().path().to_path_buf();
 
         // Try to update the registry first.
         #[cfg(not(any(target_arch = "wasm32", target_os = "android")))]
@@ -703,7 +898,7 @@ impl ResourceManagerState {
             let new_data =
                 ResourceRegistry::scan(resource_io.clone(), task_loaders, &path, excluded_folders)
                     .await;
-            let mut registry_lock = resource_registry.lock();
+            let mut registry_lock = resource_registry.safe_lock();
             registry_lock.modify().set_container(new_data);
             registry_status.mark_as_loaded();
         });
@@ -712,22 +907,18 @@ impl ResourceManagerState {
         self.task_pool.spawn_task(async move {
             use crate::registry::RegistryContainerExt;
             // Then load the registry.
+            info!("Trying to load or update the registry at {path:?}...");
             match crate::registry::RegistryContainer::load_from_file(&path, &*resource_io).await {
                 Ok(registry) => {
-                    let mut registry_lock = resource_registry.lock();
+                    let mut registry_lock = resource_registry.safe_lock();
                     registry_lock.modify().set_container(registry);
-
-                    registry_status.mark_as_loaded();
-
-                    info!(
-                        "Resource registry was loaded from {} successfully!",
-                        path.display()
-                    );
+                    info!("Resource registry was loaded from {path:?} successfully!");
                 }
                 Err(error) => {
-                    err!("Unable to load resource registry! Reason: {:?}.", error);
+                    err!("Unable to load resource registry! Reason: {error}.");
                 }
             };
+            registry_status.mark_as_loaded();
         });
     }
 
@@ -768,6 +959,242 @@ impl ResourceManagerState {
         }
     }
 
+    fn try_get_event(&self) -> Option<Event> {
+        self.watcher.as_ref()?.try_get_event()
+    }
+
+    /// Handle events in the file system relating to adding, removing, or modifying resources.
+    /// This may involve updating the registry to reflect changes to the resources, and it may
+    /// involve creating new meta files for resources that are missing meta files.
+    pub fn process_filesystem_events(&mut self) {
+        while let Some(evt) = self.try_get_event() {
+            if evt.need_rescan() {
+                info!("Filesystem watcher has forced a rescan!");
+                self.update_or_load_registry();
+            } else {
+                use notify::event::{CreateKind, DataChange, ModifyKind, RemoveKind, RenameMode};
+                use notify::EventKind;
+                match evt.kind {
+                    EventKind::Create(CreateKind::Any | CreateKind::File) => {
+                        self.on_create_event(evt.paths.first())
+                    }
+                    EventKind::Modify(ModifyKind::Data(DataChange::Content)) => {
+                        self.on_file_content_event(evt.paths.first())
+                    }
+                    EventKind::Modify(ModifyKind::Name(RenameMode::From)) => {
+                        self.on_remove_event(evt.paths.first())
+                    }
+                    EventKind::Modify(ModifyKind::Name(RenameMode::To)) => {
+                        self.on_create_event(evt.paths.first())
+                    }
+                    EventKind::Modify(ModifyKind::Name(RenameMode::Both)) => {
+                        self.on_remove_event(evt.paths.first());
+                        self.on_create_event(evt.paths.get(1));
+                    }
+                    EventKind::Remove(RemoveKind::Any | RemoveKind::File) => {
+                        self.on_remove_event(evt.paths.first())
+                    }
+                    _ => (),
+                }
+            }
+        }
+    }
+
+    fn on_create_event(&mut self, path: Option<&PathBuf>) {
+        let path = some_or_return!(path);
+        let mut relative_path = ok_or_return!(fyrox_core::make_relative_path(path));
+        let ext = some_or_return!(relative_path.extension());
+        let mut registry = self.resource_registry.safe_lock();
+        if registry
+            .excluded_folders
+            .iter()
+            .any(|folder| relative_path.starts_with(folder))
+        {
+            return;
+        }
+        // An event for a created file does not guarantee that the file actually exists.
+        // It might have been deleted or renamed between being created and us receiving the event.
+        if !block_on(self.resource_io.exists(&relative_path)) {
+            return;
+        }
+        if ext == ResourceMetadata::EXTENSION {
+            // Remove the meta extension from the path to get the path of the resource.
+            relative_path.set_extension("");
+            match registry.modify().read_metadata(relative_path.clone()) {
+                Ok(RegistryUpdate {
+                    changed,
+                    value: metadata,
+                }) => {
+                    if changed {
+                        info!(
+                        "The resource {relative_path:?} was registered successfully with {} id from a newly created meta file!",
+                        metadata.resource_id
+                        )
+                    }
+                }
+                Err(err) => {
+                    err!(
+                        "Unable to read the metadata for resource {relative_path:?}. Reason: {err}",
+                    )
+                }
+            }
+        } else if self
+            .loaders
+            .safe_lock()
+            .is_supported_resource(&relative_path)
+        {
+            Self::on_new_resource_file(registry.modify(), relative_path);
+        }
+    }
+    /// A new resource file has been discovered through an event. Check if there is a corresponding meta file,
+    /// and if not then create the meta file with a randomly generated UUID.
+    fn on_new_resource_file(mut registry: ResourceRegistryRefMut<'_>, relative_path: PathBuf) {
+        match registry.read_metadata(relative_path.clone()) {
+            Ok(RegistryUpdate {
+                changed,
+                value: metadata,
+            }) => {
+                if changed {
+                    info!(
+                    "The newly created resource {relative_path:?} was registered successfully with {} id from the meta file!",
+                    metadata.resource_id
+                    )
+                }
+            }
+            Err(_) => {
+                let uuid = Uuid::new_v4();
+                match registry.write_metadata(uuid, relative_path.clone()) {
+                    Ok(RegistryUpdate {
+                        changed,
+                        value: old_path,
+                    }) => {
+                        assert!(old_path.is_none());
+                        if changed {
+                            info!("The newly created resource {relative_path:?} was registered successfully with new id: {uuid}");
+                        }
+                    }
+                    Err(err) => {
+                        err!("Unable to register the resource {relative_path:?}. Reason: {err}")
+                    }
+                }
+            }
+        }
+    }
+    fn on_remove_event(&mut self, path: Option<&PathBuf>) {
+        let path = some_or_return!(path);
+        let mut relative_path = ok_or_return!(fyrox_core::make_relative_path(path));
+        let ext = some_or_return!(relative_path.extension());
+        // For the purposes of updating the registry, only the removal of meta files is relevant.
+        if ext != ResourceMetadata::EXTENSION {
+            return;
+        }
+        // An event for a deleted file does not guarantee that the file does not exist.
+        // It might have been created again between being deleted and us receiving the event.
+        // If the file exists now, ignore the remove event.
+        if block_on(self.resource_io.exists(&relative_path)) {
+            return;
+        }
+
+        let mut registry = self.resource_registry.safe_lock();
+        if registry
+            .excluded_folders
+            .iter()
+            .any(|folder| relative_path.starts_with(folder))
+        {
+            return;
+        }
+        // Remove the meta extension from the path to get the path of the resource.
+        relative_path.set_extension("");
+        // Check whether the resource file exists, and if not then there is nothing more to do.
+        if !block_on(self.resource_io.exists(&relative_path)) {
+            return;
+        }
+        // Recreate the meta file, using the current UUID for the resource's path, if possible.
+        let uuid = match registry.path_to_uuid(&relative_path) {
+            Some(uuid) => {
+                info!("The meta file for {relative_path:?} was removed, but its UUID is still in memory: {uuid}");
+                uuid
+            }
+            None => {
+                info!("The meta file for {relative_path:?} was removed and its UUID is lost!");
+                Uuid::new_v4()
+            }
+        };
+        let result = registry
+            .modify()
+            .write_metadata(uuid, relative_path.clone());
+        match result {
+            Ok(RegistryUpdate { changed, .. }) => {
+                if changed {
+                    info!(
+                        "The resource {relative_path:?} was registered successfully with {uuid} id after its meta file was removed!",
+                    )
+                } else {
+                    info!(
+                        "The meta file for resource {relative_path:?} was recreated with {uuid} id!",
+                    )
+                }
+            }
+            Err(err) => {
+                err!(
+                    "Unable to register the resource {relative_path:?} after its meta file was removed. Reason: {err}",
+                )
+            }
+        }
+    }
+    fn on_file_content_event(&mut self, path: Option<&PathBuf>) {
+        let path = some_or_return!(path);
+        let mut relative_path = ok_or_return!(fyrox_core::make_relative_path(path));
+        let ext = some_or_return!(relative_path.extension());
+        let mut registry = self.resource_registry.safe_lock();
+        if registry
+            .excluded_folders
+            .iter()
+            .any(|folder| relative_path.starts_with(folder))
+        {
+            return;
+        }
+        // An event for a modified file does not guarantee that the file actually exists.
+        // It might have been deleted or renamed between being modified and us receiving the event.
+        if !block_on(self.resource_io.exists(&relative_path)) {
+            return;
+        }
+
+        if ext == ResourceMetadata::EXTENSION {
+            // Remove the meta extension from the path to get the path of the resource.
+            relative_path.set_extension("");
+            match registry.modify().read_metadata(relative_path.clone()) {
+                Ok(RegistryUpdate {
+                    changed,
+                    value: metadata,
+                }) => {
+                    if changed {
+                        info!(
+                            "The resource {relative_path:?} was registered successfully with {} id after meta file modification",
+                            metadata.resource_id
+                        )
+                    }
+                }
+                Err(err) => {
+                    err!(
+                        "Unable to read the metadata for resource {relative_path:?} after meta file modification. Reason: {err}",
+                    )
+                }
+            }
+        } else if self
+            .loaders
+            .safe_lock()
+            .is_supported_resource(&relative_path)
+        {
+            drop(registry);
+            if self.try_reload_resource_from_path(&relative_path) {
+                info!(
+                    "File {relative_path:?} was changed, trying to reload a respective resource...",
+                );
+            }
+        }
+    }
+
     /// Update resource containers and do hot-reloading.
     ///
     /// Resources are removed if they're not used
@@ -783,16 +1210,10 @@ impl ResourceManagerState {
             if resource.value.use_count() <= 1 {
                 resource.time_to_live -= dt;
                 if resource.time_to_live <= 0.0 {
-                    let registry = self.resource_registry.lock();
+                    let registry = self.resource_registry.safe_lock();
                     let resource_uuid = resource.resource_uuid();
-                    if let Some(path) =
-                        resource_uuid.and_then(|resource_uuid| registry.uuid_to_path(resource_uuid))
-                    {
-                        Log::info(format!(
-                            "Resource {} destroyed because it is not used anymore!",
-                            path.display()
-                        ));
-
+                    if let Some(path) = registry.uuid_to_path(resource_uuid) {
+                        info!("Resource {path:?} destroyed because it is not used anymore!",);
                         self.event_broadcaster
                             .broadcast(ResourceEvent::Removed(path.to_path_buf()));
                     }
@@ -810,92 +1231,6 @@ impl ResourceManagerState {
                 true
             }
         });
-
-        if let Some(watcher) = self.watcher.as_ref() {
-            let mut changed_resources = FxHashSet::default();
-
-            if let Some(evt) = watcher.try_get_event() {
-                for path in evt.paths {
-                    let relative_path = ok_or_continue!(fyrox_core::make_relative_path(path));
-
-                    let mut registry = self.resource_registry.lock();
-                    if registry
-                        .excluded_folders
-                        .iter()
-                        .any(|folder| relative_path.starts_with(folder))
-                    {
-                        continue;
-                    }
-
-                    if !self.loaders.lock().is_supported_resource(&relative_path) {
-                        continue;
-                    }
-
-                    match evt.kind {
-                        notify::EventKind::Modify(_) => {
-                            changed_resources.insert(relative_path);
-                        }
-                        // The resource may be moved together with its metadata, so we need to check
-                        // if the resource is actually registered.
-                        notify::EventKind::Remove(_) if registry.is_registered(&relative_path) => {
-                            match registry.modify().remove_metadata(&relative_path) {
-                                Ok(_) => {
-                                    info!(
-                                        "The resource {} was unregistered successfully!",
-                                        relative_path.as_path().display(),
-                                    )
-                                }
-                                Err(err) => {
-                                    err!(
-                                        "Unable to unregister the resource {}. Reason: {err:?}",
-                                        relative_path.as_path().display()
-                                    )
-                                }
-                            }
-                        }
-                        notify::EventKind::Create(_) if !registry.is_registered(&relative_path) => {
-                            let uuid = Uuid::new_v4();
-                            match registry.modify().write_metadata(uuid, &relative_path) {
-                                Ok(old_path) => {
-                                    assert!(old_path.is_none());
-                                    info!(
-                                        "The resource {} was registered successfully with {} id!",
-                                        relative_path.as_path().display(),
-                                        uuid
-                                    )
-                                }
-                                Err(err) => {
-                                    err!(
-                                        "Unable to register the resource {}. Reason: {err:?}",
-                                        relative_path.as_path().display()
-                                    )
-                                }
-                            }
-                        }
-                        _ => {}
-                    }
-                }
-            }
-
-            if !changed_resources.is_empty() {
-                info!(
-                    "There's {} files changed in the project's directory. Trying to \
-                reload all supported resources...",
-                    changed_resources.len()
-                );
-            }
-
-            for path in changed_resources {
-                if self.try_reload_resource_from_path(&path) {
-                    Log::info(format!(
-                        "File {} was changed, trying to reload a respective resource...",
-                        path.display()
-                    ));
-
-                    break;
-                }
-            }
-        }
     }
 
     fn add_resource_and_notify(&mut self, resource: UntypedResource) {
@@ -916,7 +1251,7 @@ impl ResourceManagerState {
     pub fn find_by_uuid(&self, uuid: Uuid) -> Option<&UntypedResource> {
         self.resources
             .iter()
-            .find(|entry| entry.value.resource_uuid() == Some(uuid))
+            .find(|entry| entry.value.resource_uuid() == uuid)
             .map(|entry| &entry.value)
     }
 
@@ -926,13 +1261,10 @@ impl ResourceManagerState {
     ///
     /// O(n)
     pub fn find_by_path(&self, path: &Path) -> Option<&UntypedResource> {
-        let registry = self.resource_registry.lock();
+        let registry = self.resource_registry.safe_lock();
         self.resources.iter().find_map(|entry| {
-            let header = entry.value.0.lock();
-            if let ResourceState::Ok { resource_uuid, .. } = header.state {
-                if registry.uuid_to_path(resource_uuid) == Some(path) {
-                    return Some(&entry.value);
-                }
+            if registry.uuid_to_path(entry.resource_uuid()) == Some(path) {
+                return Some(&entry.value);
             }
             None
         })
@@ -961,24 +1293,12 @@ impl ResourceManagerState {
 
     /// Returns total amount of resources that still loading.
     pub fn count_pending_resources(&self) -> usize {
-        self.resources.iter().fold(0, |counter, resource| {
-            if let ResourceState::Pending { .. } = resource.0.lock().state {
-                counter + 1
-            } else {
-                counter
-            }
-        })
+        self.resources.iter().filter(|r| r.is_loading()).count()
     }
 
     /// Returns total amount of completely loaded resources.
     pub fn count_loaded_resources(&self) -> usize {
-        self.resources.iter().fold(0, |counter, resource| {
-            if let ResourceState::Ok { .. } = resource.0.lock().state {
-                counter + 1
-            } else {
-                counter
-            }
-        })
+        self.resources.iter().filter(|r| r.is_ok()).count()
     }
 
     /// Returns a set of resource handled by this container.
@@ -994,6 +1314,53 @@ impl ResourceManagerState {
         self.built_in_resources.add(resource)
     }
 
+    /// Searches the resource manager to find a resource with the given UUID, including built-in resources.
+    /// If no resource is found, a new UUID is generated and an unloaded resource is returned.
+    pub fn find_uuid(&mut self, uuid: Uuid) -> UntypedResource {
+        if let Some(built_in_resource) = self.built_in_resources.find_by_uuid(uuid) {
+            return built_in_resource.resource.clone();
+        }
+
+        if let Some(existing) = self.find_by_uuid(uuid) {
+            existing.clone()
+        } else {
+            let resource = UntypedResource::new_unloaded(uuid);
+            self.add_resource_and_notify(resource.clone());
+            resource
+        }
+    }
+
+    /// Searches the resource manager and the registry to find a resource with the given path,
+    /// including built-in resources. If no resource is found, a new UUID is generated and the
+    /// path is added to the registry and an unloaded resource is returned.
+    pub fn find<P>(&mut self, path: P) -> UntypedResource
+    where
+        P: AsRef<Path>,
+    {
+        if let Some(built_in_resource) = self.built_in_resources.get(path.as_ref()) {
+            return built_in_resource.resource.clone();
+        }
+
+        let path = ResourceRegistry::normalize_path(path);
+
+        if let Some(existing) = self.find_by_resource_path(&path) {
+            existing.clone()
+        } else {
+            let mut registry = self.resource_registry.safe_lock();
+            let uuid = if let Some(uuid) = registry.path_to_uuid(&path) {
+                uuid
+            } else {
+                let uuid = Uuid::new_v4();
+                registry.modify().register(uuid, path);
+                uuid
+            };
+            drop(registry);
+            let resource = UntypedResource::new_unloaded(uuid);
+            self.add_resource_and_notify(resource.clone());
+            resource
+        }
+    }
+
     /// Tries to load a resources at a given path.
     pub fn request<P>(&mut self, path: P) -> UntypedResource
     where
@@ -1008,55 +1375,88 @@ impl ResourceManagerState {
         self.find_or_load(path)
     }
 
+    /// Tries to load a resources at a given path.
+    pub fn request_uuid(&mut self, uuid: Uuid) -> UntypedResource {
+        let mut resource = uuid.into();
+        self.request_resource(&mut resource);
+        resource
+    }
+
+    /// Use the registry to find a resource with the given path, blocking until the registry is loaded if necessary.
     fn find_by_resource_path(&self, path_to_search: &Path) -> Option<&UntypedResource> {
+        let registry = self.resource_registry.safe_lock();
         self.resources
             .iter()
-            .find(|entry| {
-                let header = entry.value.0.lock();
-                match header.state {
-                    ResourceState::Pending { ref path, .. }
-                    | ResourceState::LoadError { ref path, .. } => path == path_to_search,
-                    ResourceState::Ok { resource_uuid, .. } => {
-                        self.resource_registry.lock().uuid_to_path(resource_uuid)
-                            == Some(path_to_search)
-                    }
-                }
-            })
+            .find(move |entry| registry.uuid_to_path(entry.resource_uuid()) == Some(path_to_search))
             .map(|entry| &entry.value)
     }
 
+    /// If a resource exists for the given path, return it.
+    /// Otherwise, check the registry for a UUID for the path, create
+    /// a resource, begin loading, and return the resource.
+    /// If the given path does not correspond to any registered UUID,
+    /// create and return an error resource.
     fn find_or_load(&mut self, path: PathBuf) -> UntypedResource {
         match self.find_by_resource_path(&path) {
             Some(existing) => existing.clone(),
-            None => {
-                let resource = UntypedResource::new_pending(path.clone(), ResourceKind::External);
-                self.add_resource_and_notify(resource.clone());
-                self.spawn_loading_task(path, resource.clone(), false);
-                resource
-            }
+            None => self.load_resource(path),
         }
     }
 
-    fn spawn_loading_task(&self, path: PathBuf, resource: UntypedResource, reload: bool) {
+    fn load_resource(&mut self, path: PathBuf) -> UntypedResource {
+        let mut registry = self.resource_registry.safe_lock();
+        let uuid = if let Some(uuid) = registry.path_to_uuid(&path) {
+            uuid
+        } else {
+            let uuid = Uuid::new_v4();
+            registry.modify().register(uuid, path);
+            uuid
+        };
+        drop(registry);
+        let resource = UntypedResource::new_pending(uuid, ResourceKind::External);
+        self.add_resource_and_notify(resource.clone());
+        self.spawn_loading_task(resource.clone(), false);
+        resource
+    }
+
+    /// Add a task to the task pool to load the given resource.
+    /// Panic if the given resource is unregistered or embedded.
+    fn spawn_loading_task(&self, mut resource: UntypedResource, reload: bool) {
         let event_broadcaster = self.event_broadcaster.clone();
         let loaders = self.loaders.clone();
         let registry = self.resource_registry.clone();
         let io = self.resource_io.clone();
-        let registry_status = registry.lock().status_flag();
+        let registry_status = registry.safe_lock().status_flag();
 
         self.task_pool.spawn_task(async move {
             // Wait until the registry is fully loaded.
             let registry_status = registry_status.await;
             if registry_status == ResourceRegistryStatus::Unknown {
-                let error = "The resource registry is unavailable!".to_string();
-                Log::err(&error);
-                resource.commit_error(path.clone(), LoadError::new(error));
+                resource.commit_error(
+                    PathBuf::default(),
+                    LoadError::new("The resource registry is unavailable!".to_string()),
+                );
                 return;
             }
 
+            let Some(path) = registry
+                .safe_lock()
+                .uuid_to_path(resource.resource_uuid())
+                .map(|p| p.to_path_buf())
+            else {
+                let error = format!(
+                    "Resource {} failed to load. The path was not found \
+                        in the registry!",
+                    resource.resource_uuid(),
+                );
+
+                resource.commit_error(PathBuf::default(), error);
+                return;
+            };
+
             // Try to find a loader for the resource.
             let loader_future = loaders
-                .lock()
+                .safe_lock()
                 .loader_for(&path)
                 .map(|loader| loader.load(path.clone(), io));
 
@@ -1065,99 +1465,50 @@ impl ResourceManagerState {
                     Ok(data) => {
                         let data = data.0;
 
-                        // Creating this p variable causes the lock to be dropped
-                        // before the match. If we put the expression directly into the
-                        // match, then it would not be dropped until after, which would mean
-                        // holding the registry lock while we resource header, which can cause
-                        // a deadlock.
-                        let p = registry.lock().path_to_uuid(&path);
-                        match p {
-                            Some(resource_uuid) => {
-                                let mut mutex_guard = resource.0.lock();
+                        let mut header = resource.lock();
 
-                                assert!(mutex_guard.kind.is_external());
+                        assert!(header.kind.is_external());
 
-                                mutex_guard.state.commit(ResourceState::Ok {
-                                    data: ResourceDataWrapper(data),
-                                    resource_uuid,
-                                });
+                        header.state.commit(ResourceState::Ok {
+                            data: ResourceDataWrapper(data),
+                        });
 
-                                drop(mutex_guard);
+                        drop(header);
 
-                                event_broadcaster.broadcast_loaded_or_reloaded(resource, reload);
+                        event_broadcaster.broadcast_loaded_or_reloaded(resource, reload);
 
-                                info!("Resource {} was loaded successfully!", path.display());
-                            }
-                            None => {
-                                let error = format!(
-                                    "Resource {} failed to load. The path was not found \
-                                        in the registry!",
-                                    path.display(),
-                                );
-
-                                Log::err(&error);
-
-                                // Do not replace the ok resource with the error if reloading has
-                                // failed.
-                                if !reload {
-                                    resource.commit_error(path, error);
-                                }
-                            }
-                        }
+                        Log::info(format!(
+                            "Resource {} was loaded successfully!",
+                            path.display()
+                        ));
                     }
                     Err(error) => {
-                        err!(
-                            "Resource {} failed to load. Reason: {:?}",
-                            path.display(),
-                            error
-                        );
+                        Log::info(format!(
+                            "Resource {path:?} failed to load. Reason: {error:?}",
+                        ));
 
-                        // Do not replace the ok resource with the error if reloading has
-                        // failed.
-                        if !reload {
-                            resource.commit_error(path, error);
-                        }
+                        resource.commit_error(path.to_path_buf(), error);
                     }
                 }
-            } else if !reload {
-                let err_msg = format!(
-                    "There's no resource loader for {} resource!",
-                    path.display()
-                );
-
-                Log::err(&err_msg);
-
-                resource.commit_error(path.clone(), LoadError::new(err_msg))
+            } else {
+                let error = format!("There's no resource loader for {path:?} resource!",);
+                resource.commit_error(path, error);
             }
         });
     }
 
     /// Tries to fetch a path of the given untyped resource. The path may be missing in a few cases:
     ///
-    /// 1) The resource is in invalid state (not in [`ResourceState::Ok`]).
-    /// 2) The resource wasn't registered in the resource registry.
-    /// 3) The resource registry wasn't loaded.
+    /// 1) The resource wasn't registered in the resource registry.
+    /// 2) The resource registry wasn't loaded.
     ///
     /// ## Built-in resources
     ///
     /// As a last resort, this method tries to find a built-in resource descriptor corresponding
     /// to the given resource and returns its "path". In reality, it is just a string id, since
     /// built-in resources are stored inside the binary.
-    pub fn resource_path(&self, resource: impl AsRef<UntypedResource>) -> Option<PathBuf> {
-        let header = resource.as_ref().0.lock();
-        if let ResourceState::Ok { resource_uuid, .. } = header.state {
-            let registry = self.resource_registry.lock();
-            if let Some(path) = registry.uuid_to_path_buf(resource_uuid) {
-                Some(path)
-            } else {
-                drop(header);
-                self.built_in_resources
-                    .find_by_uuid(resource_uuid)
-                    .map(|built_in_resource| built_in_resource.id.clone())
-            }
-        } else {
-            None
-        }
+    pub fn resource_path(&self, resource: &UntypedResource) -> Option<PathBuf> {
+        self.uuid_to_resource_path(resource.resource_uuid())
     }
 
     /// Tries to fetch a resource path associated with the given UUID. Returns [`None`] if there's
@@ -1171,7 +1522,7 @@ impl ResourceManagerState {
     pub fn uuid_to_resource_path(&self, resource_uuid: Uuid) -> Option<PathBuf> {
         if let Some(path) = self
             .resource_registry
-            .lock()
+            .safe_lock()
             .uuid_to_path_buf(resource_uuid)
         {
             Some(path)
@@ -1184,74 +1535,102 @@ impl ResourceManagerState {
 
     /// Adds a new resource loader of the given type.
     pub fn add_loader<T: ResourceLoader>(&self, loader: T) -> Option<T> {
-        self.loaders.lock().set(loader)
+        self.loaders.safe_lock().set(loader)
     }
 
-    /// Saves given resources in the specified path and registers it in resource manager, so
-    /// it will be accessible through it later.
+    /// Tries to load the given resource, based on the resource's UUID,
+    /// and adds the resource to the manager if it is not already in the manager.
+    pub fn request_resource(&mut self, resource: &mut UntypedResource) {
+        if let Some(r) = self.find_by_uuid(resource.resource_uuid()) {
+            // We are already managing a resource with this UUID, so modify the given
+            // resource to point to our resource.
+            *resource = r.clone();
+            if resource.is_unloaded() {
+                // If the resource is in the unloaded state, start it loading, because it has been requested.
+                resource.make_pending();
+                self.spawn_loading_task(resource.clone(), false);
+            }
+        } else if let Some(r) = self
+            .built_in_resources
+            .find_by_uuid(resource.resource_uuid())
+        {
+            // A built-in resource has this UUID, so modify the given resource to
+            // point to the built-in resource.
+            *resource = r.resource.clone();
+        } else if resource.is_ok() || resource.is_embedded() {
+            // This is an unknown resource, but it is ready to use, so add it to our managed
+            // resources.
+            self.add_resource_and_notify(resource.clone());
+        } else {
+            // This is an unknown resource and it is not ready to use, so add it to our managed
+            // resources and begin the loading process.
+            resource.make_pending();
+            self.add_resource_and_notify(resource.clone());
+            self.spawn_loading_task(resource.clone(), false);
+        }
+    }
+
+    /// Add the given resource to the resource manager, based on the resource's UUID,
+    /// without initiating the loading of the resource. The given resource may be modified
+    /// to be a reference to the shared data of an existing resource with the same UUID.
+    pub fn add_resource(&mut self, resource: &mut UntypedResource) {
+        if let Some(r) = self.find_by_uuid(resource.resource_uuid()) {
+            // We are already managing a resource with this UUID, so modify the given
+            // resource to point to our resource.
+            *resource = r.clone();
+        } else if let Some(r) = self
+            .built_in_resources
+            .find_by_uuid(resource.resource_uuid())
+        {
+            // A built-in resource has this UUID, so modify the given resource to
+            // point to the built in resource.
+            *resource = r.resource.clone();
+        } else {
+            // This is an unknown resource, so add it to our managed resources.
+            self.add_resource_and_notify(resource.clone());
+        }
+    }
+
+    /// Add the given resource to the manager and registers the resource as an external resource with the given
+    /// path, updating the metadata file with the resource's UUID and updating the registry file with the resource's path.
+    /// Calling this should only be necessary after newly creating the file in the given path by saving the resource
+    /// to the file, otherwise the resource's path should already have been discovered by
+    /// [`ResourceManagerState::update_or_load_registry`].
+    /// If the manager already has a resource with this resource's UUID, return [`ResourceRegistrationError::AlreadyRegistered`].
     pub fn register(
         &mut self,
         resource: UntypedResource,
         path: impl AsRef<Path>,
     ) -> Result<(), ResourceRegistrationError> {
-        let path = ResourceRegistry::normalize_path(path);
-
-        let resource_uuid = resource
-            .resource_uuid()
-            .ok_or(ResourceRegistrationError::InvalidState)?;
-
+        let resource_uuid = resource.resource_uuid();
         if self.find_by_uuid(resource_uuid).is_some() {
             return Err(ResourceRegistrationError::AlreadyRegistered);
         }
-
-        let mut resource_header = resource.0.lock();
-        resource_header.kind.make_external();
-        if let ResourceState::Ok { resource_uuid, .. } = resource_header.state {
-            let mut registry = self.resource_registry.lock();
+        let path = ResourceRegistry::normalize_path(path);
+        {
+            let mut header = resource.lock();
+            header.kind.make_external();
+            let mut registry = self.resource_registry.safe_lock();
             let mut ctx = registry.modify();
-            ctx.write_metadata(resource_uuid, path)
-                .map_err(|_| ResourceRegistrationError::UnableToCreateMetadata)?;
-            drop(ctx);
-            drop(registry);
-            drop(resource_header);
-            self.add_resource_and_notify(resource);
-            Ok(())
-        } else {
-            Err(ResourceRegistrationError::InvalidState)
+            if ctx.write_metadata(resource_uuid, path).is_err() {
+                return Err(ResourceRegistrationError::UnableToCreateMetadata);
+            }
         }
+        self.add_resource_and_notify(resource);
+        Ok(())
     }
 
     /// Reloads a single resource. Does nothing in case of built-in resources.
+    /// Log an error if the resource cannot be reloaded.
     pub fn reload_resource(&mut self, resource: UntypedResource) {
         if self.built_in_resources.is_built_in_resource(&resource) {
             return;
         }
-
-        let header = resource.0.lock();
-        match header.state {
-            ResourceState::Pending { .. } => {
-                // The resource is loading already.
-            }
-            ResourceState::LoadError { ref path, .. } => {
-                let path = path.clone();
-                drop(header);
-                self.spawn_loading_task(path, resource, true)
-            }
-            ResourceState::Ok { resource_uuid, .. } => {
-                let path = self
-                    .resource_registry
-                    .lock()
-                    .uuid_to_path_buf(resource_uuid);
-                if let Some(path) = path {
-                    drop(header);
-                    self.spawn_loading_task(path, resource, true);
-                } else {
-                    err!(
-                        "Unable to reload a {resource_uuid} resource, because it is not \
-                    registered in the resource registry and its path is unknown! "
-                    );
-                }
-            }
+        let mut header = resource.lock();
+        if !header.state.is_loading() {
+            header.state.switch_to_pending_state();
+            drop(header);
+            self.spawn_loading_task(resource, true)
         }
     }
 
@@ -1282,39 +1661,25 @@ impl ResourceManagerState {
         }
     }
 
-    /// Tries to reload a resource at the given path.
+    /// Tries to reload a resource at the given path, and returns true if a reload will
+    /// actually begin. Returns false if the resource was already loading or
+    /// cannot be reloaded.
     pub fn try_reload_resource_from_path(&mut self, path: &Path) -> bool {
         // Do not try to reload unsupported resources.
-        if !self.loaders.lock().is_supported_resource(path) {
+        if !self.loaders.safe_lock().is_supported_resource(path) {
             return false;
         }
 
-        if let Some(resource) = self.find_by_resource_path(path) {
-            if resource.0.lock().state.is_loading() {
-                return false;
-            }
-
-            self.reload_resource(resource.clone());
-            return true;
-        }
-
-        false
-    }
-
-    /// Forgets that a resource at the given path was ever loaded, thus making it possible to reload it
-    /// again as a new instance.
-    pub fn unregister(&mut self, path: &Path) {
-        let mut registry = self.resource_registry.lock();
-        let mut ctx = registry.modify();
-        if let Some(uuid) = ctx.unregister_path(path) {
-            if let Some(position) = self
-                .resources
-                .iter()
-                .position(|entry| entry.value.resource_uuid() == Some(uuid))
-            {
-                self.resources.remove(position);
-            }
+        let Some(resource) = self.find_by_resource_path(path) else {
+            return false;
+        };
+        let header = resource.lock();
+        if header.state.is_loading() {
+            return false;
         }
+        drop(header);
+        self.reload_resource(resource.clone());
+        true
     }
 
     /// Creates a resource movement context.
@@ -1347,7 +1712,7 @@ impl ResourceManagerState {
             });
         }
 
-        let registry_lock_guard = self.resource_registry.lock();
+        let registry_lock_guard = self.resource_registry.safe_lock();
         let absolute_registry_dir = if let Some(directory) = registry_lock_guard.directory() {
             fyrox_core::replace_slashes(self.resource_io.canonicalize_path(directory).await?)
         } else {
@@ -1429,10 +1794,10 @@ impl ResourceManagerState {
 
         let current_path = self
             .resource_registry
-            .lock()
+            .safe_lock()
             .modify()
             .register(resource_uuid, relative_dest_path.to_path_buf());
-        assert_eq!(current_path.as_ref(), Some(&relative_src_path));
+        assert_eq!(current_path.value.as_ref(), Some(&relative_src_path));
 
         let options_path = append_extension(&relative_src_path, OPTIONS_EXTENSION);
         if self.resource_io.exists(&options_path).await {
@@ -1463,7 +1828,7 @@ impl ResourceManagerState {
         new_path: impl AsRef<Path>,
         overwrite_existing: bool,
     ) -> Result<(), ResourceMovementError> {
-        let resource_path = self.resource_path(resource).ok_or_else(|| {
+        let resource_path = self.resource_path(resource.as_ref()).ok_or_else(|| {
             FileError::Custom(
                 "Cannot move the resource because it does not have a path!".to_string(),
             )
@@ -1479,14 +1844,14 @@ impl ResourceManagerState {
         let ext = some_or_return!(ext.to_str(), false);
 
         self.loaders
-            .lock()
+            .safe_lock()
             .iter()
             .any(|loader| loader.supports_extension(ext))
     }
 
     /// Checks if the given path is located inside the folder tracked by the resource registry.
     pub fn is_path_in_registry(&self, path: &Path) -> bool {
-        let registry = self.resource_registry.lock();
+        let registry = self.resource_registry.safe_lock();
         if let Some(registry_directory) = registry.directory() {
             if let Ok(canonical_registry_path) = registry_directory.canonicalize() {
                 if let Ok(canonical_path) = path.canonicalize() {
@@ -1624,7 +1989,11 @@ mod test {
         let cx = ResourceWaitContext {
             resources: vec![
                 UntypedResource::new_pending(Default::default(), ResourceKind::External),
-                UntypedResource::new_load_error(ResourceKind::External, Default::default()),
+                UntypedResource::new_load_error(
+                    ResourceKind::External,
+                    Default::default(),
+                    LoadError::default(),
+                ),
             ],
         };
         assert!(!cx.is_all_loaded());
@@ -1635,7 +2004,7 @@ mod test {
         let state = new_resource_manager();
 
         assert!(state.resources.is_empty());
-        assert!(state.loaders.lock().is_empty());
+        assert!(state.loaders.safe_lock().is_empty());
         assert!(state.built_in_resources.is_empty());
         assert!(state.constructors_container.is_empty());
         assert!(state.watcher.is_none());
@@ -1657,6 +2026,7 @@ mod test {
 
     #[test]
     fn resource_manager_state_push() {
+        std::fs::create_dir_all("data").expect("Could not create data directory.");
         let mut state = new_resource_manager();
 
         assert_eq!(state.count_loaded_resources(), 0);
@@ -1664,30 +2034,31 @@ mod test {
         assert_eq!(state.count_registered_resources(), 0);
         assert_eq!(state.len(), 0);
 
-        assert_eq!(
-            state.register(
+        assert!(state
+            .register(
                 UntypedResource::new_pending(Default::default(), ResourceKind::External),
                 "foo.bar",
-            ),
-            Err(ResourceRegistrationError::InvalidState)
-        );
-        assert_eq!(
-            state.register(
-                UntypedResource::new_load_error(ResourceKind::External, Default::default()),
+            )
+            .is_ok());
+        assert!(state
+            .register(
+                UntypedResource::new_load_error(
+                    ResourceKind::External,
+                    Default::default(),
+                    LoadError::default()
+                ),
                 "foo.bar",
-            ),
-            Err(ResourceRegistrationError::InvalidState)
-        );
-        assert_eq!(
-            state.register(
+            )
+            .is_ok());
+        assert!(state
+            .register(
                 UntypedResource::new_ok(Uuid::new_v4(), Default::default(), Stub {}),
                 "foo.bar",
-            ),
-            Ok(())
-        );
+            )
+            .is_ok());
 
-        assert_eq!(state.count_registered_resources(), 1);
-        assert_eq!(state.len(), 1);
+        assert_eq!(state.count_registered_resources(), 3);
+        assert_eq!(state.len(), 3);
     }
 
     #[test]
@@ -1785,22 +2156,40 @@ mod test {
     fn resource_manager_new() {
         let manager = ResourceManager::new(Arc::new(FsResourceIo), Arc::new(Default::default()));
 
-        assert!(manager.state.lock().is_empty());
+        assert!(manager.state.safe_lock().is_empty());
         assert!(manager.state().is_empty());
     }
 
     #[test]
     fn resource_manager_register() {
+        std::fs::create_dir_all("data").expect("Could not create data directory.");
         let manager = ResourceManager::new(Arc::new(FsResourceIo), Arc::new(Default::default()));
         let path = PathBuf::from("test.txt");
+        let metapath = append_extension(&path, ResourceMetadata::EXTENSION);
 
         let resource = UntypedResource::new_pending(Default::default(), ResourceKind::External);
         let res = manager.register(resource.clone(), path.clone());
-        assert!(res.is_err());
+        assert!(res.is_ok());
 
-        let resource = UntypedResource::new_ok(Uuid::new_v4(), ResourceKind::External, Stub {});
+        let metadata = block_on(ResourceMetadata::load_from_file_async(
+            &metapath,
+            &*manager.resource_io(),
+        ))
+        .expect("Reading meta file failed");
+        assert_eq!(resource.resource_uuid(), metadata.resource_id);
+
+        let uuid = Uuid::new_v4();
+        let resource = UntypedResource::new_ok(uuid, ResourceKind::External, Stub {});
         let res = manager.register(resource.clone(), path.clone());
         assert!(res.is_ok());
+
+        assert_eq!(resource.resource_uuid(), uuid);
+        let metadata = block_on(ResourceMetadata::load_from_file_async(
+            &metapath,
+            &*manager.resource_io(),
+        ))
+        .expect("Reading meta file failed");
+        assert_eq!(metadata.resource_id, uuid);
     }
 
     #[test]
diff --git a/fyrox-resource/src/registry.rs b/fyrox-resource/src/registry.rs
index bf697c5fc..2acfe58b4 100644
--- a/fyrox-resource/src/registry.rs
+++ b/fyrox-resource/src/registry.rs
@@ -32,7 +32,7 @@ use crate::{
     state::WakersList,
 };
 use fxhash::FxHashSet;
-use fyrox_core::SafeLock;
+use fyrox_core::{futures::executor::block_on, SafeLock};
 use ron::ser::PrettyConfig;
 use std::{
     collections::BTreeMap,
@@ -77,7 +77,7 @@ impl RegistryContainerExt for RegistryContainer {
         resource_io.load_file(path).await.and_then(|metadata| {
             ron::de::from_bytes::<Self>(&metadata).map_err(|err| {
                 FileError::Custom(format!(
-                    "Unable to deserialize the resource registry. Reason: {err:?}"
+                    "Unable to deserialize the resource registry. Reason: {err}"
                 ))
             })
         })
@@ -221,30 +221,49 @@ async fn make_relative_path_async<P: AsRef<Path>>(
 /// [`std::mem::forget`] after you've finished working with the mutable reference.
 pub struct ResourceRegistryRefMut<'a> {
     registry: &'a mut ResourceRegistry,
+    changed: bool,
+}
+
+/// A value returned from an update operation to a [`ResourceRegistryRefMut`],
+/// including a flag that indicates whether the operation changed the registry.
+pub struct RegistryUpdate<T> {
+    /// True if the registry was changed.
+    pub changed: bool,
+    /// The value produced by the operation.
+    pub value: T,
 }
 
 impl ResourceRegistryRefMut<'_> {
+    /// Read the metadata from the file at the given path.
+    pub fn read_metadata(
+        &mut self,
+        path: PathBuf,
+    ) -> Result<RegistryUpdate<ResourceMetadata>, FileError> {
+        let value = block_on(ResourceMetadata::load_from_file_async(
+            &append_extension(&path, ResourceMetadata::EXTENSION),
+            &*self.registry.io,
+        ))?;
+        let changed = self.register(value.resource_id, path).changed;
+        Ok(RegistryUpdate { changed, value })
+    }
     /// Writes the new metadata file for a resource at the given path and registers the resource
     /// in the registry.
     pub fn write_metadata(
         &mut self,
         uuid: Uuid,
-        path: impl AsRef<Path>,
-    ) -> Result<Option<PathBuf>, FileError> {
+        path: PathBuf,
+    ) -> Result<RegistryUpdate<Option<PathBuf>>, FileError> {
         ResourceMetadata { resource_id: uuid }.save_sync(
-            &append_extension(path.as_ref(), ResourceMetadata::EXTENSION),
+            &append_extension(&path, ResourceMetadata::EXTENSION),
             &*self.registry.io,
         )?;
-
-        Ok(self.register(uuid, path.as_ref().to_path_buf()))
+        Ok(self.register(uuid, path))
     }
 
     /// Unregisters the resource at the given path (if any) from the registry and deletes its
     /// associated metadata file.
     pub fn remove_metadata(&mut self, path: impl AsRef<Path>) -> Result<(), FileError> {
-        if let Some(uuid) = self.registry.path_to_uuid(path.as_ref()) {
-            self.unregister(uuid);
-
+        if self.unregister_path(&path).is_some() {
             let metadata_path = append_extension(path.as_ref(), ResourceMetadata::EXTENSION);
 
             self.registry.io.delete_file_sync(&metadata_path)?;
@@ -252,38 +271,83 @@ impl ResourceRegistryRefMut<'_> {
             Ok(())
         } else {
             Err(FileError::Custom(format!(
-                "The {} resource is not registered in the registry!",
-                path.as_ref().display()
+                "The {:?} resource is not registered in the registry!",
+                path.as_ref()
             )))
         }
     }
 
-    /// Registers a new pair `UUID -> Path`.
-    pub fn register(&mut self, uuid: Uuid, path: PathBuf) -> Option<PathBuf> {
-        self.registry.paths.insert(uuid, path)
+    /// Registers a new pair `UUID -> Path`, and returns the former path for this UUID.
+    pub fn register(&mut self, uuid: Uuid, path: PathBuf) -> RegistryUpdate<Option<PathBuf>> {
+        if path.as_os_str().is_empty() {
+            panic!("Registering empty path.");
+        }
+        use std::collections::btree_map::Entry;
+        //self.registry.paths.insert(uuid, path)
+        match self.registry.paths.entry(uuid) {
+            Entry::Vacant(entry) => {
+                info!("Registered: {uuid} -> {path:?}");
+                self.changed = true;
+                entry.insert(path);
+                RegistryUpdate {
+                    changed: true,
+                    value: None,
+                }
+            }
+            Entry::Occupied(mut entry) => {
+                let changed = entry.get() != &path;
+                if changed {
+                    info!("Registry update: {uuid} -> {path:?}");
+                    self.changed = true;
+                }
+                let value = Some(entry.insert(path));
+                RegistryUpdate { changed, value }
+            }
+        }
     }
 
-    /// Unregisters a resource path with the given UUID.
+    /// Unregisters a resource path with the given UUID, and returns the former path for the Uuid, if it was registered.
     pub fn unregister(&mut self, uuid: Uuid) -> Option<PathBuf> {
-        self.registry.paths.remove(&uuid)
+        let former = self.registry.paths.remove(&uuid);
+        if former.is_some() {
+            info!("Registry remove UUID: {uuid} -> {former:?}");
+            self.changed = true;
+        }
+        former
     }
 
-    /// Unregisters a resource path.
-    pub fn unregister_path(&mut self, path: &Path) -> Option<Uuid> {
+    /// Unregisters a resource path, and returns the UUID if the given path was previously registered.
+    pub fn unregister_path(&mut self, path: impl AsRef<Path>) -> Option<Uuid> {
+        let path = path.as_ref();
         let uuid = self.registry.path_to_uuid(path)?;
+        info!("Registry remove path: {uuid} -> {path:?}");
+        self.changed = true;
         self.registry.paths.remove(&uuid);
         Some(uuid)
     }
 
     /// Completely replaces the internal storage.
     pub fn set_container(&mut self, registry_container: RegistryContainer) {
+        if self.registry.paths == registry_container {
+            return;
+        }
+        // Log the new registrations.
+        let current = &self.registry.paths;
+        for (uuid, path) in &registry_container {
+            if current.get(uuid) != Some(path) {
+                info!("Resource {path:?} was registered with {uuid} UUID.");
+            }
+        }
+        self.changed = true;
         self.registry.paths = registry_container;
     }
 }
 
 impl Drop for ResourceRegistryRefMut<'_> {
     fn drop(&mut self) {
-        self.registry.save_sync();
+        if self.changed {
+            self.registry.save_sync();
+        }
     }
 }
 
@@ -291,8 +355,17 @@ impl Drop for ResourceRegistryRefMut<'_> {
 /// `UUID -> Resource Path`.
 #[derive(Clone)]
 pub struct ResourceRegistry {
+    /// The path to which the resource registry is (or may) be saved.
     path: PathBuf,
+    /// The UUIDs registered for each resource and the corresponding path of the resource.
+    /// These UUIDs should be read from the registry file or from the meta file associated with the resource.
+    /// They may also be randomly generated if a path is requested that does not have a meta file, in which
+    /// case the random UUID is dynamically added to the registry.
     paths: RegistryContainer,
+    /// A shared flag that can be used to fetch the current status of a resource registry. This
+    /// supports the [`Future`] trait, which means that you can `.await` it in an async context to wait
+    /// until the registry is fully loaded (or failed to load). Any access to the registry in an async
+    /// context must be guarded with such `.await` call.
     status: ResourceRegistryStatusFlag,
     io: Arc<dyn ResourceIo>,
     /// A list of folder that should be excluded when scanning the project folder for supported
@@ -387,16 +460,13 @@ impl ResourceRegistry {
         match self.paths.save(&self.path, &*self.io).await {
             Err(error) => {
                 err!(
-                    "Unable to write the resource registry at the {} path! Reason: {:?}",
-                    self.path.display(),
+                    "Unable to write the resource registry at the {:?} path! Reason: {:?}",
+                    self.path,
                     error
                 )
             }
             Ok(_) => {
-                info!(
-                    "The registry was successfully saved to {}!",
-                    self.path.display()
-                )
+                info!("The registry was successfully saved to {:?}!", self.path)
             }
         }
     }
@@ -425,7 +495,10 @@ impl ResourceRegistry {
 
     /// Begins registry modification. See [`ResourceRegistryRefMut`] docs for more info.
     pub fn modify(&mut self) -> ResourceRegistryRefMut<'_> {
-        ResourceRegistryRefMut { registry: self }
+        ResourceRegistryRefMut {
+            changed: false,
+            registry: self,
+        }
     }
 
     /// Tries to get a path associated with the given resource UUID.
@@ -452,7 +525,7 @@ impl ResourceRegistry {
 
     /// Searches for supported resources starting from the given path and builds a mapping `UUID -> Path`.
     /// If a supported resource does not have a metadata file besides it, this method will automatically
-    /// add it with a new UUID and add the resource to the registry.
+    /// create the metadata file with a new UUID and add the resource to the registry.
     ///
     /// This method does **not** load any resource, instead it checks extension of every file in the
     /// given directory, and if there's a loader for it, "remember" the resource.
@@ -486,21 +559,14 @@ impl ResourceRegistry {
                 Ok(path) => path,
                 Err(err) => {
                     warn!(
-                        "Unable to make relative path from {} path! The resource won't be \
-                    included in the registry! Reason: {:?}",
-                        fs_path.display(),
-                        err
+                        "Unable to make relative path from {fs_path:?} path! The resource won't be \
+                    included in the registry! Reason: {err:?}",
                     );
                     continue;
                 }
             };
 
             if excluded_folders.contains(&path) {
-                warn!(
-                    "Skipping {} folder, because it is in the excluded folders list!",
-                    path.display()
-                );
-
                 continue;
             }
 
@@ -514,60 +580,34 @@ impl ResourceRegistry {
             }
 
             if !loaders.safe_lock().is_supported_resource(&path) {
-                if path
-                    .extension()
-                    .is_some_and(|ext| ext != "meta" && ext != "registry")
-                {
-                    info!(
-                        "Skipping {} file, because there's no loader for it.",
-                        path.display()
-                    );
-                }
-
                 continue;
             }
 
             let metadata_path = append_extension(&path, ResourceMetadata::EXTENSION);
-            let metadata =
-                match ResourceMetadata::load_from_file_async(&metadata_path, &*resource_io).await {
-                    Ok(metadata) => metadata,
-                    Err(err) => {
-                        warn!(
-                            "Unable to load metadata for {} resource. Reason: {:?}, The metadata \
+            let metadata = match ResourceMetadata::load_from_file_async(
+                &metadata_path,
+                &*resource_io,
+            )
+            .await
+            {
+                Ok(metadata) => metadata,
+                Err(err) => {
+                    warn!(
+                            "Unable to load metadata for {path:?} resource. Reason: {err}. The metadata \
                             file will be added/recreated, do **NOT** delete it! Add it to the \
                             version control!",
-                            path.display(),
-                            err
                         );
-                        let new_metadata = ResourceMetadata::new_with_random_id();
-                        if let Err(err) =
-                            new_metadata.save_async(&metadata_path, &*resource_io).await
-                        {
-                            warn!(
-                                "Unable to save resource {} metadata. Reason: {:?}",
-                                path.display(),
-                                err
-                            );
-                        }
-                        new_metadata
+                    let new_metadata = ResourceMetadata::new_with_random_id();
+                    if let Err(err) = new_metadata.save_async(&metadata_path, &*resource_io).await {
+                        warn!("Unable to save resource {path:?} metadata. Reason: {err}");
                     }
-                };
+                    new_metadata
+                }
+            };
 
-            if container
-                .insert(metadata.resource_id, path.clone())
-                .is_some()
-            {
-                warn!(
-                    "Resource UUID collision occurred for {} resource!",
-                    path.display()
-                );
+            if let Some(former) = container.insert(metadata.resource_id, path.clone()) {
+                warn!("Resource UUID collision between {path:?} and {former:?}");
             }
-
-            info!(
-                "Resource {} was registered with {} UUID.",
-                path.display(),
-                metadata.resource_id
-            );
         }
 
         container
diff --git a/fyrox-resource/src/state.rs b/fyrox-resource/src/state.rs
index a97dfbaa9..babc0e2e1 100644
--- a/fyrox-resource/src/state.rs
+++ b/fyrox-resource/src/state.rs
@@ -20,16 +20,10 @@
 
 //! A module that handles resource states.
 
-use crate::untyped::ResourceKind;
-use crate::{
-    core::{reflect::prelude::*, uuid::Uuid, visitor::prelude::*},
-    manager::ResourceManager,
-    ResourceData, ResourceLoadError, TypedResourceData,
-};
+use crate::{core::reflect::prelude::*, ResourceData, ResourceLoadError, TypedResourceData};
 use fyrox_core::reflect::ReflectHandle;
-use fyrox_core::warn;
 use std::any::{Any, TypeId};
-use std::fmt::Display;
+use std::fmt::{Debug, Display};
 use std::path::PathBuf;
 use std::{
     ops::{Deref, DerefMut},
@@ -277,18 +271,15 @@ impl Clone for ResourceDataWrapper {
 /// to get the UUID earlier: the UUID is stored in a metadata file which exists only if the resource
 /// is present. It is somewhat possible to get a UUID when a resource is failed to load, but not in
 /// 100% cases.
-#[derive(Debug, Clone, Reflect)]
+#[derive(Clone, Reflect)]
 pub enum ResourceState {
+    /// Resource is not loaded. In some situations, having a handle to a resource
+    /// can be sufficient even without the resource's data.
+    Unloaded,
     /// Resource is loading from external resource or in the queue to load.
     Pending {
         /// List of wakers to wake future when resource is fully loaded.
         wakers: WakersList,
-        /// A resource path (explicit or implicit). It is used at the loading stage to get a
-        /// real path in the file system. Since resource registry loading is async (especially
-        /// on WASM), it is impossible to fetch the uuid by path immediately. Instead, the resource
-        /// system offloads this task to resource loading tasks, which are able to wait until the
-        /// registry is fully loaded.
-        path: PathBuf,
     },
     /// An error has occurred during the load.
     LoadError {
@@ -300,19 +291,45 @@ pub enum ResourceState {
     },
     /// Actual resource data when it is fully loaded.
     Ok {
-        /// Unique id of the resource.
-        resource_uuid: Uuid,
         /// Actual data of the resource.
         data: ResourceDataWrapper,
     },
 }
 
+impl Debug for ResourceState {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Unloaded => write!(f, "Unloaded"),
+            Self::Pending { .. } => write!(f, "Pending"),
+            Self::LoadError { path, error } => write!(f, "LoadError {:?}: {:?}", error, path),
+            Self::Ok { .. } => write!(f, "Ok"),
+        }
+    }
+}
+
+impl Display for ResourceState {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Unloaded => write!(f, "Unloaded"),
+            Self::Pending { .. } => write!(f, "Pending"),
+            Self::LoadError { path, error } => {
+                if path.as_os_str().is_empty() {
+                    write!(f, "{} (for unknown path)", error)
+                } else {
+                    write!(f, "{} (for {:?})", error, path)
+                }
+            }
+            Self::Ok { .. } => write!(f, "Ok"),
+        }
+    }
+}
+
 impl Default for ResourceState {
     fn default() -> Self {
-        Self::LoadError {
-            path: Default::default(),
-            error: Default::default(),
-        }
+        ResourceState::new_load_error(
+            Default::default(),
+            LoadError::new("Default resource state of unknown type."),
+        )
     }
 }
 
@@ -325,78 +342,11 @@ impl Drop for ResourceState {
 }
 
 impl ResourceState {
-    pub(crate) fn visit(
-        &mut self,
-        kind: ResourceKind,
-        name: &str,
-        visitor: &mut Visitor,
-    ) -> VisitResult {
-        if visitor.is_reading() {
-            let mut type_uuid = Uuid::default();
-            type_uuid.visit("TypeUuid", visitor)?;
-
-            let mut resource_uuid = Uuid::default();
-            if resource_uuid.visit("ResourceUuid", visitor).is_err() {
-                warn!(
-                    "A resource of type {type_uuid} has no uuid! It looks like a resource in \
-              the old format; trying to read it..."
-                );
-            }
-
-            let resource_manager = visitor.blackboard.get::<ResourceManager>().expect(
-                "Resource data constructor container must be \
-                provided when serializing resources!",
-            );
-            let resource_manager_state = resource_manager.state();
-
-            if let Some(mut instance) = resource_manager_state
-                .constructors_container
-                .try_create(&type_uuid)
-            {
-                drop(resource_manager_state);
-
-                if kind == ResourceKind::Embedded {
-                    instance.visit(name, visitor)?;
-                }
-
-                *self = Self::Ok {
-                    resource_uuid,
-                    data: ResourceDataWrapper(instance),
-                };
-            } else {
-                return Err(VisitError::User(format!(
-                    "There's no constructor registered for type {type_uuid}!"
-                )));
-            }
-
-            Ok(())
-        } else if let Self::Ok {
-            resource_uuid,
-            data,
-        } = self
-        {
-            resource_uuid.visit("ResourceUuid", visitor)?;
-
-            let mut type_uuid = data.type_uuid();
-            type_uuid.visit("TypeUuid", visitor)?;
-
-            if kind == ResourceKind::Embedded {
-                data.visit(name, visitor)?;
-            }
-
-            Ok(())
-        } else {
-            // Do not save other variants, because they're needed only for runtime purposes.
-            Ok(())
-        }
-    }
-
     /// Creates new resource in pending state.
     #[inline]
-    pub fn new_pending(path: PathBuf) -> Self {
+    pub fn new_pending() -> Self {
         Self::Pending {
             wakers: Default::default(),
-            path,
         }
     }
 
@@ -408,42 +358,34 @@ impl ResourceState {
 
     /// Creates new resource in [`ResourceState::Ok`] state.
     #[inline]
-    pub fn new_ok<T: ResourceData>(resource_uuid: Uuid, data: T) -> Self {
+    pub fn new_ok<T: ResourceData>(data: T) -> Self {
         Self::Ok {
-            resource_uuid,
             data: ResourceDataWrapper(Box::new(data)),
         }
     }
 
     /// Creates a new resource in [`ResourceState::Ok`] state using arbitrary data.
     #[inline]
-    pub fn new_ok_untyped(resource_uuid: Uuid, data: Box<dyn ResourceData>) -> Self {
+    pub fn new_ok_untyped(data: Box<dyn ResourceData>) -> Self {
         Self::Ok {
-            resource_uuid,
             data: ResourceDataWrapper(data),
         }
     }
 
-    /// Tries to get a resource uuid. The uuid is available only for resource in [`ResourceState::Ok`]
-    /// state.
-    #[inline]
-    pub fn resource_uuid(&self) -> Option<Uuid> {
-        match self {
-            ResourceState::Ok { resource_uuid, .. } => Some(*resource_uuid),
-            _ => None,
-        }
-    }
-
     /// Checks whether the resource is still loading or not.
     pub fn is_loading(&self) -> bool {
         matches!(self, ResourceState::Pending { .. })
     }
 
+    /// Checks whether the resource is loaded without errors.
+    pub fn is_ok(&self) -> bool {
+        matches!(self, ResourceState::Ok { .. })
+    }
+
     /// Switches the internal state of the resource to [`ResourceState::Pending`].
-    pub fn switch_to_pending_state(&mut self, path: PathBuf) {
+    pub fn switch_to_pending_state(&mut self) {
         *self = ResourceState::Pending {
             wakers: Default::default(),
-            path,
         };
     }
 
@@ -456,7 +398,7 @@ impl ResourceState {
         let wakers = if let ResourceState::Pending { ref mut wakers, .. } = self {
             std::mem::take(wakers)
         } else {
-            Default::default()
+            WakersList::default()
         };
 
         *self = state;
@@ -467,9 +409,8 @@ impl ResourceState {
     }
 
     /// Changes internal state to [`ResourceState::Ok`]
-    pub fn commit_ok<T: ResourceData>(&mut self, resource_uuid: Uuid, data: T) {
+    pub fn commit_ok<T: ResourceData>(&mut self, data: T) {
         self.commit(ResourceState::Ok {
-            resource_uuid,
             data: ResourceDataWrapper(Box::new(data)),
         })
     }
@@ -485,7 +426,9 @@ impl ResourceState {
     /// Tries to get the resource data. Will fail if the resource is not in [`ResourceState::Ok`].
     pub fn data_ref(&self) -> Option<&ResourceDataWrapper> {
         match self {
-            ResourceState::Pending { .. } | ResourceState::LoadError { .. } => None,
+            ResourceState::Pending { .. }
+            | ResourceState::LoadError { .. }
+            | ResourceState::Unloaded => None,
             ResourceState::Ok { data, .. } => Some(data),
         }
     }
@@ -493,7 +436,9 @@ impl ResourceState {
     /// Tries to get the resource data. Will fail if the resource is not in [`ResourceState::Ok`].
     pub fn data_mut(&mut self) -> Option<&mut ResourceDataWrapper> {
         match self {
-            ResourceState::Pending { .. } | ResourceState::LoadError { .. } => None,
+            ResourceState::Pending { .. }
+            | ResourceState::LoadError { .. }
+            | ResourceState::Unloaded => None,
             ResourceState::Ok { data, .. } => Some(data),
         }
     }
@@ -502,7 +447,9 @@ impl ResourceState {
     /// [`ResourceState::Ok`].
     pub fn data_ref_of_type<T: TypedResourceData>(&self) -> Option<&T> {
         match self {
-            ResourceState::Pending { .. } | ResourceState::LoadError { .. } => None,
+            ResourceState::Pending { .. }
+            | ResourceState::LoadError { .. }
+            | ResourceState::Unloaded => None,
             ResourceState::Ok { data, .. } => (&**data as &dyn Any).downcast_ref::<T>(),
         }
     }
@@ -511,7 +458,9 @@ impl ResourceState {
     /// [`ResourceState::Ok`].
     pub fn data_mut_of_type<T: TypedResourceData>(&mut self) -> Option<&mut T> {
         match self {
-            ResourceState::Pending { .. } | ResourceState::LoadError { .. } => None,
+            ResourceState::Pending { .. }
+            | ResourceState::LoadError { .. }
+            | ResourceState::Unloaded => None,
             ResourceState::Ok { data, .. } => (&mut **data as &mut dyn Any).downcast_mut::<T>(),
         }
     }
@@ -521,6 +470,8 @@ impl ResourceState {
 mod test {
     use fyrox_core::{
         reflect::{FieldRef, Reflect},
+        uuid::Uuid,
+        visitor::prelude::*,
         TypeUuidProvider,
     };
     use std::error::Error;
@@ -557,7 +508,7 @@ mod test {
 
     #[test]
     fn resource_state_new_pending() {
-        let state = ResourceState::new_pending(Default::default());
+        let state = ResourceState::new_pending();
 
         assert!(matches!(state, ResourceState::Pending { .. }));
         assert!(state.is_loading());
@@ -573,8 +524,7 @@ mod test {
 
     #[test]
     fn resource_state_new_ok() {
-        let uuid = Uuid::new_v4();
-        let state = ResourceState::new_ok(uuid, Stub {});
+        let state = ResourceState::new_ok(Stub {});
         assert!(matches!(state, ResourceState::Ok { .. }));
         assert!(!state.is_loading());
     }
@@ -582,48 +532,21 @@ mod test {
     #[test]
     fn resource_state_switch_to_pending_state() {
         // from Ok
-        let mut state = ResourceState::new_ok(Uuid::new_v4(), Stub {});
-        state.switch_to_pending_state(Default::default());
+        let mut state = ResourceState::new_ok(Stub {});
+        state.switch_to_pending_state();
 
         assert!(matches!(state, ResourceState::Pending { .. }));
 
         // from LoadError
         let mut state = ResourceState::new_load_error(Default::default(), Default::default());
-        state.switch_to_pending_state(Default::default());
+        state.switch_to_pending_state();
 
         assert!(matches!(state, ResourceState::Pending { .. }));
 
         // from Pending
-        let mut state = ResourceState::new_pending(Default::default());
-        state.switch_to_pending_state(Default::default());
+        let mut state = ResourceState::new_pending();
+        state.switch_to_pending_state();
 
         assert!(matches!(state, ResourceState::Pending { .. }));
     }
-
-    #[test]
-    fn visit_for_resource_state() {
-        // Visit Pending
-        let mut state = ResourceState::new_pending(Default::default());
-        let mut visitor = Visitor::default();
-
-        assert!(state
-            .visit(ResourceKind::External, "name", &mut visitor)
-            .is_ok());
-
-        // Visit LoadError
-        let mut state = ResourceState::new_load_error(Default::default(), Default::default());
-        let mut visitor = Visitor::default();
-
-        assert!(state
-            .visit(ResourceKind::External, "name", &mut visitor)
-            .is_ok());
-
-        // Visit Ok
-        let mut state = ResourceState::new_ok(Uuid::new_v4(), Stub {});
-        let mut visitor = Visitor::default();
-
-        assert!(state
-            .visit(ResourceKind::External, "name", &mut visitor)
-            .is_ok());
-    }
 }
diff --git a/fyrox-resource/src/untyped.rs b/fyrox-resource/src/untyped.rs
index 9711e4c5d..bdd245e0d 100644
--- a/fyrox-resource/src/untyped.rs
+++ b/fyrox-resource/src/untyped.rs
@@ -24,15 +24,19 @@ use crate::state::ResourceDataWrapper;
 use crate::{
     core::{
         math::curve::Curve, parking_lot::Mutex, reflect::prelude::*, uuid, uuid::Uuid,
-        visitor::prelude::*, visitor::RegionGuard, TypeUuidProvider,
+        visitor::prelude::*, TypeUuidProvider,
     },
     manager::ResourceManager,
-    registry::ResourceRegistryStatus,
     state::{LoadError, ResourceState},
     Resource, ResourceData, ResourceLoadError, TypedResourceData, CURVE_RESOURCE_UUID,
     MODEL_RESOURCE_UUID, SHADER_RESOURCE_UUID, SOUND_BUFFER_RESOURCE_UUID, TEXTURE_RESOURCE_UUID,
 };
-use fyrox_core::err;
+use crate::{ResourceHeaderGuard, FONT_RESOURCE_UUID, HRIR_SPHERE_RESOURCE_UUID};
+use fxhash::FxHasher64;
+use fyrox_core::io::FileError;
+use fyrox_core::log::Log;
+use fyrox_core::parking_lot::MutexGuard;
+use fyrox_core::SafeLock;
 use std::fmt::Write;
 use std::{
     error::Error,
@@ -47,11 +51,167 @@ use std::{
     task::{Context, Poll},
 };
 
+const MISSING_RESOURCE_MANAGER: &str =
+    "Resource data constructor container must be provided when serializing resources!";
+
+/// The UUIDs for resources that cannot be visited as embedded data because none of their
+/// fields are visited. This is used by `LegacyHeader` to avoid mistakenly interpretting
+/// a visitor node as an embedded resource.
+/// Being on this list does *not* prevent future versions of these resources from being
+/// embedded. It is purely a heuristic to assist with reading legacy resources.
+const INVALID_EMBEDDED_RESOURCES: &[Uuid] = &[
+    SOUND_BUFFER_RESOURCE_UUID,
+    MODEL_RESOURCE_UUID,
+    HRIR_SPHERE_RESOURCE_UUID,
+    FONT_RESOURCE_UUID,
+];
+
+#[derive(Default, Debug, Visit, Clone, PartialEq, Eq, Hash)]
+enum OldResourceKind {
+    #[default]
+    Embedded,
+    External(PathBuf),
+}
+
+#[derive(Debug)]
+enum LegacyHeader {
+    Path(PathBuf),
+    Uuid(Uuid),
+    Data(Box<dyn ResourceData>),
+}
+
+impl LegacyHeader {
+    fn visit_path(&mut self, name: &str, visitor: &mut Visitor) -> VisitResult {
+        let mut path = PathBuf::default();
+        path.visit(name, visitor)?;
+        if path.as_os_str().is_empty() {
+            return Err(VisitError::FileLoadError(FileError::Custom(
+                "Empty path".to_string(),
+            )));
+        }
+        *self = Self::Path(path);
+        Ok(())
+    }
+    fn visit_details(&mut self, type_uuid: Uuid, visitor: &mut Visitor) -> VisitResult {
+        let mut region = visitor.enter_region("Details")?;
+        if type_uuid == SOUND_BUFFER_RESOURCE_UUID {
+            let mut sound_region = region.enter_region("0")?;
+            self.visit_path("Path", &mut sound_region)
+        } else {
+            self.visit_path("Path", &mut region)
+        }
+    }
+    fn take_data(&mut self, uuid: Uuid) -> Option<Box<dyn ResourceData>> {
+        if let Self::Data(data) = std::mem::replace(self, Self::Uuid(uuid)) {
+            Some(data)
+        } else {
+            None
+        }
+    }
+    fn is_valid_embedded_type_uuid(uuid: Uuid) -> bool {
+        INVALID_EMBEDDED_RESOURCES.contains(&uuid)
+    }
+}
+
+impl Default for LegacyHeader {
+    fn default() -> Self {
+        Self::Path(PathBuf::default())
+    }
+}
+
+impl Visit for LegacyHeader {
+    fn visit(&mut self, name: &str, visitor: &mut Visitor) -> VisitResult {
+        assert!(visitor.is_reading());
+        let mut region = visitor.enter_region(name)?;
+
+        let mut type_uuid = Uuid::default();
+        if type_uuid.visit("TypeUuid", &mut region).is_err() {
+            // We might be reading the old version, try to guess an actual type uuid by
+            // the inner content of the resource data.
+            type_uuid = guess_uuid(&mut region);
+        };
+        let resource_manager = region
+            .blackboard
+            .get::<ResourceManager>()
+            .expect(MISSING_RESOURCE_MANAGER);
+        let resource_manager_state = resource_manager.state();
+        let Some(mut instance) = resource_manager_state
+            .constructors_container
+            .try_create(&type_uuid)
+        else {
+            return Err(VisitError::User(format!(
+                "There's no constructor registered for type {type_uuid}!"
+            )));
+        };
+        drop(resource_manager_state);
+
+        let mut id: u32 = 0;
+
+        if id.visit("Id", &mut region).is_ok() {
+            // We're interested only in embedded resources.
+            if id == 2 {
+                let result = self.visit_details(type_uuid, &mut region);
+                if let Err(err0) = result {
+                    if Self::is_valid_embedded_type_uuid(type_uuid) {
+                        let result = instance.visit("Details", &mut region);
+                        if let Err(err1) = result {
+                            let result = instance.visit("State", &mut region);
+                            if let Err(err2) = result {
+                                return Err(err0.multiple(err1).multiple(err2));
+                            }
+                        }
+                        *self = Self::Data(instance);
+                        Ok(())
+                    } else {
+                        Err(err0)
+                    }
+                } else {
+                    result
+                }
+            } else {
+                Err(VisitError::User("Old resource".into()))
+            }
+        } else {
+            let mut uuid = Uuid::default();
+            if uuid.visit("ResourceUuid", &mut region).is_ok() && !uuid.is_nil() {
+                *self = Self::Uuid(uuid);
+                return Ok(());
+            }
+            let mut old_kind = OldResourceKind::Embedded;
+            old_kind.visit("Kind", &mut region)?;
+            match old_kind {
+                OldResourceKind::External(path) => {
+                    if path.as_os_str().is_empty() {
+                        return Err(VisitError::FileLoadError(FileError::Custom(
+                            "Empty path".to_string(),
+                        )));
+                    }
+                    *self = Self::Path(path);
+                }
+                OldResourceKind::Embedded => {
+                    instance.visit("State", &mut region)?;
+                    *self = Self::Data(instance);
+                }
+            }
+            Ok(())
+        }
+    }
+}
+
 // Heuristic function to guess resource uuid based on inner content of a resource.
-fn guess_uuid(region: &mut RegionGuard) -> Uuid {
+fn guess_uuid(region: &mut Visitor) -> Uuid {
     assert!(region.is_reading());
 
-    let mut region = region.enter_region("Details").unwrap();
+    let guard = region.enter_region("Details");
+    let mut region = match guard {
+        Ok(region) => region,
+        Err(ref err) => {
+            Log::err(err.to_string());
+            drop(guard);
+            Log::info(region.debug());
+            return TEXTURE_RESOURCE_UUID;
+        }
+    };
 
     let mut mip_count = 0u32;
     if mip_count.visit("MipCount", &mut region).is_ok() {
@@ -108,13 +268,6 @@ pub enum ResourceKind {
     External,
 }
 
-#[derive(Default, Debug, Visit, Clone, PartialEq, Eq, Hash)]
-enum OldResourceKind {
-    #[default]
-    Embedded,
-    External(PathBuf),
-}
-
 impl ResourceKind {
     /// Switches the resource kind to [`Self::External`].
     #[inline]
@@ -158,23 +311,56 @@ impl Display for ResourceKind {
 /// its kind, etc.
 #[derive(Reflect, Clone, Debug)]
 pub struct ResourceHeader {
+    /// The unique identifier of this resource.
+    pub uuid: Uuid,
     /// Kind of the resource. See [`ResourceKind`] for more info.
     pub kind: ResourceKind,
     /// Actual state of the resource. See [`ResourceState`] for more info.
     pub state: ResourceState,
+}
 
-    // TODO: Remove in Fyrox 1.0
-    old_format_path: Option<PathBuf>,
+impl Default for ResourceHeader {
+    fn default() -> Self {
+        Self {
+            uuid: Uuid::new_v4(),
+            kind: Default::default(),
+            state: Default::default(),
+        }
+    }
+}
+
+impl From<Uuid> for ResourceHeader {
+    fn from(uuid: Uuid) -> Self {
+        Self {
+            uuid,
+            kind: ResourceKind::External,
+            state: ResourceState::Unloaded,
+        }
+    }
+}
+
+impl ResourceHeader {
+    /// The type of the data, if this resource is Ok.
+    pub fn type_uuid(&self) -> Option<Uuid> {
+        if let ResourceState::Ok { data } = &self.state {
+            Some(data.type_uuid())
+        } else {
+            None
+        }
+    }
 }
 
 impl Display for ResourceHeader {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        Display::fmt(&self.uuid, f)?;
+        f.write_char(':')?;
         match self.kind {
             ResourceKind::Embedded => f.write_str("Embed")?,
             ResourceKind::External => f.write_str("Extern")?,
         }
         f.write_char(':')?;
         match &self.state {
+            ResourceState::Unloaded => f.write_str("Unloaded"),
             ResourceState::Pending { .. } => f.write_str("Pending"),
             ResourceState::LoadError { path, error } => write!(f, "Error({path:?}, {error})"),
             ResourceState::Ok { .. } => f.write_str("Ok"),
@@ -185,87 +371,44 @@ impl Display for ResourceHeader {
 impl Visit for ResourceHeader {
     fn visit(&mut self, name: &str, visitor: &mut Visitor) -> VisitResult {
         let mut region = visitor.enter_region(name)?;
-
         if region.is_reading() {
-            let mut id: u32 = 0;
-
-            if id.visit("Id", &mut region).is_ok() {
-                // Reading old version, convert it to the new.
-
-                let mut type_uuid = Uuid::default();
-                if type_uuid.visit("TypeUuid", &mut region).is_err() {
-                    // We might be reading the old version, try to guess an actual type uuid by
-                    // the inner content of the resource data.
-                    type_uuid = guess_uuid(&mut region);
-                };
-
-                // We're interested only in embedded resources.
-                if id == 2 {
-                    let resource_manager = region.blackboard.get::<ResourceManager>().expect(
-                        "Resource data constructor container must be \
-                provided when serializing resources!",
-                    );
-                    let resource_manager_state = resource_manager.state();
-
-                    if let Some(mut instance) = resource_manager_state
-                        .constructors_container
-                        .try_create(&type_uuid)
-                    {
-                        drop(resource_manager_state);
-
-                        if let Ok(mut details_region) = region.enter_region("Details") {
-                            if type_uuid == SOUND_BUFFER_RESOURCE_UUID {
-                                let mut sound_region = details_region.enter_region("0")?;
-                                let mut path = PathBuf::new();
-                                path.visit("Path", &mut sound_region).unwrap();
-                                self.kind.make_external();
-                                self.old_format_path = Some(path);
-                            } else {
-                                let mut path = PathBuf::new();
-                                path.visit("Path", &mut details_region).unwrap();
-                                self.kind.make_external();
-                                self.old_format_path = Some(path);
-                            }
-                        }
-
-                        instance.visit("Details", &mut region)?;
-
-                        self.state = ResourceState::Ok {
-                            data: ResourceDataWrapper(instance),
-                            // The old format does not contain an uuid.
-                            resource_uuid: Uuid::nil(),
-                        };
-
-                        return Ok(());
-                    } else {
-                        return Err(VisitError::User(format!(
-                            "There's no constructor registered for type {type_uuid}!"
-                        )));
-                    }
-                } else {
-                    self.state = ResourceState::LoadError {
-                        path: Default::default(),
-                        error: LoadError::new("Old resource"),
-                    };
+            self.kind = ResourceKind::Embedded;
+            let mut actual_type_uuid = Uuid::default();
+            actual_type_uuid.visit("TypeUuid", &mut region)?;
+            let resource_manager = region
+                .blackboard
+                .get::<ResourceManager>()
+                .expect(MISSING_RESOURCE_MANAGER)
+                .clone();
+            let Some(mut data) = resource_manager
+                .state()
+                .constructors_container
+                .try_create(&actual_type_uuid)
+            else {
+                return Err(VisitError::User(format!(
+                    "There's no constructor registered for type {actual_type_uuid}!"
+                )));
+            };
+            data.visit("Data", &mut region)?;
+            self.state = ResourceState::Ok {
+                data: ResourceDataWrapper(data),
+            };
+            Ok(())
+        } else {
+            match (&self.kind, &mut self.state) {
+                (ResourceKind::Embedded, ResourceState::Ok { data }) => {
+                    let mut type_uuid = data.type_uuid();
+                    type_uuid.visit("TypeUuid", &mut region)?;
+                    data.visit("Data", &mut region)
                 }
-
-                return Ok(());
-            } else {
-                let mut old_kind = OldResourceKind::Embedded;
-                if old_kind.visit("Kind", &mut region).is_ok() {
-                    if let OldResourceKind::External(path) = old_kind {
-                        self.old_format_path = Some(path);
-                    }
+                (ResourceKind::External, _) => {
+                    Err(VisitError::User("Writing an external resource".into()))
                 }
+                _ => Err(VisitError::User(
+                    "Writing an embedded resource that is not ok.".into(),
+                )),
             }
         }
-
-        self.kind.visit("Kind", &mut region)?;
-        if !region.is_reading() || region.find_field("TypeUuid").is_some() {
-            self.state.visit(self.kind, "State", &mut region)?;
-        }
-
-        Ok(())
     }
 }
 
@@ -308,101 +451,21 @@ impl Visit for ResourceHeader {
 /// that the resource is in default state. This is a trade-off to prevent wrapping internals into
 /// `Option`, that in some cases could lead to convoluted code with lots of `unwrap`s and state
 /// assumptions.
-#[derive(Clone, Reflect, TypeUuidProvider)]
+#[derive(Default, Clone, Reflect, TypeUuidProvider)]
 #[type_uuid(id = "21613484-7145-4d1c-87d8-62fa767560ab")]
 pub struct UntypedResource(pub Arc<Mutex<ResourceHeader>>);
 
 impl Visit for UntypedResource {
     fn visit(&mut self, name: &str, visitor: &mut Visitor) -> VisitResult {
-        self.0.visit(name, visitor)?;
-
-        // Try to restore the shallow handle on deserialization for external resources.
-        if visitor.is_reading() {
-            let inner_lock = self.0.lock();
-            if let (ResourceKind::External, &ResourceState::Ok { resource_uuid, .. }) =
-                (inner_lock.kind, &inner_lock.state)
-            {
-                let resource_manager = visitor
-                    .blackboard
-                    .get::<ResourceManager>()
-                    .expect("Resource manager must be available when deserializing resources!");
-
-                let status_flag = resource_manager
-                    .state()
-                    .resource_registry
-                    .lock()
-                    .status_flag();
-
-                // The resource registry **MUST** be loaded at this stage. This assertion should never
-                // trigger in normal circumstances, because resource references normally stored inside
-                // some other resources and resource loading is guarded with `registry.await` that
-                // waits until the registry is fully loaded.
-                //
-                // There are two major ways that will trigger this assertion:
-                // 1) The registry is not loaded.
-                // 2) You're trying to deserialize the resource handle manually without a proper
-                // environment.
-                assert_eq!(
-                    status_flag.status(),
-                    ResourceRegistryStatus::Loaded,
-                    "Resource registry is not loaded"
-                );
-
-                let path = match inner_lock.old_format_path {
-                    None => {
-                        let rm_state = resource_manager.state();
-                        let registry_lock = rm_state.resource_registry.lock();
-                        let path = registry_lock.uuid_to_path_buf(resource_uuid);
-                        // Minimize duration of lock on registry.
-                        drop(registry_lock);
-                        match path {
-                            Some(path) => Some(path),
-                            None => {
-                                // As a last resort - try to find a built-in resource with this id.
-                                // Beware that find_by_uuid causes resource header locking.
-                                rm_state
-                                    .built_in_resources
-                                    .find_by_uuid(resource_uuid)
-                                    .map(|r| r.id.clone())
-                            }
-                        }
-                    }
-                    Some(ref path) => Some(path.clone()),
-                };
-
-                if let Some(path) = path {
-                    drop(inner_lock);
-                    self.0 = resource_manager.request_untyped(path).0;
-                } else {
-                    let kind = inner_lock.kind;
-                    drop(inner_lock);
-
-                    let message = format!(
-                        "Unable to restore resource handle of {resource_uuid} uuid!\
-                        The uuid wasn't found in the resource registry!"
-                    );
-
-                    err!("{}", message);
-
-                    *self = UntypedResource::new_load_error(kind, LoadError::new(message));
-                }
+        let result = self.visit_with_type_uuid(name, None, visitor);
+        if let Err(err) = &result {
+            Log::err(format!("Resource error for untyped resource: {err}"));
+            if let Ok(region) = visitor.enter_region(name) {
+                region.debug();
             }
+            self.commit_error(PathBuf::default(), err.to_string());
         }
-
-        Ok(())
-    }
-}
-
-impl Default for UntypedResource {
-    fn default() -> Self {
-        Self(Arc::new(Mutex::new(ResourceHeader {
-            kind: Default::default(),
-            state: ResourceState::new_load_error(
-                Default::default(),
-                LoadError::new("Default resource state of unknown type."),
-            ),
-            old_format_path: None,
-        })))
+        result
     }
 }
 
@@ -418,13 +481,13 @@ impl Display for UntypedResource {
 
 impl Debug for UntypedResource {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        writeln!(f, "Resource")
+        write!(f, "UntypedResource({self})")
     }
 }
 
 impl PartialEq for UntypedResource {
     fn eq(&self, other: &Self) -> bool {
-        std::ptr::eq(&*self.0, &*other.0)
+        Arc::ptr_eq(&self.0, &other.0)
     }
 }
 
@@ -432,18 +495,177 @@ impl Eq for UntypedResource {}
 
 impl Hash for UntypedResource {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        state.write_u64(&*self.0 as *const _ as u64)
+        Arc::as_ptr(&self.0).hash(state);
+    }
+}
+
+impl From<Uuid> for UntypedResource {
+    fn from(uuid: Uuid) -> Self {
+        ResourceHeader::from(uuid).into()
+    }
+}
+
+impl From<ResourceHeader> for UntypedResource {
+    fn from(header: ResourceHeader) -> Self {
+        Self(Arc::new(Mutex::new(header)))
     }
 }
 
 impl UntypedResource {
-    /// Creates new untyped resource in pending state using the given path and type uuid.
-    pub fn new_pending(path: PathBuf, kind: ResourceKind) -> Self {
-        Self(Arc::new(Mutex::new(ResourceHeader {
+    /// Visit this resource handle with the given UUID for the type of the resource data.
+    pub fn visit_with_type_uuid(
+        &mut self,
+        name: &str,
+        type_uuid: Option<Uuid>,
+        visitor: &mut Visitor,
+    ) -> VisitResult {
+        let mut region = visitor.enter_region(name)?;
+        if region.is_reading() {
+            let mut uuid = Uuid::default();
+            match uuid.visit("Uuid", &mut region) {
+                Ok(()) => {
+                    self.read_visit(uuid, type_uuid, &mut region)?;
+                    drop(region);
+                }
+                Err(_) => {
+                    drop(region);
+                    self.legacy_visit(name, visitor)?;
+                }
+            }
+            let resource_manager = visitor
+                .blackboard
+                .get::<ResourceManager>()
+                .expect("Resource manager must be available when deserializing resources!")
+                .clone();
+            resource_manager.state().request_resource(self);
+            Ok(())
+        } else {
+            self.resource_uuid().visit("Uuid", &mut region)?;
+            let header_guard = self.lock();
+            let is_embedded = header_guard.kind.is_embedded();
+            let is_ok = header_guard.state.is_ok();
+            drop(header_guard);
+            if is_embedded && is_ok {
+                self.0.visit("Embedded", &mut region)
+            } else if is_embedded {
+                true.visit("Default", &mut region)
+            } else {
+                Ok(())
+            }
+        }
+    }
+    fn legacy_visit(&mut self, name: &str, visitor: &mut Visitor) -> VisitResult {
+        let mut header: Arc<Mutex<LegacyHeader>> = Default::default();
+        let result = header.visit(name, visitor);
+        if let Err(err1) = result {
+            header = Arc::default();
+            if let Ok(mut region) = visitor.enter_region(name) {
+                let mut region = if region.has_region("Value") {
+                    region.enter_region("Value").unwrap()
+                } else {
+                    region
+                };
+                let result = header.visit("State", &mut region);
+                if let Err(err2) = result {
+                    if let Ok(mut region) = region.enter_region("State") {
+                        let result = header.visit("Data", &mut region);
+                        if let Err(err3) = result {
+                            return Err(err1.multiple(err2).multiple(err3));
+                        }
+                    } else {
+                        return Err(err1.multiple(err2));
+                    }
+                }
+            } else {
+                return Err(err1);
+            }
+        }
+        let resource_manager = visitor
+            .blackboard
+            .get::<ResourceManager>()
+            .expect("Resource manager must be available when deserializing resources!")
+            .clone();
+        let mut state = resource_manager.state();
+        let mut header = header.try_lock().expect("header locked");
+        match *header {
+            LegacyHeader::Path(ref path) => {
+                Log::info(format!("Requesting {path:?}"));
+                *self = state.request(path);
+            }
+            LegacyHeader::Uuid(uuid) => {
+                *self = uuid.into();
+            }
+            LegacyHeader::Data(_) => {
+                let uuid = Uuid::new_v4();
+                let data = header.take_data(uuid).unwrap();
+                *self = UntypedResource::new_ok_untyped(uuid, ResourceKind::Embedded, data);
+            }
+        }
+        Ok(())
+    }
+    fn read_visit(
+        &mut self,
+        resource_uuid: Uuid,
+        type_uuid: Option<Uuid>,
+        visitor: &mut Visitor,
+    ) -> VisitResult {
+        let mut is_default = false;
+        if is_default.visit("Default", visitor).is_ok() && is_default {
+            *self = Self::default();
+            self.lock().uuid = resource_uuid;
+            Ok(())
+        } else if visitor.has_region("Embedded") {
+            self.0.visit("Embedded", visitor)?;
+            self.lock().uuid = resource_uuid;
+            if let (Some(expected), Some(actual)) = (type_uuid, self.lock().type_uuid()) {
+                if expected != actual {
+                    return Err(format!(
+                        "Unable to deserialize untyped resource into its typed \
+                    version, because types do not match! Untyped resource has \
+                    {actual} type, but the required type is {expected}.",
+                    )
+                    .into());
+                }
+            }
+            Ok(())
+        } else {
+            *self = resource_uuid.into();
+            Ok(())
+        }
+    }
+    /// Lock the shared header of this resource.
+    pub fn typed_lock<T: TypedResourceData>(&self) -> ResourceHeaderGuard<'_, T> {
+        self.lock().into()
+    }
+    /// Lock the shared header of this resource.
+    pub fn lock(&self) -> MutexGuard<'_, ResourceHeader> {
+        self.0.safe_lock()
+    }
+    /// Attempt to lock the shared header. None if the header is already locked.
+    pub fn try_typed_lock<T: TypedResourceData>(&self) -> Option<ResourceHeaderGuard<'_, T>> {
+        self.try_lock().map(|g| g.into())
+    }
+    /// Attempt to lock the shared header. None if the header is already locked.
+    pub fn try_lock(&self) -> Option<MutexGuard<'_, ResourceHeader>> {
+        self.0.try_lock()
+    }
+    /// Creates new untyped resource in unloaded state with the given UUID.
+    pub fn new_unloaded(resource_uuid: Uuid) -> Self {
+        ResourceHeader {
+            uuid: resource_uuid,
+            kind: ResourceKind::External,
+            state: ResourceState::Unloaded,
+        }
+        .into()
+    }
+    /// Creates new untyped resource in pending state with the given UUID.
+    pub fn new_pending(resource_uuid: Uuid, kind: ResourceKind) -> Self {
+        ResourceHeader {
+            uuid: resource_uuid,
             kind,
-            state: ResourceState::new_pending(path),
-            old_format_path: None,
-        })))
+            state: ResourceState::new_pending(),
+        }
+        .into()
     }
 
     /// Creates new untyped resource in ok (fully loaded) state using the given data of any type, that
@@ -452,11 +674,12 @@ impl UntypedResource {
     where
         T: ResourceData,
     {
-        Self(Arc::new(Mutex::new(ResourceHeader {
+        ResourceHeader {
+            uuid: resource_uuid,
             kind,
-            state: ResourceState::new_ok(resource_uuid, data),
-            old_format_path: None,
-        })))
+            state: ResourceState::new_ok(data),
+        }
+        .into()
     }
 
     /// Creates new untyped resource in ok (fully loaded) state using the given data.
@@ -465,11 +688,12 @@ impl UntypedResource {
         kind: ResourceKind,
         data: Box<dyn ResourceData>,
     ) -> Self {
-        Self(Arc::new(Mutex::new(ResourceHeader {
+        ResourceHeader {
+            uuid: resource_uuid,
             kind,
-            state: ResourceState::new_ok_untyped(resource_uuid, data),
-            old_format_path: None,
-        })))
+            state: ResourceState::new_ok_untyped(data),
+        }
+        .into()
     }
 
     /// Creates new untyped resource in ok (fully loaded) state using the given data of any type, that
@@ -479,27 +703,24 @@ impl UntypedResource {
     }
 
     /// Creates new untyped resource in error state.
-    pub fn new_load_error(kind: ResourceKind, error: LoadError) -> Self {
-        Self(Arc::new(Mutex::new(ResourceHeader {
+    pub fn new_load_error(kind: ResourceKind, path: PathBuf, error: LoadError) -> Self {
+        ResourceHeader {
+            uuid: Uuid::new_v4(),
             kind,
-            state: ResourceState::new_load_error(Default::default(), error),
-            old_format_path: None,
-        })))
+            state: ResourceState::new_load_error(path, error),
+        }
+        .into()
     }
 
-    /// Tries to get a resource uuid (if any). Uuid is available only for fully loaded resources
-    /// (in [`ResourceState::Ok`] state).
-    pub fn resource_uuid(&self) -> Option<Uuid> {
-        let header = self.0.lock();
-        match header.state {
-            ResourceState::Ok { resource_uuid, .. } => Some(resource_uuid),
-            _ => None,
-        }
+    /// The UUID of the resource. All resources must have a UUID, even if they are not loaded
+    /// because the UUID is how the resource manager knows the path to load from.
+    pub fn resource_uuid(&self) -> Uuid {
+        self.lock().uuid
     }
 
     /// Returns actual unique type id of underlying resource data.
     pub fn type_uuid(&self) -> Option<Uuid> {
-        let header = self.0.lock();
+        let header = self.lock();
         match header.state {
             ResourceState::Ok { ref data, .. } => Some(data.type_uuid()),
             _ => None,
@@ -509,7 +730,7 @@ impl UntypedResource {
     /// Tries to get an actual unique type id of underlying resource data. Returns `None` if the
     /// resource cannot be locked or if it is not loaded.
     pub fn type_uuid_non_blocking(&self) -> Option<Uuid> {
-        let header = self.0.try_lock()?;
+        let header = self.try_lock()?;
         match header.state {
             ResourceState::Ok { ref data, .. } => Some(data.type_uuid()),
             _ => None,
@@ -519,8 +740,7 @@ impl UntypedResource {
     /// Tries to get a type name of the resource data. Data type name is available only for fully
     /// loaded resources (in [`ResourceState::Ok`] state).
     pub fn data_type_name(&self) -> Option<String> {
-        let header = self.0.lock();
-        match header.state {
+        match self.lock().state {
             ResourceState::Ok { ref data, .. } => Some(Reflect::type_name(&**data).to_string()),
             _ => None,
         }
@@ -533,15 +753,29 @@ impl UntypedResource {
             .unwrap_or_else(|| "Unknown".to_string())
     }
 
+    /// Returns true if the resource has not been requested.
+    pub fn is_unloaded(&self) -> bool {
+        matches!(self.lock().state, ResourceState::Unloaded)
+    }
     /// Returns true if the resource is still loading.
     pub fn is_loading(&self) -> bool {
-        matches!(self.0.lock().state, ResourceState::Pending { .. })
+        matches!(self.lock().state, ResourceState::Pending { .. })
+    }
+
+    /// Returns true if the resource is completely loaded.
+    pub fn is_ok(&self) -> bool {
+        matches!(self.lock().state, ResourceState::Ok { .. })
+    }
+
+    /// Returns true if the resource failed to load.
+    pub fn is_failed_to_load(&self) -> bool {
+        matches!(self.lock().state, ResourceState::LoadError { .. })
     }
 
     /// Returns true if the resource is procedural (its data is generated at runtime, not stored in an external
     /// file).
     pub fn is_embedded(&self) -> bool {
-        self.0.lock().kind.is_embedded()
+        self.lock().kind.is_embedded()
     }
 
     /// Returns exact amount of users of the resource.
@@ -552,27 +786,28 @@ impl UntypedResource {
 
     /// Returns a pointer as numeric value which can be used as a hash.
     #[inline]
-    pub fn key(&self) -> usize {
-        (&*self.0 as *const _) as usize
+    pub fn key(&self) -> u64 {
+        let mut hasher = FxHasher64::default();
+        self.hash(&mut hasher);
+        hasher.finish()
     }
 
     /// Returns path of the untyped resource.
     pub fn kind(&self) -> ResourceKind {
-        self.0.lock().kind
+        self.lock().kind
     }
 
     /// Set a new path for the untyped resource.
     pub fn set_kind(&self, new_kind: ResourceKind) {
-        self.0.lock().kind = new_kind;
+        self.lock().kind = new_kind;
     }
 
     /// Tries to save the resource to the specified path.
     pub fn save(&self, path: &Path) -> Result<(), Box<dyn Error>> {
-        let mut guard = self.0.lock();
-        match guard.state {
-            ResourceState::Pending { .. } | ResourceState::LoadError { .. } => {
-                Err("Unable to save unloaded resource!".into())
-            }
+        match self.lock().state {
+            ResourceState::Pending { .. }
+            | ResourceState::LoadError { .. }
+            | ResourceState::Unloaded => Err("Unable to save unloaded resource!".into()),
             ResourceState::Ok { ref mut data, .. } => data.save(path),
         }
     }
@@ -592,22 +827,25 @@ impl UntypedResource {
         }
     }
 
+    /// Modify this resource into the [`ResourceState::Pending`] state.
+    pub fn make_pending(&mut self) {
+        self.lock().state = ResourceState::new_pending();
+    }
     /// Changes ResourceState::Pending state to ResourceState::Ok(data) with given `data`.
-    /// Additionally, it wakes all futures.
+    /// Additionally, it wakes all futures. Panics if the resource is unrequested.
     #[inline]
     pub fn commit(&self, state: ResourceState) {
-        self.0.lock().state.commit(state);
+        self.lock().state.commit(state);
     }
 
-    /// Changes internal state to [`ResourceState::Ok`]
-    pub fn commit_ok<T: ResourceData>(&self, resource_uuid: Uuid, data: T) {
-        let mut guard = self.0.lock();
-        guard.state.commit_ok(resource_uuid, data);
+    /// Changes internal state to [`ResourceState::Ok`]. Panics if the resource is unrequested.
+    pub fn commit_ok<T: ResourceData>(&self, data: T) {
+        self.lock().state.commit_ok(data);
     }
 
     /// Changes internal state to [`ResourceState::LoadError`].
-    pub fn commit_error<E: ResourceLoadError>(&self, path: PathBuf, error: E) {
-        self.0.lock().state.commit_error(path, error);
+    pub fn commit_error<E: ResourceLoadError>(&mut self, path: PathBuf, error: E) {
+        self.lock().state.commit_error(path, error);
     }
 }
 
@@ -615,13 +853,15 @@ impl Future for UntypedResource {
     type Output = Result<Self, LoadError>;
 
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let state = self.0.clone();
-        let mut guard = state.lock();
+        let mut guard = self.lock();
         match guard.state {
             ResourceState::Pending { ref mut wakers, .. } => {
                 wakers.add_waker(cx.waker());
                 Poll::Pending
             }
+            ResourceState::Unloaded => Poll::Ready(Err(LoadError::new(
+                "Unloaded resource is not loading".to_string(),
+            ))),
             ResourceState::LoadError { ref error, .. } => Poll::Ready(Err(error.clone())),
             ResourceState::Ok { .. } => Poll::Ready(Ok(self.clone())),
         }
@@ -635,6 +875,8 @@ mod test {
     use std::error::Error;
     use std::task::{self};
 
+    use crate::io::FsResourceIo;
+
     use super::*;
 
     #[derive(Debug, Default, Reflect, Visit, Clone, Copy)]
@@ -672,13 +914,21 @@ mod test {
         let mut visitor = Visitor::default();
 
         assert!(r.visit("name", &mut visitor).is_ok());
-    }
 
-    #[test]
-    fn debug_for_untyped_resource() {
-        let r = UntypedResource::default();
-
-        assert_eq!(format!("{r:?}"), "Resource\n");
+        let mut cursor = std::io::Cursor::new(Vec::<u8>::new());
+        visitor
+            .save_binary_to_memory(&mut cursor)
+            .expect("Failed to write binary for visitor");
+        cursor.set_position(0);
+        let mut visitor = Visitor::load_binary_from_memory(cursor.get_ref())
+            .expect("Failed to read binary for visitor");
+        visitor.blackboard.register(Arc::new(ResourceManager::new(
+            Arc::new(FsResourceIo),
+            Arc::default(),
+        )));
+        assert!(r.visit("name", &mut visitor).is_ok());
+        assert!(r.is_embedded());
+        assert!(r.is_failed_to_load());
     }
 
     #[test]
@@ -704,24 +954,23 @@ mod test {
         let waker = noop_waker();
         let mut cx = task::Context::from_waker(&waker);
 
-        let mut r = UntypedResource(Arc::new(Mutex::new(ResourceHeader {
+        let mut r = UntypedResource::from(ResourceHeader {
+            uuid: Uuid::new_v4(),
             kind: ResourceKind::External,
             state: ResourceState::Ok {
                 data: ResourceDataWrapper(Box::new(stub)),
-                resource_uuid: Uuid::new_v4(),
             },
-            old_format_path: None,
-        })));
+        });
         assert!(Pin::new(&mut r).poll(&mut cx).is_ready());
 
-        let mut r = UntypedResource(Arc::new(Mutex::new(ResourceHeader {
+        let mut r = UntypedResource::from(ResourceHeader {
+            uuid: Uuid::new_v4(),
             kind: ResourceKind::External,
             state: ResourceState::LoadError {
                 path: Default::default(),
                 error: Default::default(),
             },
-            old_format_path: None,
-        })));
+        });
         assert!(Pin::new(&mut r).poll(&mut cx).is_ready());
     }
 }
diff --git a/fyrox-sound/src/buffer/generic.rs b/fyrox-sound/src/buffer/generic.rs
index f8c1f2b89..5047a40f7 100644
--- a/fyrox-sound/src/buffer/generic.rs
+++ b/fyrox-sound/src/buffer/generic.rs
@@ -162,6 +162,9 @@ impl GenericBuffer {
     /// Returns exact time length of the buffer.
     #[inline]
     pub fn duration(&self) -> Duration {
+        if self.sample_rate == 0 {
+            return Duration::ZERO;
+        }
         Duration::from_nanos(
             (self.channel_duration_in_samples as u64 * 1_000_000_000u64) / self.sample_rate as u64,
         )
diff --git a/fyrox-ui/src/file_browser/mod.rs b/fyrox-ui/src/file_browser/mod.rs
index af72310dd..fb864525d 100644
--- a/fyrox-ui/src/file_browser/mod.rs
+++ b/fyrox-ui/src/file_browser/mod.rs
@@ -27,7 +27,7 @@ use crate::{
     button::{ButtonBuilder, ButtonMessage},
     core::{
         parking_lot::Mutex, pool::Handle, reflect::prelude::*, type_traits::prelude::*,
-        uuid_provider, visitor::prelude::*,
+        uuid_provider, visitor::prelude::*, SafeLock,
     },
     define_constructor,
     file_browser::menu::ItemContextMenu,
@@ -450,7 +450,7 @@ impl Control for FileBrowser {
                     for entry in entries {
                         let path = entry.path();
                         let build = if let Some(filter) = self.filter.as_mut() {
-                            filter.0.borrow_mut().deref_mut().lock()(&path)
+                            filter.0.borrow_mut().deref_mut().safe_lock()(&path)
                         } else {
                             true
                         };
@@ -605,7 +605,7 @@ impl Control for FileBrowser {
         ui.node(widget)
             .user_data
             .as_ref()
-            .is_some_and(|data| data.lock().downcast_ref::<PathBuf>().is_some())
+            .is_some_and(|data| data.safe_lock().downcast_ref::<PathBuf>().is_some())
     }
 }
 
@@ -617,7 +617,7 @@ fn parent_path(path: &Path) -> PathBuf {
 
 fn filtered_out(filter: &mut Option<Filter>, path: &Path) -> bool {
     match filter.as_mut() {
-        Some(filter) => !filter.0.borrow_mut().deref_mut().lock()(path),
+        Some(filter) => !filter.0.borrow_mut().deref_mut().safe_lock()(path),
         None => false,
     }
 }
@@ -935,7 +935,7 @@ fn build_all(
                 #[allow(clippy::blocks_in_conditions)]
                 if filter
                     .as_mut()
-                    .is_none_or(|f| f.0.borrow_mut().deref_mut().lock()(&path))
+                    .is_none_or(|f| f.0.borrow_mut().deref_mut().safe_lock()(&path))
                 {
                     let is_part_of_final_path = next.as_ref().is_some_and(|next| *next == path);
 
diff --git a/fyrox-ui/src/formatted_text.rs b/fyrox-ui/src/formatted_text.rs
index 49d7e105a..ba7172ce8 100644
--- a/fyrox-ui/src/formatted_text.rs
+++ b/fyrox-ui/src/formatted_text.rs
@@ -839,10 +839,10 @@ impl FormattedText {
     pub fn font_loading_summary(&self) -> String {
         use std::fmt::Write;
         let mut result = String::default();
-        writeln!(result, "Primary font: {:?}", self.font.header().state).unwrap();
+        write!(result, "Primary font: {}", self.font.header().state).unwrap();
         for run in self.runs.iter() {
             if let Some(font) = run.font() {
-                writeln!(result, "Run {:?}: {:?}", run.range, font.header().state).unwrap();
+                write!(result, "\nRun {:?}: {}", run.range, font.header().state).unwrap();
             }
         }
         result
diff --git a/fyrox-ui/src/lib.rs b/fyrox-ui/src/lib.rs
index 5bb53f73c..885503abb 100644
--- a/fyrox-ui/src/lib.rs
+++ b/fyrox-ui/src/lib.rs
@@ -299,12 +299,16 @@ use crate::{
         algebra::{Matrix3, Vector2},
         color::Color,
         math::Rect,
+        parking_lot::Mutex,
+        pool::Ticket,
         pool::{Handle, Pool},
         reflect::prelude::*,
         uuid::uuid,
+        uuid::Uuid,
+        uuid_provider,
         visitor::prelude::*,
+        SafeLock, TypeUuidProvider,
     },
-    core::{parking_lot::Mutex, pool::Ticket, uuid::Uuid, uuid_provider, TypeUuidProvider},
     draw::{CommandTexture, Draw, DrawingContext},
     font::FontResource,
     font::BUILT_IN_FONT,
@@ -411,7 +415,7 @@ pub struct RcUiNodeHandle(Arc<Mutex<RcUiNodeHandleInner>>);
 
 impl Debug for RcUiNodeHandle {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        let handle = self.0.lock().handle;
+        let handle = self.0.safe_lock().handle;
 
         writeln!(
             f,
@@ -425,8 +429,8 @@ impl Debug for RcUiNodeHandle {
 
 impl PartialEq for RcUiNodeHandle {
     fn eq(&self, other: &Self) -> bool {
-        let a = self.0.lock().handle;
-        let b = other.0.lock().handle;
+        let a = self.0.safe_lock().handle;
+        let b = other.0.safe_lock().handle;
         a == b
     }
 }
@@ -444,7 +448,7 @@ impl RcUiNodeHandle {
     /// Returns the inner handle.
     #[inline]
     pub fn handle(&self) -> Handle<UiNode> {
-        self.0.lock().handle
+        self.0.safe_lock().handle
     }
 }
 

From 430f3290ee298f6bf5a086f648add9a0d49cb65f Mon Sep 17 00:00:00 2001
From: b-guild <148972828+b-guild@users.noreply.github.com>
Date: Mon, 13 Oct 2025 20:00:50 -0700
Subject: [PATCH 3/5] Minor correction to comments in manager.rs

---
 fyrox-resource/src/manager.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fyrox-resource/src/manager.rs b/fyrox-resource/src/manager.rs
index 8f3aa00a9..58b0bcea7 100644
--- a/fyrox-resource/src/manager.rs
+++ b/fyrox-resource/src/manager.rs
@@ -1361,7 +1361,7 @@ impl ResourceManagerState {
         }
     }
 
-    /// Tries to load a resources at a given path.
+    /// Tries to load the resource at the given path.
     pub fn request<P>(&mut self, path: P) -> UntypedResource
     where
         P: AsRef<Path>,
@@ -1375,7 +1375,7 @@ impl ResourceManagerState {
         self.find_or_load(path)
     }
 
-    /// Tries to load a resources at a given path.
+    /// Tries to load the resource for the given UUID.
     pub fn request_uuid(&mut self, uuid: Uuid) -> UntypedResource {
         let mut resource = uuid.into();
         self.request_resource(&mut resource);

From ef3c5f1090b9f373375e9cae952cb851903cafb9 Mon Sep 17 00:00:00 2001
From: b-guild <148972828+b-guild@users.noreply.github.com>
Date: Tue, 14 Oct 2025 12:24:44 -0700
Subject: [PATCH 4/5] Convince test to not use previous content of the meta
 file.

---
 fyrox-resource/src/manager.rs | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/fyrox-resource/src/manager.rs b/fyrox-resource/src/manager.rs
index 58b0bcea7..fe6c0e2dd 100644
--- a/fyrox-resource/src/manager.rs
+++ b/fyrox-resource/src/manager.rs
@@ -1982,6 +1982,16 @@ mod test {
         ResourceManagerState::new(Arc::new(FsResourceIo), Arc::new(Default::default()))
     }
 
+    fn remove_file_if_exists(path: &Path) -> std::io::Result<()> {
+        match std::fs::remove_file(path) {
+            Ok(()) => Ok(()),
+            Err(e) => match e.kind() {
+                std::io::ErrorKind::NotFound => Ok(()),
+                _ => Err(e),
+            },
+        }
+    }
+
     #[test]
     fn resource_wait_context_is_all_loaded() {
         assert!(ResourceWaitContext::default().is_all_loaded());
@@ -2166,6 +2176,7 @@ mod test {
         let manager = ResourceManager::new(Arc::new(FsResourceIo), Arc::new(Default::default()));
         let path = PathBuf::from("test.txt");
         let metapath = append_extension(&path, ResourceMetadata::EXTENSION);
+        remove_file_if_exists(&metapath).unwrap();
 
         let resource = UntypedResource::new_pending(Default::default(), ResourceKind::External);
         let res = manager.register(resource.clone(), path.clone());

From d4f5f2c171fc736585ea4c571615132caf8c2d3d Mon Sep 17 00:00:00 2001
From: b-guild <148972828+b-guild@users.noreply.github.com>
Date: Thu, 16 Oct 2025 18:09:36 -0700
Subject: [PATCH 5/5] Corrections to resource reloading, material deep copy,
 etc.

---
 editor/src/asset/mod.rs              |  7 +++-
 editor/src/asset/selection.rs        |  5 ++-
 fyrox-impl/src/engine/executor.rs    |  3 ++
 fyrox-impl/src/renderer/bundle.rs    |  4 +-
 fyrox-impl/src/resource/model/mod.rs |  2 +-
 fyrox-impl/src/scene/sound/mod.rs    | 14 +++----
 fyrox-material/src/lib.rs            | 27 +++++++-------
 fyrox-resource/src/manager.rs        | 55 +++++++++++++++++++++-------
 fyrox-resource/src/registry.rs       |  1 -
 9 files changed, 76 insertions(+), 42 deletions(-)

diff --git a/editor/src/asset/mod.rs b/editor/src/asset/mod.rs
index 2ccd60df3..768d62f84 100644
--- a/editor/src/asset/mod.rs
+++ b/editor/src/asset/mod.rs
@@ -685,6 +685,11 @@ impl AssetBrowser {
             .path
             .clone();
 
+        if asset_path.as_os_str().is_empty() {
+            err!("Selecting AssetItem with empty path: {selected_asset}");
+            return;
+        }
+
         if let Some(selection) = entry.selection.as_ref::<AssetSelection>() {
             if selection.contains(&asset_path) {
                 return;
@@ -830,7 +835,7 @@ impl AssetBrowser {
                     }
                     drop(registry);
 
-                    for path in paths {
+                    for path in paths.into_iter().filter(|p| !p.as_os_str().is_empty()) {
                         self.add_asset(&path, ui, &engine.resource_manager, &sender);
                     }
                 }
diff --git a/editor/src/asset/selection.rs b/editor/src/asset/selection.rs
index 0986c4814..c76f6937a 100644
--- a/editor/src/asset/selection.rs
+++ b/editor/src/asset/selection.rs
@@ -129,7 +129,10 @@ impl AssetSelection {
     }
 
     pub fn selected_path(&self) -> Option<&Path> {
-        self.resources.first().map(|r| r.path.as_path())
+        self.resources
+            .first()
+            .map(|r| r.path.as_path())
+            .filter(|p| !p.as_os_str().is_empty())
     }
 
     pub fn selected_import_options(&self) -> Option<RefMut<Box<dyn BaseImportOptions>>> {
diff --git a/fyrox-impl/src/engine/executor.rs b/fyrox-impl/src/engine/executor.rs
index e4ba49c2d..0e188b098 100644
--- a/fyrox-impl/src/engine/executor.rs
+++ b/fyrox-impl/src/engine/executor.rs
@@ -376,6 +376,9 @@ fn run_normal(
             }
             Event::WindowEvent { event, .. } => {
                 match event {
+                    WindowEvent::Focused(true) => {
+                        engine.resource_manager.state().process_filesystem_events();
+                    }
                     WindowEvent::CloseRequested => active_event_loop.exit(),
                     WindowEvent::Resized(size) => {
                         if let Err(e) = engine.set_frame_size(size.into()) {
diff --git a/fyrox-impl/src/renderer/bundle.rs b/fyrox-impl/src/renderer/bundle.rs
index b071bd84c..18787f2ef 100644
--- a/fyrox-impl/src/renderer/bundle.rs
+++ b/fyrox-impl/src/renderer/bundle.rs
@@ -567,10 +567,10 @@ impl RenderDataBundle {
                 {
                     err_once!(
                         self.data.key() as usize,
-                        "There's no render pass {} in {} shader! \
+                        "There's no render pass {} in {:?} shader! \
                         If it is not needed, add it to disabled passes.",
                         render_context.render_pass_name,
-                        shader_state.kind()
+                        shader_data.definition.name,
                     );
                 }
             }
diff --git a/fyrox-impl/src/resource/model/mod.rs b/fyrox-impl/src/resource/model/mod.rs
index ccf561c54..1d8c1e79b 100644
--- a/fyrox-impl/src/resource/model/mod.rs
+++ b/fyrox-impl/src/resource/model/mod.rs
@@ -760,7 +760,7 @@ impl Display for ModelLoadError {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
             ModelLoadError::Visit(v) => {
-                write!(f, "An error occurred while reading a data source {v:?}")
+                write!(f, "An error occurred while reading a data source: {v}")
             }
             ModelLoadError::NotSupported(v) => {
                 write!(f, "Model format is not supported: {v}")
diff --git a/fyrox-impl/src/scene/sound/mod.rs b/fyrox-impl/src/scene/sound/mod.rs
index 1368a0481..86674f8df 100644
--- a/fyrox-impl/src/scene/sound/mod.rs
+++ b/fyrox-impl/src/scene/sound/mod.rs
@@ -459,15 +459,13 @@ impl NodeTrait for Sound {
                     ResourceState::Unloaded => {
                         Err("Sound buffer is unloaded because it was never requested.".to_string())
                     }
-                    ResourceState::LoadError { ref error, .. } => {
-                        match &error.0 {
-                            None => Err("Sound buffer is failed to load, the reason is unknown!"
-                                .to_string()),
-                            Some(err) => {
-                                Err(format!("Sound buffer is failed to load. Reason: {err:?}"))
-                            }
+                    ResourceState::LoadError { ref error, .. } => match &error.0 {
+                        None => {
+                            Err("Sound buffer is failed to load, the reason is unknown!"
+                                .to_string())
                         }
-                    }
+                        Some(err) => Err(format!("Sound buffer is failed to load. Reason: {err}")),
+                    },
                 }
             }
             None => Err("Sound buffer is not set, the sound won't play!".to_string()),
diff --git a/fyrox-material/src/lib.rs b/fyrox-material/src/lib.rs
index c6ee1bfa4..2603e6419 100644
--- a/fyrox-material/src/lib.rs
+++ b/fyrox-material/src/lib.rs
@@ -9,7 +9,6 @@ use fxhash::FxHashMap;
 use fyrox_core::{
     algebra::{Matrix2, Matrix3, Matrix4, Vector2, Vector3, Vector4},
     color::Color,
-    futures::executor::block_on,
     io::FileError,
     parking_lot::Mutex,
     reflect::prelude::*,
@@ -32,7 +31,7 @@ use std::{
     any::Any,
     error::Error,
     fmt::{Display, Formatter},
-    path::{Path, PathBuf},
+    path::Path,
     sync::Arc,
 };
 use strum_macros::{AsRefStr, EnumString, VariantNames};
@@ -1143,21 +1142,21 @@ impl MaterialResourceExtension for MaterialResource {
     }
 
     fn deep_copy(&self) -> MaterialResource {
-        if let Err(error) = block_on(self.clone()) {
-            return MaterialResource::new_load_error(
-                ResourceKind::Embedded,
-                PathBuf::default(),
-                error,
-            );
-        }
         let material_state = self.header();
         match material_state.state {
-            ResourceState::Pending { .. }
-            | ResourceState::Unloaded
-            | ResourceState::LoadError { .. } => {
-                unreachable!("The resource should be loaded by now")
+            ResourceState::Unloaded => self.resource_uuid().into(),
+            ResourceState::Pending { .. } => {
+                MaterialResource::new_pending(self.resource_uuid(), ResourceKind::External)
             }
-            ResourceState::Ok { ref data, .. } => MaterialResource::new_ok(
+            ResourceState::LoadError {
+                ref error,
+                ref path,
+            } => MaterialResource::new_load_error(
+                ResourceKind::External,
+                path.clone(),
+                error.clone(),
+            ),
+            ResourceState::Ok { ref data } => MaterialResource::new_ok(
                 Uuid::new_v4(),
                 ResourceKind::Embedded,
                 (&**data as &dyn Any)
diff --git a/fyrox-resource/src/manager.rs b/fyrox-resource/src/manager.rs
index fe6c0e2dd..3fd98c30a 100644
--- a/fyrox-resource/src/manager.rs
+++ b/fyrox-resource/src/manager.rs
@@ -47,6 +47,7 @@ use crate::{
     untyped::ResourceKind,
     Resource, TypedResourceData, UntypedResource,
 };
+use fxhash::FxHashSet;
 use fyrox_core::{
     futures::executor::block_on, make_relative_path, notify::Event, ok_or_return, some_or_continue,
     some_or_return,
@@ -495,7 +496,6 @@ impl ResourceManager {
     }
 
     /// Find the resource for the given UUID without loading the resource.
-    /// A new unloaded resource is created if one does not already exist.
     /// If the resource is not already loading, then it will be returned in
     /// the [`ResourceState::Unloaded`] state, and [`Self::request_resource`] may
     /// be used to begin the loading process.
@@ -967,20 +967,19 @@ impl ResourceManagerState {
     /// This may involve updating the registry to reflect changes to the resources, and it may
     /// involve creating new meta files for resources that are missing meta files.
     pub fn process_filesystem_events(&mut self) {
-        while let Some(evt) = self.try_get_event() {
+        let mut modified_files = FxHashSet::default();
+        while let Some(mut evt) = self.try_get_event() {
             if evt.need_rescan() {
                 info!("Filesystem watcher has forced a rescan!");
                 self.update_or_load_registry();
+                self.reload_resources();
             } else {
-                use notify::event::{CreateKind, DataChange, ModifyKind, RemoveKind, RenameMode};
+                use notify::event::{CreateKind, ModifyKind, RemoveKind, RenameMode};
                 use notify::EventKind;
                 match evt.kind {
                     EventKind::Create(CreateKind::Any | CreateKind::File) => {
                         self.on_create_event(evt.paths.first())
                     }
-                    EventKind::Modify(ModifyKind::Data(DataChange::Content)) => {
-                        self.on_file_content_event(evt.paths.first())
-                    }
                     EventKind::Modify(ModifyKind::Name(RenameMode::From)) => {
                         self.on_remove_event(evt.paths.first())
                     }
@@ -991,6 +990,10 @@ impl ResourceManagerState {
                         self.on_remove_event(evt.paths.first());
                         self.on_create_event(evt.paths.get(1));
                     }
+                    EventKind::Modify(ModifyKind::Any | ModifyKind::Data(_)) => {
+                        let path = evt.paths.get_mut(0).map(std::mem::take);
+                        modified_files.insert(path);
+                    }
                     EventKind::Remove(RemoveKind::Any | RemoveKind::File) => {
                         self.on_remove_event(evt.paths.first())
                     }
@@ -998,6 +1001,9 @@ impl ResourceManagerState {
                 }
             }
         }
+        for path in modified_files {
+            self.on_file_content_event(path.as_ref())
+        }
     }
 
     fn on_create_event(&mut self, path: Option<&PathBuf>) {
@@ -1043,7 +1049,13 @@ impl ResourceManagerState {
             .safe_lock()
             .is_supported_resource(&relative_path)
         {
-            Self::on_new_resource_file(registry.modify(), relative_path);
+            Self::on_new_resource_file(registry.modify(), relative_path.clone());
+            drop(registry);
+            if self.try_reload_resource_from_path(&relative_path) {
+                info!(
+                    "File {relative_path:?} was created, trying to reload a respective resource...",
+                );
+            }
         }
     }
     /// A new resource file has been discovered through an event. Check if there is a corresponding meta file,
@@ -1314,8 +1326,11 @@ impl ResourceManagerState {
         self.built_in_resources.add(resource)
     }
 
+    /// Find the resource for the given UUID without loading the resource.
     /// Searches the resource manager to find a resource with the given UUID, including built-in resources.
-    /// If no resource is found, a new UUID is generated and an unloaded resource is returned.
+    /// If no resource is found, a new unloaded external resource is returned for the given UUID,
+    /// because it is presumed that this is a real UUID for some resource that is not currently managed
+    /// and therefore it should be added to the manager.
     pub fn find_uuid(&mut self, uuid: Uuid) -> UntypedResource {
         if let Some(built_in_resource) = self.built_in_resources.find_by_uuid(uuid) {
             return built_in_resource.resource.clone();
@@ -1483,11 +1498,21 @@ impl ResourceManagerState {
                         ));
                     }
                     Err(error) => {
-                        Log::info(format!(
-                            "Resource {path:?} failed to load. Reason: {error:?}",
-                        ));
-
-                        resource.commit_error(path.to_path_buf(), error);
+                        if reload {
+                            if resource.is_ok() {
+                                info!("Resource {path:?} failed to reload, keeping the existing version. Reason: {error}");
+                            }
+                            else
+                            {
+                                info!("Resource {path:?} failed to reload. Reason: {error}");
+                                resource.commit_error(path.to_path_buf(), error);
+                            }
+                        }
+                        else
+                        {
+                            info!("Resource {path:?} failed to load. Reason: {error}");
+                            resource.commit_error(path.to_path_buf(), error);
+                        }
                     }
                 }
             } else {
@@ -1628,7 +1653,9 @@ impl ResourceManagerState {
         }
         let mut header = resource.lock();
         if !header.state.is_loading() {
-            header.state.switch_to_pending_state();
+            if !header.state.is_ok() {
+                header.state.switch_to_pending_state();
+            }
             drop(header);
             self.spawn_loading_task(resource, true)
         }
diff --git a/fyrox-resource/src/registry.rs b/fyrox-resource/src/registry.rs
index 2acfe58b4..e5110b54c 100644
--- a/fyrox-resource/src/registry.rs
+++ b/fyrox-resource/src/registry.rs
@@ -283,7 +283,6 @@ impl ResourceRegistryRefMut<'_> {
             panic!("Registering empty path.");
         }
         use std::collections::btree_map::Entry;
-        //self.registry.paths.insert(uuid, path)
         match self.registry.paths.entry(uuid) {
             Entry::Vacant(entry) => {
                 info!("Registered: {uuid} -> {path:?}");