diff --git a/crates/bevy_app/src/app.rs b/crates/bevy_app/src/app.rs
index 195bc71d5dd4e..3cab757fc7815 100644
--- a/crates/bevy_app/src/app.rs
+++ b/crates/bevy_app/src/app.rs
@@ -817,7 +817,7 @@ impl App {
     /// Gets read-only access to the [`Schedule`] with the provided `label` if it exists.
     pub fn get_schedule(&self, label: impl ScheduleLabel) -> Option<&Schedule> {
         let schedules = self.world.get_resource::<Schedules>()?;
-        schedules.get(&label)
+        schedules.into_inner().get(&label)
     }
 
     /// Gets read-write access to a [`Schedule`] with the provided `label` if it exists.
diff --git a/crates/bevy_app/src/main_schedule.rs b/crates/bevy_app/src/main_schedule.rs
index 004aba0a6fc0a..02800c973df97 100644
--- a/crates/bevy_app/src/main_schedule.rs
+++ b/crates/bevy_app/src/main_schedule.rs
@@ -1,8 +1,8 @@
 use crate::{App, Plugin};
 use bevy_ecs::{
     schedule::{ExecutorKind, Schedule, ScheduleLabel},
-    system::{Local, Resource},
-    world::{Mut, World},
+    system::{Local, ResMut, Resource},
+    world::World,
 };
 
 /// The schedule that contains the app logic that is evaluated each tick of [`App::update()`].
@@ -147,7 +147,7 @@ impl Main {
             *run_at_least_once = true;
         }
 
-        world.resource_scope(|world, order: Mut<MainScheduleOrder>| {
+        world.resource_scope(|world, order: ResMut<MainScheduleOrder>| {
             for label in &order.labels {
                 let _ = world.try_run_schedule(&**label);
             }
diff --git a/crates/bevy_asset/src/lib.rs b/crates/bevy_asset/src/lib.rs
index fcf4b09f19ba3..58b6e942f468e 100644
--- a/crates/bevy_asset/src/lib.rs
+++ b/crates/bevy_asset/src/lib.rs
@@ -537,7 +537,7 @@ mod tests {
     const LARGE_ITERATION_COUNT: usize = 10000;
 
     fn get<A: Asset>(world: &World, id: AssetId<A>) -> Option<&A> {
-        world.resource::<Assets<A>>().get(id)
+        world.resource::<Assets<A>>().into_inner().get(id)
     }
 
     #[derive(Resource, Default)]
@@ -1018,6 +1018,7 @@ mod tests {
                 let text = app
                     .world
                     .resource::<Assets<CoolText>>()
+                    .into_inner()
                     .get(&handle)
                     .unwrap();
                 assert_eq!(text.text, hello);
@@ -1129,7 +1130,7 @@ mod tests {
             let asset_server = world.resource::<AssetServer>();
             let loaded_folders = world.resource::<Assets<LoadedFolder>>();
             let cool_texts = world.resource::<Assets<CoolText>>();
-            for event in reader.read(events) {
+            for event in reader.read(&events) {
                 if let AssetEvent::LoadedWithDependencies { id } = event {
                     if *id == handle.id() {
                         let loaded_folder = loaded_folders.get(&handle).unwrap();
diff --git a/crates/bevy_asset/src/reflect.rs b/crates/bevy_asset/src/reflect.rs
index 6e00323826de1..293290f43bb17 100644
--- a/crates/bevy_asset/src/reflect.rs
+++ b/crates/bevy_asset/src/reflect.rs
@@ -128,7 +128,7 @@ impl<A: Asset + FromReflect> FromType<A> for ReflectAsset {
             handle_type_id: TypeId::of::<Handle<A>>(),
             assets_resource_type_id: TypeId::of::<Assets<A>>(),
             get: |world, handle| {
-                let assets = world.resource::<Assets<A>>();
+                let assets = world.resource::<Assets<A>>().into_inner();
                 let asset = assets.get(&handle.typed_debug_checked());
                 asset.map(|asset| asset as &dyn Reflect)
             },
@@ -156,7 +156,7 @@ impl<A: Asset + FromReflect> FromType<A> for ReflectAsset {
                 assets.len()
             },
             ids: |world| {
-                let assets = world.resource::<Assets<A>>();
+                let assets = world.resource::<Assets<A>>().into_inner();
                 Box::new(assets.ids().map(|i| i.untyped()))
             },
             remove: |world, handle| {
diff --git a/crates/bevy_asset/src/server/mod.rs b/crates/bevy_asset/src/server/mod.rs
index b4e8470b13c2d..dc96dcb436f26 100644
--- a/crates/bevy_asset/src/server/mod.rs
+++ b/crates/bevy_asset/src/server/mod.rs
@@ -710,7 +710,7 @@ impl AssetServer {
 
 /// A system that manages internal [`AssetServer`] events, such as finalizing asset loads.
 pub fn handle_internal_asset_events(world: &mut World) {
-    world.resource_scope(|world, server: Mut<AssetServer>| {
+    world.resource_scope(|world, server: ResMut<AssetServer>| {
         let mut infos = server.data.infos.write();
         for event in server.data.asset_event_receiver.try_iter() {
             match event {
diff --git a/crates/bevy_core_pipeline/src/core_3d/main_opaque_pass_3d_node.rs b/crates/bevy_core_pipeline/src/core_3d/main_opaque_pass_3d_node.rs
index 34d8c299c94c9..61aee4e1591e6 100644
--- a/crates/bevy_core_pipeline/src/core_3d/main_opaque_pass_3d_node.rs
+++ b/crates/bevy_core_pipeline/src/core_3d/main_opaque_pass_3d_node.rs
@@ -119,7 +119,7 @@ impl ViewNode for MainOpaquePass3dNode {
         if let (Some(skybox_pipeline), Some(skybox_bind_group)) =
             (skybox_pipeline, skybox_bind_group)
         {
-            let pipeline_cache = world.resource::<PipelineCache>();
+            let pipeline_cache = world.resource::<PipelineCache>().into_inner();
             if let Some(pipeline) = pipeline_cache.get_render_pipeline(skybox_pipeline.0) {
                 render_pass.set_render_pipeline(pipeline);
                 render_pass.set_bind_group(0, &skybox_bind_group.0, &[view_uniform_offset.offset]);
diff --git a/crates/bevy_core_pipeline/src/tonemapping/node.rs b/crates/bevy_core_pipeline/src/tonemapping/node.rs
index e3da4aa03e417..a5abcbe53c77b 100644
--- a/crates/bevy_core_pipeline/src/tonemapping/node.rs
+++ b/crates/bevy_core_pipeline/src/tonemapping/node.rs
@@ -104,8 +104,8 @@ impl ViewNode for TonemappingNode {
                 ];
 
                 entries.extend(get_lut_bindings(
-                    gpu_images,
-                    tonemapping_luts,
+                    &gpu_images,
+                    &tonemapping_luts,
                     tonemapping,
                     [3, 4],
                 ));
diff --git a/crates/bevy_ecs/src/lib.rs b/crates/bevy_ecs/src/lib.rs
index 06001b584dbdc..6893f8ecc5041 100644
--- a/crates/bevy_ecs/src/lib.rs
+++ b/crates/bevy_ecs/src/lib.rs
@@ -71,8 +71,8 @@ mod tests {
         component::{Component, ComponentId},
         entity::Entity,
         query::{Added, Changed, FilteredAccess, ReadOnlyWorldQuery, With, Without},
-        system::Resource,
-        world::{EntityRef, Mut, World},
+        system::{ResMut, Resource},
+        world::{EntityRef, World},
     };
     use bevy_tasks::{ComputeTaskPool, TaskPool};
     use std::{
@@ -1145,7 +1145,7 @@ mod tests {
             "removed resource has the correct value"
         );
         assert_eq!(
-            world.get_resource::<BigNum>(),
+            world.get_resource::<BigNum>().map(|res| res.into_inner()),
             None,
             "removed resource no longer exists"
         );
@@ -1157,13 +1157,13 @@ mod tests {
 
         world.insert_resource(BigNum(1));
         assert_eq!(
-            world.get_resource::<BigNum>(),
+            world.get_resource::<BigNum>().map(|res| res.into_inner()),
             Some(&BigNum(1)),
             "re-inserting resources works"
         );
 
         assert_eq!(
-            world.get_resource::<Num>(),
+            world.get_resource::<Num>().map(|res| res.into_inner()),
             Some(&Num(123)),
             "other resources are unaffected"
         );
@@ -1409,7 +1409,7 @@ mod tests {
     fn resource_scope() {
         let mut world = World::default();
         world.insert_resource(A(0));
-        world.resource_scope(|world: &mut World, mut value: Mut<A>| {
+        world.resource_scope(|world: &mut World, mut value: ResMut<A>| {
             value.0 += 1;
             assert!(!world.contains_resource::<A>());
         });
diff --git a/crates/bevy_ecs/src/reflect/entity_commands.rs b/crates/bevy_ecs/src/reflect/entity_commands.rs
index ca61ebb85c866..b00fe22313fe8 100644
--- a/crates/bevy_ecs/src/reflect/entity_commands.rs
+++ b/crates/bevy_ecs/src/reflect/entity_commands.rs
@@ -1,6 +1,5 @@
-use crate::prelude::Mut;
 use crate::reflect::AppTypeRegistry;
-use crate::system::{Command, EntityCommands, Resource};
+use crate::system::{Command, EntityCommands, ResMut, Resource};
 use crate::{entity::Entity, reflect::ReflectComponent, world::World};
 use bevy_reflect::{Reflect, TypeRegistry};
 use std::borrow::Cow;
@@ -234,7 +233,7 @@ pub struct InsertReflectWithRegistry<T: Resource + AsRef<TypeRegistry>> {
 
 impl<T: Resource + AsRef<TypeRegistry>> Command for InsertReflectWithRegistry<T> {
     fn apply(self, world: &mut World) {
-        world.resource_scope(|world, registry: Mut<T>| {
+        world.resource_scope(|world, registry: ResMut<T>| {
             let registry: &TypeRegistry = registry.as_ref().as_ref();
             insert_reflect(world, self.entity, registry, self.component);
         });
@@ -299,7 +298,7 @@ pub struct RemoveReflectWithRegistry<T: Resource + AsRef<TypeRegistry>> {
 
 impl<T: Resource + AsRef<TypeRegistry>> Command for RemoveReflectWithRegistry<T> {
     fn apply(self, world: &mut World) {
-        world.resource_scope(|world, registry: Mut<T>| {
+        world.resource_scope(|world, registry: ResMut<T>| {
             let registry: &TypeRegistry = registry.as_ref().as_ref();
             remove_reflect(world, self.entity, registry, self.component_type_name);
         });
diff --git a/crates/bevy_ecs/src/reflect/resource.rs b/crates/bevy_ecs/src/reflect/resource.rs
index 924eb54b09c8e..bcf5944c61885 100644
--- a/crates/bevy_ecs/src/reflect/resource.rs
+++ b/crates/bevy_ecs/src/reflect/resource.rs
@@ -188,7 +188,11 @@ impl<C: Resource + Reflect + FromWorld> FromType<C> for ReflectResource {
             remove: |world| {
                 world.remove_resource::<C>();
             },
-            reflect: |world| world.get_resource::<C>().map(|res| res as &dyn Reflect),
+            reflect: |world| {
+                world
+                    .get_resource::<C>()
+                    .map(|res| res.into_inner() as &dyn Reflect)
+            },
             reflect_unchecked_mut: |world| {
                 // SAFETY: all usages of `reflect_unchecked_mut` guarantee that there is either a single mutable
                 // reference or multiple immutable ones alive at any given point
@@ -200,7 +204,7 @@ impl<C: Resource + Reflect + FromWorld> FromType<C> for ReflectResource {
                 }
             },
             copy: |source_world, destination_world| {
-                let source_resource = source_world.resource::<C>();
+                let source_resource = source_world.resource::<C>().into_inner();
                 let mut destination_resource = C::from_world(destination_world);
                 destination_resource.apply(source_resource);
                 destination_world.insert_resource(destination_resource);
diff --git a/crates/bevy_ecs/src/system/function_system.rs b/crates/bevy_ecs/src/system/function_system.rs
index 9e5fd21513dc9..5b9a2c3f21170 100644
--- a/crates/bevy_ecs/src/system/function_system.rs
+++ b/crates/bevy_ecs/src/system/function_system.rs
@@ -152,7 +152,7 @@ impl SystemMeta {
 /// });
 ///
 /// // Later, fetch the cached system state, saving on overhead
-/// world.resource_scope(|world, mut cached_state: Mut<CachedSystemState>| {
+/// world.resource_scope(|world, mut cached_state: ResMut<CachedSystemState>| {
 ///     let mut event_reader = cached_state.event_state.get_mut(world);
 ///
 ///     for events in event_reader.iter() {
diff --git a/crates/bevy_ecs/src/system/mod.rs b/crates/bevy_ecs/src/system/mod.rs
index 9079d3a9d4745..6e6c76d580282 100644
--- a/crates/bevy_ecs/src/system/mod.rs
+++ b/crates/bevy_ecs/src/system/mod.rs
@@ -1080,7 +1080,7 @@ mod tests {
         impl FromWorld for Foo {
             fn from_world(world: &mut World) -> Self {
                 Foo {
-                    value: world.resource::<ProtoFoo>().value + 1,
+                    value: world.resource::<ProtoFoo>().into_inner().value + 1,
                 }
             }
         }
@@ -1934,6 +1934,9 @@ mod tests {
         );
         sched.initialize(&mut world).unwrap();
         sched.run(&mut world);
-        assert_eq!(world.get_resource(), Some(&C(3)));
+        assert_eq!(
+            world.get_resource::<C>().map(|res| res.into_inner()),
+            Some(&C(3))
+        );
     }
 }
diff --git a/crates/bevy_ecs/src/world/mod.rs b/crates/bevy_ecs/src/world/mod.rs
index be43fcce3d770..0c2abb4e90b6b 100644
--- a/crates/bevy_ecs/src/world/mod.rs
+++ b/crates/bevy_ecs/src/world/mod.rs
@@ -22,7 +22,7 @@ use crate::{
     removal_detection::RemovedComponentEvents,
     schedule::{Schedule, ScheduleLabel, Schedules},
     storage::{ResourceData, Storages},
-    system::Resource,
+    system::{Res, ResMut, Resource},
     world::error::TryRunScheduleError,
 };
 use bevy_ptr::{OwningPtr, Ptr};
@@ -1221,7 +1221,7 @@ impl World {
     /// use [`get_resource_or_insert_with`](World::get_resource_or_insert_with).
     #[inline]
     #[track_caller]
-    pub fn resource<R: Resource>(&self) -> &R {
+    pub fn resource<R: Resource>(&self) -> Res<'_, R> {
         match self.get_resource() {
             Some(x) => x,
             None => panic!(
@@ -1245,7 +1245,7 @@ impl World {
     /// use [`get_resource_or_insert_with`](World::get_resource_or_insert_with).
     #[inline]
     #[track_caller]
-    pub fn resource_mut<R: Resource>(&mut self) -> Mut<'_, R> {
+    pub fn resource_mut<R: Resource>(&mut self) -> ResMut<'_, R> {
         match self.get_resource_mut() {
             Some(x) => x,
             None => panic!(
@@ -1260,20 +1260,20 @@ impl World {
 
     /// Gets a reference to the resource of the given type if it exists
     #[inline]
-    pub fn get_resource<R: Resource>(&self) -> Option<&R> {
+    pub fn get_resource<R: Resource>(&self) -> Option<Res<'_, R>> {
         // SAFETY:
         // - `as_unsafe_world_cell_readonly` gives permission to access everything immutably
         // - `&self` ensures nothing in world is borrowed immutably
-        unsafe { self.as_unsafe_world_cell_readonly().get_resource() }
+        unsafe { self.as_unsafe_world_cell_readonly().get_resource::<R>() }
     }
 
     /// Gets a mutable reference to the resource of the given type if it exists
     #[inline]
-    pub fn get_resource_mut<R: Resource>(&mut self) -> Option<Mut<'_, R>> {
+    pub fn get_resource_mut<R: Resource>(&mut self) -> Option<ResMut<'_, R>> {
         // SAFETY:
         // - `as_unsafe_world_cell` gives permission to access everything mutably
         // - `&mut self` ensures nothing in world is borrowed
-        unsafe { self.as_unsafe_world_cell().get_resource_mut() }
+        unsafe { self.as_unsafe_world_cell().get_resource_mut::<R>() }
     }
 
     /// Gets a mutable reference to the resource of type `T` if it exists,
@@ -1282,7 +1282,7 @@ impl World {
     pub fn get_resource_or_insert_with<R: Resource>(
         &mut self,
         func: impl FnOnce() -> R,
-    ) -> Mut<'_, R> {
+    ) -> ResMut<'_, R> {
         let change_tick = self.change_tick();
         let last_change_tick = self.last_change_tick();
 
@@ -1303,7 +1303,10 @@ impl World {
                 .debug_checked_unwrap()
         };
         // SAFETY: The underlying type of the resource is `R`.
-        unsafe { data.with_type::<R>() }
+        let Mut { value, ticks } = unsafe { data.with_type::<R>() };
+
+        // TODO: Maybe `impl<R: Resource> From<Mut<R>> for ResMut<R>`?
+        ResMut { value, ticks }
     }
 
     /// Gets an immutable reference to the non-send resource of the given type, if it exists.
@@ -1536,13 +1539,16 @@ impl World {
     /// world.insert_resource(A(1));
     /// let entity = world.spawn(B(1)).id();
     ///
-    /// world.resource_scope(|world, mut a: Mut<A>| {
+    /// world.resource_scope(|world, mut a: ResMut<A>| {
     ///     let b = world.get_mut::<B>(entity).unwrap();
     ///     a.0 += b.0;
     /// });
     /// assert_eq!(world.get_resource::<A>().unwrap().0, 2);
     /// ```
-    pub fn resource_scope<R: Resource, U>(&mut self, f: impl FnOnce(&mut World, Mut<R>) -> U) -> U {
+    pub fn resource_scope<R: Resource, U>(
+        &mut self,
+        f: impl FnOnce(&mut World, ResMut<R>) -> U,
+    ) -> U {
         let last_change_tick = self.last_change_tick();
         let change_tick = self.change_tick();
 
@@ -1559,7 +1565,7 @@ impl World {
         // Read the value onto the stack to avoid potential mut aliasing.
         // SAFETY: `ptr` was obtained from the TypeId of `R`.
         let mut value = unsafe { ptr.read::<R>() };
-        let value_mut = Mut {
+        let value_mut = ResMut {
             value: &mut value,
             ticks: TicksMut {
                 added: &mut ticks.added,
diff --git a/crates/bevy_ecs/src/world/unsafe_world_cell.rs b/crates/bevy_ecs/src/world/unsafe_world_cell.rs
index 85dcbc5554cdf..b3303aa8d4e68 100644
--- a/crates/bevy_ecs/src/world/unsafe_world_cell.rs
+++ b/crates/bevy_ecs/src/world/unsafe_world_cell.rs
@@ -13,7 +13,7 @@ use crate::{
     entity::{Entities, Entity, EntityLocation},
     prelude::Component,
     storage::{Column, ComponentSparseSet, Storages},
-    system::Resource,
+    system::{Res, ResMut, Resource},
 };
 use bevy_ptr::Ptr;
 use std::{any::TypeId, cell::UnsafeCell, fmt::Debug, marker::PhantomData};
@@ -45,7 +45,7 @@ use std::{any::TypeId, cell::UnsafeCell, fmt::Debug, marker::PhantomData};
 ///
 /// ```
 /// use bevy_ecs::world::World;
-/// use bevy_ecs::change_detection::Mut;
+/// use bevy_ecs::change_detection::ResMut;
 /// use bevy_ecs::system::Resource;
 /// use bevy_ecs::world::unsafe_world_cell::UnsafeWorldCell;
 ///
@@ -55,7 +55,7 @@ use std::{any::TypeId, cell::UnsafeCell, fmt::Debug, marker::PhantomData};
 /// struct OnlyComponentAccessWorld<'w>(UnsafeWorldCell<'w>);
 ///
 /// impl<'w> OnlyResourceAccessWorld<'w> {
-///     fn get_resource_mut<T: Resource>(&mut self) -> Option<Mut<'w, T>> {
+///     fn get_resource_mut<T: Resource>(&mut self) -> Option<ResMut<'w, T>> {
 ///         // SAFETY: resource access is allowed through this UnsafeWorldCell
 ///         unsafe { self.0.get_resource_mut::<T>() }
 ///     }
@@ -323,15 +323,22 @@ impl<'w> UnsafeWorldCell<'w> {
     /// - the [`UnsafeWorldCell`] has permission to access the resource
     /// - no mutable reference to the resource exists at the same time
     #[inline]
-    pub unsafe fn get_resource<R: Resource>(self) -> Option<&'w R> {
+    pub unsafe fn get_resource<R: Resource>(self) -> Option<Res<'w, R>> {
         let component_id = self.components().get_resource_id(TypeId::of::<R>())?;
+        let last_change_tick = self.last_change_tick();
+        let change_tick = self.change_tick();
+
         // SAFETY: caller ensures `self` has permission to access the resource
         //  caller also ensure that no mutable reference to the resource exists
-        unsafe {
-            self.get_resource_by_id(component_id)
-                // SAFETY: `component_id` was obtained from the type ID of `R`.
-                .map(|ptr| ptr.deref::<R>())
-        }
+        let (component_ptr, tick_cells) = unsafe { self.get_resource_with_ticks(component_id) }?;
+
+        // SAFETY: `component_id` was obtained from the type ID of `R`.
+        let value = unsafe { component_ptr.deref::<R>() };
+
+        // SAFETY: The caller ensures this will not interact with an existing mutable borrow.
+        let ticks = unsafe { Ticks::from_tick_cells(tick_cells, last_change_tick, change_tick) };
+
+        Some(Res { value, ticks })
     }
 
     /// Gets a pointer to the resource with the id [`ComponentId`] if it exists.
@@ -404,16 +411,18 @@ impl<'w> UnsafeWorldCell<'w> {
     /// - the [`UnsafeWorldCell`] has permission to access the resource mutably
     /// - no other references to the resource exist at the same time
     #[inline]
-    pub unsafe fn get_resource_mut<R: Resource>(self) -> Option<Mut<'w, R>> {
+    pub unsafe fn get_resource_mut<R: Resource>(self) -> Option<ResMut<'w, R>> {
         let component_id = self.components().get_resource_id(TypeId::of::<R>())?;
+
         // SAFETY:
         // - caller ensures `self` has permission to access the resource mutably
         // - caller ensures no other references to the resource exist
-        unsafe {
-            self.get_resource_mut_by_id(component_id)
-                // `component_id` was gotten from `TypeId::of::<R>()`
-                .map(|ptr| ptr.with_type::<R>())
-        }
+        let data = unsafe { self.get_resource_mut_by_id(component_id) }?;
+
+        // SAFETY: `component_id` was gotten from `TypeId::of::<R>()`
+        let Mut { value, ticks } = unsafe { data.with_type::<R>() };
+
+        Some(ResMut { value, ticks })
     }
 
     /// Gets a pointer to the resource with the id [`ComponentId`] if it exists.
diff --git a/crates/bevy_ecs/src/world/world_cell.rs b/crates/bevy_ecs/src/world/world_cell.rs
index d97cdcac9f660..dabfd84d14945 100644
--- a/crates/bevy_ecs/src/world/world_cell.rs
+++ b/crates/bevy_ecs/src/world/world_cell.rs
@@ -209,7 +209,7 @@ impl<'w> WorldCell<'w> {
 
         WorldBorrow::try_new(
             // SAFETY: access is checked by WorldBorrow
-            || unsafe { self.world.get_resource::<T>() },
+            || unsafe { self.world.get_resource::<T>() }.map(|res| res.into_inner()),
             archetype_component_id,
             self.access.clone(),
         )
@@ -243,7 +243,7 @@ impl<'w> WorldCell<'w> {
             .get_resource_archetype_component_id(component_id)?;
         WorldBorrowMut::try_new(
             // SAFETY: access is checked by WorldBorrowMut
-            || unsafe { self.world.get_resource_mut::<T>() },
+            || unsafe { self.world.get_resource_mut::<T>() }.map(|res| res.into()),
             archetype_component_id,
             self.access.clone(),
         )
diff --git a/crates/bevy_pbr/src/material.rs b/crates/bevy_pbr/src/material.rs
index d9c835abcaffa..34dd246c8e255 100644
--- a/crates/bevy_pbr/src/material.rs
+++ b/crates/bevy_pbr/src/material.rs
@@ -341,7 +341,7 @@ impl<M: Material> FromWorld for MaterialPipeline<M> {
 
         MaterialPipeline {
             mesh_pipeline: world.resource::<MeshPipeline>().clone(),
-            material_layout: M::bind_group_layout(render_device),
+            material_layout: M::bind_group_layout(&render_device),
             vertex_shader: match M::vertex_shader() {
                 ShaderRef::Default => None,
                 ShaderRef::Handle(handle) => Some(handle),
diff --git a/crates/bevy_pbr/src/prepass/mod.rs b/crates/bevy_pbr/src/prepass/mod.rs
index 9169d1083fde1..201a1d1ef1a52 100644
--- a/crates/bevy_pbr/src/prepass/mod.rs
+++ b/crates/bevy_pbr/src/prepass/mod.rs
@@ -320,7 +320,7 @@ impl<M: Material> FromWorld for PrepassPipeline<M> {
                 ShaderRef::Handle(handle) => Some(handle),
                 ShaderRef::Path(path) => Some(asset_server.load(path)),
             },
-            material_layout: M::bind_group_layout(render_device),
+            material_layout: M::bind_group_layout(&render_device),
             material_pipeline: world.resource::<MaterialPipeline<M>>().clone(),
             _marker: PhantomData,
         }
diff --git a/crates/bevy_pbr/src/render/mesh.rs b/crates/bevy_pbr/src/render/mesh.rs
index 992ae4cf3fa7d..5310aa9b2b0dd 100644
--- a/crates/bevy_pbr/src/render/mesh.rs
+++ b/crates/bevy_pbr/src/render/mesh.rs
@@ -137,7 +137,7 @@ impl Plugin for MeshRenderPlugin {
 
         if let Ok(render_app) = app.get_sub_app_mut(RenderApp) {
             if let Some(per_object_buffer_batch_size) = GpuArrayBuffer::<MeshUniform>::batch_size(
-                render_app.world.resource::<RenderDevice>(),
+                render_app.world.resource::<RenderDevice>().into_inner(),
             ) {
                 mesh_bindings_shader_defs.push(ShaderDefVal::UInt(
                     "PER_OBJECT_BUFFER_BATCH_SIZE".into(),
@@ -147,7 +147,7 @@ impl Plugin for MeshRenderPlugin {
 
             render_app
                 .insert_resource(GpuArrayBuffer::<MeshUniform>::new(
-                    render_app.world.resource::<RenderDevice>(),
+                    render_app.world.resource::<RenderDevice>().into_inner(),
                 ))
                 .init_resource::<MeshPipeline>();
         }
diff --git a/crates/bevy_pbr/src/ssao/mod.rs b/crates/bevy_pbr/src/ssao/mod.rs
index 3a31c0afbe620..8662a2473dcc3 100644
--- a/crates/bevy_pbr/src/ssao/mod.rs
+++ b/crates/bevy_pbr/src/ssao/mod.rs
@@ -326,7 +326,7 @@ impl FromWorld for SsaoPipelines {
 
         let hilbert_index_lut = render_device
             .create_texture_with_data(
-                render_queue,
+                &render_queue,
                 &(TextureDescriptor {
                     label: Some("ssao_hilbert_index_lut"),
                     size: Extent3d {
diff --git a/crates/bevy_render/src/gpu_component_array_buffer.rs b/crates/bevy_render/src/gpu_component_array_buffer.rs
index 7685625fdf2a5..a505093610d30 100644
--- a/crates/bevy_render/src/gpu_component_array_buffer.rs
+++ b/crates/bevy_render/src/gpu_component_array_buffer.rs
@@ -28,7 +28,7 @@ impl<C: Component + GpuArrayBufferable> Plugin for GpuComponentArrayBufferPlugin
     fn finish(&self, app: &mut App) {
         if let Ok(render_app) = app.get_sub_app_mut(RenderApp) {
             render_app.insert_resource(GpuArrayBuffer::<C>::new(
-                render_app.world.resource::<RenderDevice>(),
+                render_app.world.resource::<RenderDevice>().into_inner(),
             ));
         }
     }
diff --git a/crates/bevy_render/src/lib.rs b/crates/bevy_render/src/lib.rs
index 1709c0ea048c5..c012901e9cb72 100644
--- a/crates/bevy_render/src/lib.rs
+++ b/crates/bevy_render/src/lib.rs
@@ -472,7 +472,7 @@ unsafe fn initialize_render_app(app: &mut App) {
 /// the render schedule rather than during extraction to allow the commands to run in parallel with the
 /// main app when pipelined rendering is enabled.
 fn apply_extract_commands(render_world: &mut World) {
-    render_world.resource_scope(|render_world, mut schedules: Mut<Schedules>| {
+    render_world.resource_scope(|render_world, mut schedules: ResMut<Schedules>| {
         schedules
             .get_mut(&ExtractSchedule)
             .unwrap()
diff --git a/crates/bevy_render/src/pipelined_rendering.rs b/crates/bevy_render/src/pipelined_rendering.rs
index f8fcfe53e978e..f0c2d4ef2f0c8 100644
--- a/crates/bevy_render/src/pipelined_rendering.rs
+++ b/crates/bevy_render/src/pipelined_rendering.rs
@@ -3,8 +3,8 @@ use async_channel::{Receiver, Sender};
 use bevy_app::{App, AppLabel, Main, Plugin, SubApp};
 use bevy_ecs::{
     schedule::MainThreadExecutor,
-    system::Resource,
-    world::{Mut, World},
+    system::{ResMut, Resource},
+    world::World,
 };
 use bevy_tasks::ComputeTaskPool;
 
@@ -135,7 +135,7 @@ impl Plugin for PipelinedRenderingPlugin {
 // This function waits for the rendering world to be received,
 // runs extract, and then sends the rendering world back to the render thread.
 fn update_rendering(app_world: &mut World, _sub_app: &mut App) {
-    app_world.resource_scope(|world, main_thread_executor: Mut<MainThreadExecutor>| {
+    app_world.resource_scope(|world, main_thread_executor: ResMut<MainThreadExecutor>| {
         // we use a scope here to run any main thread tasks that the render world still needs to run
         // while we wait for the render world to be received.
         let mut render_app = ComputeTaskPool::get()
diff --git a/crates/bevy_render/src/renderer/mod.rs b/crates/bevy_render/src/renderer/mod.rs
index f98eb81189375..6d57b05a6af66 100644
--- a/crates/bevy_render/src/renderer/mod.rs
+++ b/crates/bevy_render/src/renderer/mod.rs
@@ -23,7 +23,7 @@ use wgpu::{
 
 /// Updates the [`RenderGraph`] with all of its nodes and then runs it to render the entire frame.
 pub fn render_system(world: &mut World) {
-    world.resource_scope(|world, mut graph: Mut<RenderGraph>| {
+    world.resource_scope(|world, mut graph: ResMut<RenderGraph>| {
         graph.update(world);
     });
     let graph = world.resource::<RenderGraph>();
@@ -31,7 +31,7 @@ pub fn render_system(world: &mut World) {
     let render_queue = world.resource::<RenderQueue>();
 
     if let Err(e) = RenderGraphRunner::run(
-        graph,
+        &graph,
         render_device.clone(), // TODO: is this clone really necessary?
         &render_queue.0,
         world,
diff --git a/crates/bevy_render/src/texture/fallback_image.rs b/crates/bevy_render/src/texture/fallback_image.rs
index 24e91bc224dcc..debff01073e8f 100644
--- a/crates/bevy_render/src/texture/fallback_image.rs
+++ b/crates/bevy_render/src/texture/fallback_image.rs
@@ -116,54 +116,54 @@ impl FromWorld for FallbackImage {
         let default_sampler = world.resource::<DefaultImageSampler>();
         Self {
             d1: fallback_image_new(
-                render_device,
-                render_queue,
-                default_sampler,
+                &render_device,
+                &render_queue,
+                &default_sampler,
                 TextureFormat::bevy_default(),
                 TextureViewDimension::D1,
                 1,
                 255,
             ),
             d2: fallback_image_new(
-                render_device,
-                render_queue,
-                default_sampler,
+                &render_device,
+                &render_queue,
+                &default_sampler,
                 TextureFormat::bevy_default(),
                 TextureViewDimension::D2,
                 1,
                 255,
             ),
             d2_array: fallback_image_new(
-                render_device,
-                render_queue,
-                default_sampler,
+                &render_device,
+                &render_queue,
+                &default_sampler,
                 TextureFormat::bevy_default(),
                 TextureViewDimension::D2Array,
                 1,
                 255,
             ),
             cube: fallback_image_new(
-                render_device,
-                render_queue,
-                default_sampler,
+                &render_device,
+                &render_queue,
+                &default_sampler,
                 TextureFormat::bevy_default(),
                 TextureViewDimension::Cube,
                 1,
                 255,
             ),
             cube_array: fallback_image_new(
-                render_device,
-                render_queue,
-                default_sampler,
+                &render_device,
+                &render_queue,
+                &default_sampler,
                 TextureFormat::bevy_default(),
                 TextureViewDimension::CubeArray,
                 1,
                 255,
             ),
             d3: fallback_image_new(
-                render_device,
-                render_queue,
-                default_sampler,
+                &render_device,
+                &render_queue,
+                &default_sampler,
                 TextureFormat::bevy_default(),
                 TextureViewDimension::D3,
                 1,
@@ -179,9 +179,9 @@ impl FromWorld for FallbackImageZero {
         let render_queue = world.resource::<RenderQueue>();
         let default_sampler = world.resource::<DefaultImageSampler>();
         Self(fallback_image_new(
-            render_device,
-            render_queue,
-            default_sampler,
+            &render_device,
+            &render_queue,
+            &default_sampler,
             TextureFormat::bevy_default(),
             TextureViewDimension::D2,
             1,
@@ -196,9 +196,9 @@ impl FromWorld for FallbackImageCubemap {
         let render_queue = world.resource::<RenderQueue>();
         let default_sampler = world.resource::<DefaultImageSampler>();
         Self(fallback_image_new(
-            render_device,
-            render_queue,
-            default_sampler,
+            &render_device,
+            &render_queue,
+            &default_sampler,
             TextureFormat::bevy_default(),
             TextureViewDimension::Cube,
             1,
diff --git a/crates/bevy_scene/src/dynamic_scene_builder.rs b/crates/bevy_scene/src/dynamic_scene_builder.rs
index 62e5a3ed1f348..e8e26915cc135 100644
--- a/crates/bevy_scene/src/dynamic_scene_builder.rs
+++ b/crates/bevy_scene/src/dynamic_scene_builder.rs
@@ -232,7 +232,11 @@ impl<'w> DynamicSceneBuilder<'w> {
     /// [`allow`]: Self::allow
     /// [`deny`]: Self::deny
     pub fn extract_entities(&mut self, entities: impl Iterator<Item = Entity>) -> &mut Self {
-        let type_registry = self.original_world.resource::<AppTypeRegistry>().read();
+        let type_registry = self
+            .original_world
+            .resource::<AppTypeRegistry>()
+            .into_inner()
+            .read();
 
         for entity in entities {
             if self.extracted_scene.contains_key(&entity) {
@@ -303,7 +307,11 @@ impl<'w> DynamicSceneBuilder<'w> {
     /// [`allow_resource`]: Self::allow_resource
     /// [`deny_resource`]: Self::deny_resource
     pub fn extract_resources(&mut self) -> &mut Self {
-        let type_registry = self.original_world.resource::<AppTypeRegistry>().read();
+        let type_registry = self
+            .original_world
+            .resource::<AppTypeRegistry>()
+            .into_inner()
+            .read();
 
         for (component_id, _) in self.original_world.storages().resources.iter() {
             let mut extract_and_push = || {
diff --git a/crates/bevy_scene/src/scene_spawner.rs b/crates/bevy_scene/src/scene_spawner.rs
index ebb037afdc764..d91937ad2dc01 100644
--- a/crates/bevy_scene/src/scene_spawner.rs
+++ b/crates/bevy_scene/src/scene_spawner.rs
@@ -4,8 +4,8 @@ use bevy_ecs::{
     entity::Entity,
     event::{Event, Events, ManualEventReader},
     reflect::AppTypeRegistry,
-    system::{Command, Resource},
-    world::{Mut, World},
+    system::{Command, ResMut, Resource},
+    world::World,
 };
 use bevy_hierarchy::{AddChild, Parent};
 use bevy_utils::{tracing::error, HashMap, HashSet};
@@ -145,7 +145,7 @@ impl SceneSpawner {
         id: AssetId<DynamicScene>,
         entity_map: &mut HashMap<Entity, Entity>,
     ) -> Result<(), SceneSpawnError> {
-        world.resource_scope(|world, scenes: Mut<Assets<DynamicScene>>| {
+        world.resource_scope(|world, scenes: ResMut<Assets<DynamicScene>>| {
             let scene = scenes
                 .get(id)
                 .ok_or(SceneSpawnError::NonExistentScene { id })?;
@@ -167,7 +167,7 @@ impl SceneSpawner {
         id: AssetId<Scene>,
         instance_id: InstanceId,
     ) -> Result<InstanceId, SceneSpawnError> {
-        world.resource_scope(|world, scenes: Mut<Assets<Scene>>| {
+        world.resource_scope(|world, scenes: ResMut<Assets<Scene>>| {
             let scene = scenes
                 .get(id)
                 .ok_or(SceneSpawnError::NonExistentRealScene { id })?;
@@ -309,7 +309,7 @@ impl SceneSpawner {
 }
 
 pub fn scene_spawner_system(world: &mut World) {
-    world.resource_scope(|world, mut scene_spawner: Mut<SceneSpawner>| {
+    world.resource_scope(|world, mut scene_spawner: ResMut<SceneSpawner>| {
         // remove any loading instances where parent is deleted
         let mut dead_instances = HashSet::default();
         scene_spawner
@@ -336,7 +336,7 @@ pub fn scene_spawner_system(world: &mut World) {
         let scene_spawner = &mut *scene_spawner;
         for event in scene_spawner
             .scene_asset_event_reader
-            .read(scene_asset_events)
+            .read(&scene_asset_events)
         {
             if let AssetEvent::Modified { id } = event {
                 if scene_spawner.spawned_dynamic_scenes.contains_key(id) {
diff --git a/crates/bevy_scene/src/serde.rs b/crates/bevy_scene/src/serde.rs
index c91d8084ff2db..48449049942ba 100644
--- a/crates/bevy_scene/src/serde.rs
+++ b/crates/bevy_scene/src/serde.rs
@@ -588,7 +588,7 @@ mod tests {
 )"#;
         let mut deserializer = ron::de::Deserializer::from_str(input).unwrap();
         let scene_deserializer = SceneDeserializer {
-            type_registry: &world.resource::<AppTypeRegistry>().read(),
+            type_registry: &world.resource::<AppTypeRegistry>().into_inner().read(),
         };
         let scene = scene_deserializer.deserialize(&mut deserializer).unwrap();
 
diff --git a/crates/bevy_sprite/src/mesh2d/material.rs b/crates/bevy_sprite/src/mesh2d/material.rs
index 4b496c7242ac4..95d9979f98d81 100644
--- a/crates/bevy_sprite/src/mesh2d/material.rs
+++ b/crates/bevy_sprite/src/mesh2d/material.rs
@@ -290,7 +290,7 @@ impl<M: Material2d> FromWorld for Material2dPipeline<M> {
     fn from_world(world: &mut World) -> Self {
         let asset_server = world.resource::<AssetServer>();
         let render_device = world.resource::<RenderDevice>();
-        let material2d_layout = M::bind_group_layout(render_device);
+        let material2d_layout = M::bind_group_layout(&render_device);
 
         Material2dPipeline {
             mesh2d_pipeline: world.resource::<Mesh2dPipeline>().clone(),
diff --git a/crates/bevy_sprite/src/mesh2d/mesh.rs b/crates/bevy_sprite/src/mesh2d/mesh.rs
index 2717acd394d4e..36a8304e96f50 100644
--- a/crates/bevy_sprite/src/mesh2d/mesh.rs
+++ b/crates/bevy_sprite/src/mesh2d/mesh.rs
@@ -110,7 +110,7 @@ impl Plugin for Mesh2dRenderPlugin {
 
         if let Ok(render_app) = app.get_sub_app_mut(RenderApp) {
             if let Some(per_object_buffer_batch_size) = GpuArrayBuffer::<Mesh2dUniform>::batch_size(
-                render_app.world.resource::<RenderDevice>(),
+                render_app.world.resource::<RenderDevice>().into_inner(),
             ) {
                 mesh_bindings_shader_defs.push(ShaderDefVal::UInt(
                     "PER_OBJECT_BUFFER_BATCH_SIZE".into(),
@@ -120,7 +120,7 @@ impl Plugin for Mesh2dRenderPlugin {
 
             render_app
                 .insert_resource(GpuArrayBuffer::<Mesh2dUniform>::new(
-                    render_app.world.resource::<RenderDevice>(),
+                    render_app.world.resource::<RenderDevice>().into_inner(),
                 ))
                 .init_resource::<Mesh2dPipeline>();
         }
diff --git a/crates/bevy_winit/src/lib.rs b/crates/bevy_winit/src/lib.rs
index a13c158709bfe..8ea3c4e292e64 100644
--- a/crates/bevy_winit/src/lib.rs
+++ b/crates/bevy_winit/src/lib.rs
@@ -356,7 +356,11 @@ pub fn winit_runner(mut app: App) {
             }
 
             if let Some(app_exit_events) = app.world.get_resource::<Events<AppExit>>() {
-                if app_exit_event_reader.read(app_exit_events).last().is_some() {
+                if app_exit_event_reader
+                    .read(&app_exit_events)
+                    .last()
+                    .is_some()
+                {
                     *control_flow = ControlFlow::Exit;
                     return;
                 }
@@ -723,14 +727,22 @@ pub fn winit_runner(mut app: App) {
                         if let Some(app_redraw_events) =
                             app.world.get_resource::<Events<RequestRedraw>>()
                         {
-                            if redraw_event_reader.read(app_redraw_events).last().is_some() {
+                            if redraw_event_reader
+                                .read(&app_redraw_events)
+                                .last()
+                                .is_some()
+                            {
                                 runner_state.redraw_requested = true;
                                 *control_flow = ControlFlow::Poll;
                             }
                         }
 
                         if let Some(app_exit_events) = app.world.get_resource::<Events<AppExit>>() {
-                            if app_exit_event_reader.read(app_exit_events).last().is_some() {
+                            if app_exit_event_reader
+                                .read(&app_exit_events)
+                                .last()
+                                .is_some()
+                            {
                                 *control_flow = ControlFlow::Exit;
                             }
                         }
diff --git a/examples/scene/scene.rs b/examples/scene/scene.rs
index da09648c244e3..eed992832c40d 100644
--- a/examples/scene/scene.rs
+++ b/examples/scene/scene.rs
@@ -121,7 +121,7 @@ fn save_scene_system(world: &mut World) {
     let scene = DynamicScene::from_world(&scene_world);
 
     // Scenes can be serialized like this:
-    let type_registry = world.resource::<AppTypeRegistry>();
+    let type_registry = world.resource::<AppTypeRegistry>().into_inner();
     let serialized_scene = scene.serialize_ron(type_registry).unwrap();
 
     // Showing the scene in the console
diff --git a/tests/how_to_test_systems.rs b/tests/how_to_test_systems.rs
index 23b29bd550c2b..ce5fc58c9393f 100644
--- a/tests/how_to_test_systems.rs
+++ b/tests/how_to_test_systems.rs
@@ -109,7 +109,7 @@ fn did_despawn_enemy() {
     // Get `EnemyDied` event reader
     let enemy_died_events = app.world.resource::<Events<EnemyDied>>();
     let mut enemy_died_reader = enemy_died_events.get_reader();
-    let enemy_died = enemy_died_reader.read(enemy_died_events).next().unwrap();
+    let enemy_died = enemy_died_reader.read(&enemy_died_events).next().unwrap();
 
     // Check the event has been sent
     assert_eq!(enemy_died.0, 1);