diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4198681..e86d23d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,7 @@
 # Changelog
 
+- all texture atlas layout parameters are integers (u32) now
+
 ## v0.20.2 - 18.05.2024
 - Fix texture atlas layout in asset collections (see [#212](https://github.com/NiklasEi/bevy_asset_loader/pull/212))
 
diff --git a/bevy_asset_loader/Cargo.toml b/bevy_asset_loader/Cargo.toml
index 7f6b67a..3ef0ed8 100644
--- a/bevy_asset_loader/Cargo.toml
+++ b/bevy_asset_loader/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_asset_loader"
-version = "0.20.2"
+version = "0.21.0-rc2.1"
 authors = ["Niklas Eicker <git@nikl.me>"]
 edition = "2021"
 license = "MIT OR Apache-2.0"
@@ -22,20 +22,20 @@ standard_dynamic_assets = ["dep:bevy_common_assets", "dep:serde"]
 progress_tracking = ["dep:iyes_progress"]
 
 [dependencies]
-bevy = { version = "0.13", default-features = false, features = ["bevy_asset"] }
-bevy_asset_loader_derive = { version = "=0.20.2", path = "../bevy_asset_loader_derive" }
+bevy = { version = "0.14.0-rc.2", default-features = false, features = ["bevy_asset"] }
+bevy_asset_loader_derive = { version = "=0.21.0-rc2.1", path = "../bevy_asset_loader_derive" }
 anyhow = "1"
 path-slash = "0.2"
 
-bevy_common_assets = { version = "0.10", features = ["ron"], optional = true }
+bevy_common_assets = { version = "0.11.0-rc.2.1", features = ["ron"], optional = true }
 serde = { version = "1", optional = true }
-iyes_progress = { version = "0.11", optional = true }
+iyes_progress = { git = "https://github.com/NiklasEi/iyes_progress", branch = "update_bevy_main_for_0_14_cycle", optional = true }
 
 [dev-dependencies]
-bevy = { version = "0.13", features = ["vorbis"] }
+bevy = { version = "0.14.0-rc.2", features = ["vorbis"] }
 anyhow = "1"
-iyes_progress = { version = "0.11" }
-bevy_common_assets = { version = "0.10", features = ["ron"] }
+iyes_progress = { git = "https://github.com/NiklasEi/iyes_progress", branch = "update_bevy_main_for_0_14_cycle" }
+bevy_common_assets = { version = "0.11.0-rc.2.1", features = ["ron"] }
 serde = { version = "1" }
 ron = "0.8.1"
 trybuild = { version = "1.0" }
diff --git a/bevy_asset_loader/assets/dynamic_asset.assets.ron b/bevy_asset_loader/assets/dynamic_asset.assets.ron
index 3148998..459b43c 100644
--- a/bevy_asset_loader/assets/dynamic_asset.assets.ron
+++ b/bevy_asset_loader/assets/dynamic_asset.assets.ron
@@ -3,8 +3,8 @@
         path: "images/female_adventurer_sheet.png",
     ),
     "layout.player_sheet": TextureAtlasLayout (
-        tile_size_x: 96.,
-        tile_size_y: 99.,
+        tile_size_x: 96,
+        tile_size_y: 99,
         columns: 8,
         rows: 1
     ),
diff --git a/bevy_asset_loader/assets/dynamic_asset_arrays.asset_arrays.ron b/bevy_asset_loader/assets/dynamic_asset_arrays.asset_arrays.ron
index 1656784..d1b3db9 100644
--- a/bevy_asset_loader/assets/dynamic_asset_arrays.asset_arrays.ron
+++ b/bevy_asset_loader/assets/dynamic_asset_arrays.asset_arrays.ron
@@ -1,26 +1,26 @@
 ({
     "layouts": [
         TextureAtlasLayout(
-            tile_size_x: 96.,
-            tile_size_y: 99.,
+            tile_size_x: 96,
+            tile_size_y: 99,
             columns: 8,
             rows: 1,
         ),
         TextureAtlasLayout(
-            tile_size_x: 32.,
-            tile_size_y: 64.,
+            tile_size_x: 32,
+            tile_size_y: 64,
             columns: 12,
             rows: 6,
         ),
         TextureAtlasLayout(
-            tile_size_x: 64.,
-            tile_size_y: 32.,
+            tile_size_x: 64,
+            tile_size_y: 32,
             columns: 6,
             rows: 12,
         ),
         TextureAtlasLayout(
-            tile_size_x: 64.,
-            tile_size_y: 64.,
+            tile_size_x: 64,
+            tile_size_y: 64,
             columns: 6,
             rows: 6,
         ),
diff --git a/bevy_asset_loader/assets/full_dynamic_collection.assets.ron b/bevy_asset_loader/assets/full_dynamic_collection.assets.ron
index 3e6c159..52eb0a9 100644
--- a/bevy_asset_loader/assets/full_dynamic_collection.assets.ron
+++ b/bevy_asset_loader/assets/full_dynamic_collection.assets.ron
@@ -6,8 +6,8 @@
         path: "images/tree.png",
     ),
     "texture_atlas_layout": TextureAtlasLayout (
-        tile_size_x: 96.,
-        tile_size_y: 99.,
+        tile_size_x: 96,
+        tile_size_y: 99,
         columns: 8,
         rows: 1,
     ),
diff --git a/bevy_asset_loader/examples/asset_maps.rs b/bevy_asset_loader/examples/asset_maps.rs
index 7d78926..9c719ed 100644
--- a/bevy_asset_loader/examples/asset_maps.rs
+++ b/bevy_asset_loader/examples/asset_maps.rs
@@ -71,7 +71,7 @@ fn use_audio_assets(audio_assets: Res<AudioAssets>, mut quit: EventWriter<AppExi
 
     info!("Everything looks good!");
     info!("Quitting the application...");
-    quit.send(AppExit);
+    quit.send(AppExit::Success);
 }
 
 #[derive(PartialEq, Eq, Hash)]
diff --git a/bevy_asset_loader/examples/atlas_from_grid.rs b/bevy_asset_loader/examples/atlas_from_grid.rs
index 8fcd92a..d6a9bfa 100644
--- a/bevy_asset_loader/examples/atlas_from_grid.rs
+++ b/bevy_asset_loader/examples/atlas_from_grid.rs
@@ -26,7 +26,7 @@ struct MyAssets {
     // if the sheet would have padding, you could set that with `padding_x` and `padding_y`.
     // if there would be space between the top left corner of the sheet and the first sprite, you could configure that with `offset_x` and `offset_y`
     // A texture atlas layout does not have a path as no asset file will be loaded for the layout
-    #[asset(texture_atlas_layout(tile_size_x = 96., tile_size_y = 99., columns = 8, rows = 1))]
+    #[asset(texture_atlas_layout(tile_size_x = 96, tile_size_y = 99, columns = 8, rows = 1))]
     female_adventurer_layout: Handle<TextureAtlasLayout>,
     // you can configure the sampler for the sprite sheet image
     #[asset(image(sampler = nearest))]
diff --git a/bevy_asset_loader/examples/custom_dynamic_assets.rs b/bevy_asset_loader/examples/custom_dynamic_assets.rs
index d65ee59..ee92a69 100644
--- a/bevy_asset_loader/examples/custom_dynamic_assets.rs
+++ b/bevy_asset_loader/examples/custom_dynamic_assets.rs
@@ -1,3 +1,4 @@
+use bevy::ecs::system::SystemState;
 use bevy::prelude::*;
 use bevy::reflect::TypePath;
 use bevy::render::render_asset::RenderAssetUsages;
@@ -117,18 +118,14 @@ impl DynamicAsset for CustomDynamicAsset {
     // This method is called when all asset handles returned from `load` are done loading.
     // The handles that you return, should also be loaded.
     fn build(&self, world: &mut World) -> Result<DynamicAssetType, anyhow::Error> {
-        let cell = world.cell();
-        let asset_server = cell
-            .get_resource::<AssetServer>()
-            .expect("Failed to get asset server");
         match self {
             CustomDynamicAsset::CombinedImage {
                 top_layer,
                 bottom_layer,
             } => {
-                let mut images = cell
-                    .get_resource_mut::<Assets<Image>>()
-                    .expect("Failed to get image assets");
+                let mut system_state =
+                    SystemState::<(ResMut<Assets<Image>>, Res<AssetServer>)>::new(world);
+                let (mut images, asset_server) = system_state.get_mut(world);
                 let first = images
                     .get(&asset_server.load(top_layer))
                     .expect("Failed to get first layer");
@@ -161,10 +158,11 @@ impl DynamicAsset for CustomDynamicAsset {
                 base_color_texture,
                 base_color,
             } => {
-                let mut materials = cell
-                    .get_resource_mut::<Assets<StandardMaterial>>()
-                    .expect("Failed to get standard material assets");
-                let color = Color::rgba(base_color[0], base_color[1], base_color[2], base_color[3]);
+                let mut system_state =
+                    SystemState::<(ResMut<Assets<StandardMaterial>>, Res<AssetServer>)>::new(world);
+                let (mut materials, asset_server) = system_state.get_mut(world);
+                let color =
+                    Color::linear_rgba(base_color[0], base_color[1], base_color[2], base_color[3]);
                 let image = asset_server.load(base_color_texture);
                 let mut material = StandardMaterial::from(color);
                 material.base_color_texture = Some(image);
@@ -173,9 +171,9 @@ impl DynamicAsset for CustomDynamicAsset {
                 Ok(DynamicAssetType::Single(materials.add(material).untyped()))
             }
             CustomDynamicAsset::Cube { size } => {
-                let mut meshes = cell
+                let mut meshes = world
                     .get_resource_mut::<Assets<Mesh>>()
-                    .expect("Failed to get mesh assets");
+                    .expect("Cannot get Assets<Mesh>");
                 let handle = meshes
                     .add(Mesh::from(Cuboid {
                         half_size: Vec3::splat(size / 2.),
diff --git a/bevy_asset_loader/examples/dynamic_asset.rs b/bevy_asset_loader/examples/dynamic_asset.rs
index 5652bef..684a24f 100644
--- a/bevy_asset_loader/examples/dynamic_asset.rs
+++ b/bevy_asset_loader/examples/dynamic_asset.rs
@@ -50,18 +50,20 @@ fn spawn_player_and_tree(mut commands: Commands, image_assets: Res<ImageAssets>)
     let mut transform = Transform::from_translation(Vec3::new(0., 0., 1.));
     transform.scale = Vec3::splat(0.5);
     commands
-        .spawn(SpriteSheetBundle {
-            transform: Transform {
-                translation: Vec3::new(0., 150., 0.),
+        .spawn((
+            SpriteBundle {
+                transform: Transform {
+                    translation: Vec3::new(0., 150., 0.),
+                    ..Default::default()
+                },
+                texture: image_assets.player.clone(),
                 ..Default::default()
             },
-            texture: image_assets.player.clone(),
-            atlas: TextureAtlas {
+            TextureAtlas {
                 layout: image_assets.player_layout.clone(),
                 index: 0,
             },
-            ..Default::default()
-        })
+        ))
         .insert(AnimationTimer(Timer::from_seconds(
             0.1,
             TimerMode::Repeating,
diff --git a/bevy_asset_loader/examples/dynamic_asset_arrays.rs b/bevy_asset_loader/examples/dynamic_asset_arrays.rs
index 623577b..5922c04 100644
--- a/bevy_asset_loader/examples/dynamic_asset_arrays.rs
+++ b/bevy_asset_loader/examples/dynamic_asset_arrays.rs
@@ -38,18 +38,20 @@ fn spawn_player_and_tree(mut commands: Commands, image_assets: Res<ImageAssets>)
     let mut transform = Transform::from_translation(Vec3::new(0., 0., 1.));
     transform.scale = Vec3::splat(0.5);
     commands
-        .spawn(SpriteSheetBundle {
-            transform: Transform {
-                translation: Vec3::new(0., 150., 0.),
+        .spawn((
+            SpriteBundle {
+                transform: Transform {
+                    translation: Vec3::new(0., 150., 0.),
+                    ..Default::default()
+                },
+                texture: image_assets.mixed_handlers[1].clone().typed(),
                 ..Default::default()
             },
-            texture: image_assets.mixed_handlers[1].clone().typed(),
-            atlas: TextureAtlas {
+            TextureAtlas {
                 layout: image_assets.atlas_layout[0].clone(),
                 index: 0,
             },
-            ..Default::default()
-        })
+        ))
         .insert(AnimationTimer(Timer::from_seconds(
             0.1,
             TimerMode::Repeating,
diff --git a/bevy_asset_loader/examples/failure_state.rs b/bevy_asset_loader/examples/failure_state.rs
index a94f4c8..e7ad9f0 100644
--- a/bevy_asset_loader/examples/failure_state.rs
+++ b/bevy_asset_loader/examples/failure_state.rs
@@ -35,7 +35,7 @@ fn fail() {
 fn ok(mut quit: EventWriter<AppExit>) {
     info!("As expected, bevy_asset_loader switched to the failure state");
     info!("Quitting the application...");
-    quit.send(AppExit);
+    quit.send(AppExit::Success);
 }
 
 fn timeout(time: Res<Time>) {
diff --git a/bevy_asset_loader/examples/full_collection.rs b/bevy_asset_loader/examples/full_collection.rs
index 5048609..c1f877c 100644
--- a/bevy_asset_loader/examples/full_collection.rs
+++ b/bevy_asset_loader/examples/full_collection.rs
@@ -27,7 +27,7 @@ struct MyAssets {
     #[asset(path = "images/player.png", standard_material)]
     standard_material: Handle<StandardMaterial>,
     // Create a texture atlas layout
-    #[asset(texture_atlas_layout(tile_size_x = 96., tile_size_y = 99., columns = 8, rows = 1))]
+    #[asset(texture_atlas_layout(tile_size_x = 96, tile_size_y = 99, columns = 8, rows = 1))]
     texture_atlas_layout: Handle<TextureAtlasLayout>,
     // Example field with type that implements `FromWorld`
     // If no derive attributes are set, `from_world` will be used to set the value.
@@ -80,7 +80,7 @@ fn expectations(
     info!("Done loading the collection. Checking expectations...");
 
     assert_eq!(
-        asset_server.get_recursive_dependency_load_state(assets.single_file.clone()),
+        asset_server.get_recursive_dependency_load_state(&assets.single_file.clone()),
         Some(RecursiveDependencyLoadState::Loaded)
     );
     let material = standard_materials
@@ -88,7 +88,7 @@ fn expectations(
         .expect("Standard material should be added to its assets resource.");
     assert_eq!(
         asset_server.get_recursive_dependency_load_state(
-            material
+            &material
                 .base_color_texture
                 .clone()
                 .expect("Material should have image as base color texture")
@@ -102,7 +102,7 @@ fn expectations(
     let material = standard_materials
         .get(&assets.from_world.handle)
         .expect("Standard material should be added to its assets resource.");
-    assert_eq!(material.base_color, Color::RED);
+    assert_eq!(material.base_color, Color::LinearRgba(LinearRgba::RED));
 
     let image = images
         .get(&assets.image_tree_nearest)
@@ -178,7 +178,7 @@ fn expectations(
 
     info!("Everything looks good!");
     info!("Quitting the application...");
-    quit.send(AppExit);
+    quit.send(AppExit::Success);
 }
 
 struct ColorStandardMaterial<const R: u8, const G: u8, const B: u8, const A: u8> {
@@ -193,7 +193,12 @@ impl<const R: u8, const G: u8, const B: u8, const A: u8> FromWorld
             .get_resource_mut::<Assets<StandardMaterial>>()
             .unwrap();
         ColorStandardMaterial {
-            handle: materials.add(StandardMaterial::from(Color::rgba_u8(R, G, B, A))),
+            handle: materials.add(StandardMaterial::from(Color::linear_rgba(
+                R as f32 / u8::MAX as f32,
+                G as f32 / u8::MAX as f32,
+                B as f32 / u8::MAX as f32,
+                A as f32 / u8::MAX as f32,
+            ))),
         }
     }
 }
diff --git a/bevy_asset_loader/examples/full_dynamic_collection.rs b/bevy_asset_loader/examples/full_dynamic_collection.rs
index b0d421a..3974904 100644
--- a/bevy_asset_loader/examples/full_dynamic_collection.rs
+++ b/bevy_asset_loader/examples/full_dynamic_collection.rs
@@ -115,7 +115,7 @@ fn expectations(
     info!("Done loading the collection. Checking expectations...");
 
     assert_eq!(
-        asset_server.get_recursive_dependency_load_state(assets.single_file.clone()),
+        asset_server.get_recursive_dependency_load_state(&assets.single_file),
         Some(RecursiveDependencyLoadState::Loaded)
     );
     let material = standard_materials
@@ -125,7 +125,7 @@ fn expectations(
         asset_server.get_recursive_dependency_load_state(
             material
                 .base_color_texture
-                .clone()
+                .as_ref()
                 .expect("Material should have image as base color texture")
         ),
         Some(RecursiveDependencyLoadState::Loaded)
@@ -194,14 +194,14 @@ fn expectations(
     assert_eq!(assets.files_typed.len(), 2);
     for handle in assets.files_typed.iter() {
         assert_eq!(
-            asset_server.get_recursive_dependency_load_state(handle.clone()),
+            asset_server.get_recursive_dependency_load_state(handle),
             Some(RecursiveDependencyLoadState::Loaded)
         );
     }
     assert_eq!(assets.files_typed_mapped.len(), 2);
     for (name, handle) in assets.files_typed_mapped.iter() {
         assert_eq!(
-            asset_server.get_recursive_dependency_load_state(handle.clone()),
+            asset_server.get_recursive_dependency_load_state(handle),
             Some(RecursiveDependencyLoadState::Loaded)
         );
         assert_eq!(&handle.path().unwrap().to_string(), name);
@@ -279,7 +279,7 @@ fn expectations(
     assert_eq!(optional_files_typed.len(), 2);
     for handle in optional_files_typed.iter() {
         assert_eq!(
-            asset_server.get_recursive_dependency_load_state(handle.clone()),
+            asset_server.get_recursive_dependency_load_state(handle),
             Some(RecursiveDependencyLoadState::Loaded)
         );
     }
@@ -289,7 +289,7 @@ fn expectations(
     assert_eq!(optional_files_typed_mapped.len(), 2);
     for (name, handle) in optional_files_typed_mapped.iter() {
         assert_eq!(
-            asset_server.get_recursive_dependency_load_state(handle.clone()),
+            asset_server.get_recursive_dependency_load_state(handle),
             Some(RecursiveDependencyLoadState::Loaded)
         );
         assert_eq!(&handle.path().unwrap().to_string(), name);
@@ -297,7 +297,7 @@ fn expectations(
 
     info!("Everything looks good!");
     info!("Quitting the application...");
-    quit.send(AppExit);
+    quit.send(AppExit::Success);
 }
 
 #[derive(Clone, Eq, PartialEq, Debug, Hash, Default, States)]
diff --git a/bevy_asset_loader/examples/init_resource.rs b/bevy_asset_loader/examples/init_resource.rs
index 0dccaf3..1fa04b0 100644
--- a/bevy_asset_loader/examples/init_resource.rs
+++ b/bevy_asset_loader/examples/init_resource.rs
@@ -1,3 +1,4 @@
+use bevy::ecs::system::SystemState;
 use bevy::prelude::*;
 use bevy_asset_loader::prelude::*;
 
@@ -36,13 +37,8 @@ struct CombinedImage {
 
 impl FromWorld for CombinedImage {
     fn from_world(world: &mut World) -> Self {
-        let cell = world.cell();
-        let mut images = cell
-            .get_resource_mut::<Assets<Image>>()
-            .expect("Failed to get Assets<Image>");
-        let image_assets = cell
-            .get_resource::<ImageAssets>()
-            .expect("Failed to get ImageAssets");
+        let mut system_state = SystemState::<(ResMut<Assets<Image>>, Res<ImageAssets>)>::new(world);
+        let (mut images, image_assets) = system_state.get_mut(world);
         let player_image = images.get(&image_assets.player).unwrap();
         let tree_image = images.get(&image_assets.tree).unwrap();
         let mut combined = player_image.clone();
diff --git a/bevy_asset_loader/examples/manual_dynamic_asset.rs b/bevy_asset_loader/examples/manual_dynamic_asset.rs
index e681f7e..e1a46f7 100644
--- a/bevy_asset_loader/examples/manual_dynamic_asset.rs
+++ b/bevy_asset_loader/examples/manual_dynamic_asset.rs
@@ -199,7 +199,7 @@ fn menu(mut commands: Commands, font_assets: Res<FontAssets>) {
                 flex_direction: FlexDirection::ColumnReverse,
                 ..Default::default()
             },
-            background_color: BackgroundColor(Color::rgba(0.0,0.0,0.0,1.0)),
+            background_color: BackgroundColor(Color::linear_rgba(0.0,0.0,0.0,1.0)),
             ..Default::default()
         })
         .insert(MenuUi)
@@ -216,7 +216,7 @@ fn menu(mut commands: Commands, font_assets: Res<FontAssets>) {
                         style: TextStyle {
                             font: font_assets.fira_sans.clone(),
                             font_size: 30.0,
-                            color: Color::rgb(1., 1., 1.),
+                            color: Color::linear_rgb(1., 1., 1.),
                         },
                     }],
                     justify: JustifyText::Center,
@@ -231,7 +231,7 @@ fn menu(mut commands: Commands, font_assets: Res<FontAssets>) {
                         style: TextStyle {
                             font: font_assets.fira_sans.clone(),
                             font_size: 30.0,
-                            color: Color::rgb(1., 1., 1.),
+                            color: Color::linear_rgb(1., 1., 1.),
                         },
                     }],
                     justify: JustifyText::Center,
diff --git a/bevy_asset_loader/examples/no_loading_state.rs b/bevy_asset_loader/examples/no_loading_state.rs
index 2987eb8..d5d4b59 100644
--- a/bevy_asset_loader/examples/no_loading_state.rs
+++ b/bevy_asset_loader/examples/no_loading_state.rs
@@ -55,7 +55,7 @@ fn play_audio(audio_assets: Option<Res<AudioAssets>>, mut commands: Commands) {
 struct ImageAssets {
     #[asset(path = "images/female_adventurer_sheet.png")]
     female_adventurer: Handle<Image>,
-    #[asset(texture_atlas_layout(tile_size_x = 96., tile_size_y = 99., columns = 8, rows = 1))]
+    #[asset(texture_atlas_layout(tile_size_x = 96, tile_size_y = 99, columns = 8, rows = 1))]
     female_adventurer_layout: Handle<TextureAtlasLayout>,
     #[asset(path = "images/tree.png")]
     tree: Handle<Image>,
@@ -70,12 +70,14 @@ struct AudioAssets {
 fn draw(mut commands: Commands, image_assets: Res<ImageAssets>) {
     commands.spawn(Camera2dBundle::default());
     commands
-        .spawn(SpriteSheetBundle {
-            texture: image_assets.female_adventurer.clone(),
-            atlas: TextureAtlas::from(image_assets.female_adventurer_layout.clone()),
-            transform: Transform::from_translation(Vec3::new(-150., 0., 1.)),
-            ..Default::default()
-        })
+        .spawn((
+            SpriteBundle {
+                texture: image_assets.female_adventurer.clone(),
+                transform: Transform::from_translation(Vec3::new(-150., 0., 1.)),
+                ..Default::default()
+            },
+            TextureAtlas::from(image_assets.female_adventurer_layout.clone()),
+        ))
         .insert(AnimationTimer(Timer::from_seconds(
             0.1,
             TimerMode::Repeating,
diff --git a/bevy_asset_loader/examples/progress_tracking.rs b/bevy_asset_loader/examples/progress_tracking.rs
index f3e0840..872ce06 100644
--- a/bevy_asset_loader/examples/progress_tracking.rs
+++ b/bevy_asset_loader/examples/progress_tracking.rs
@@ -58,7 +58,7 @@ struct TextureAssets {
     tree: Handle<Image>,
     #[asset(path = "images/female_adventurer_sheet.png")]
     female_adventurer: Handle<Image>,
-    #[asset(texture_atlas_layout(tile_size_x = 96., tile_size_y = 99., columns = 8, rows = 1))]
+    #[asset(texture_atlas_layout(tile_size_x = 96, tile_size_y = 99, columns = 8, rows = 1))]
     female_adventurer_layout: Handle<TextureAtlasLayout>,
 }
 
@@ -79,31 +79,31 @@ fn expect(
     mut quit: EventWriter<AppExit>,
 ) {
     assert_eq!(
-        asset_server.get_recursive_dependency_load_state(audio_assets.background.clone()),
+        asset_server.get_recursive_dependency_load_state(&audio_assets.background.clone()),
         Some(RecursiveDependencyLoadState::Loaded)
     );
     assert_eq!(
-        asset_server.get_recursive_dependency_load_state(audio_assets.plop.clone()),
+        asset_server.get_recursive_dependency_load_state(&audio_assets.plop.clone()),
         Some(RecursiveDependencyLoadState::Loaded)
     );
     texture_atlas_layouts
         .get(&texture_assets.female_adventurer_layout)
         .expect("Texture atlas should be added to its assets resource.");
     assert_eq!(
-        asset_server.get_recursive_dependency_load_state(texture_assets.female_adventurer.clone()),
+        asset_server.get_recursive_dependency_load_state(&texture_assets.female_adventurer.clone()),
         Some(RecursiveDependencyLoadState::Loaded)
     );
     assert_eq!(
-        asset_server.get_recursive_dependency_load_state(texture_assets.player.clone()),
+        asset_server.get_recursive_dependency_load_state(&texture_assets.player.clone()),
         Some(RecursiveDependencyLoadState::Loaded)
     );
     assert_eq!(
-        asset_server.get_recursive_dependency_load_state(texture_assets.tree.clone()),
+        asset_server.get_recursive_dependency_load_state(&texture_assets.tree.clone()),
         Some(RecursiveDependencyLoadState::Loaded)
     );
     info!("Everything looks good!");
     info!("Quitting the application...");
-    quit.send(AppExit);
+    quit.send(AppExit::Success);
 }
 
 fn print_progress(
diff --git a/bevy_asset_loader/src/asset_collection.rs b/bevy_asset_loader/src/asset_collection.rs
index c6463e3..4d60a52 100644
--- a/bevy_asset_loader/src/asset_collection.rs
+++ b/bevy_asset_loader/src/asset_collection.rs
@@ -42,14 +42,14 @@ impl AssetCollectionApp for App {
     where
         Collection: AssetCollection,
     {
-        if !self.world.contains_resource::<Collection>() {
+        if !self.world().contains_resource::<Collection>() {
             // This resource is required for loading a collection
             // Since bevy_asset_loader does not have a "real" Plugin,
             // we need to make sure the resource exists here
             self.init_resource::<DynamicAssets>();
             // make sure the assets start to load
-            let _ = Collection::load(&mut self.world);
-            let resource = Collection::create(&mut self.world);
+            let _ = Collection::load(&mut self.world_mut());
+            let resource = Collection::create(&mut self.world_mut());
             self.insert_resource(resource);
         }
         self
diff --git a/bevy_asset_loader/src/dynamic_asset.rs b/bevy_asset_loader/src/dynamic_asset.rs
index bd59e54..dbdc40b 100644
--- a/bevy_asset_loader/src/dynamic_asset.rs
+++ b/bevy_asset_loader/src/dynamic_asset.rs
@@ -3,9 +3,9 @@ use std::any::TypeId;
 use std::fmt::Debug;
 
 use bevy::asset::{Asset, AssetServer, UntypedHandle};
-use bevy::ecs::schedule::States;
 use bevy::ecs::system::Resource;
 use bevy::ecs::world::World;
+use bevy::state::state::FreelyMutableState;
 use std::marker::PhantomData;
 
 /// Different typed that can generate the asset field value of a dynamic asset
@@ -68,12 +68,12 @@ pub trait DynamicAssetCollection {
 
 /// Resource keeping track of dynamic asset collection files for different loading states
 #[derive(Resource, Debug)]
-pub struct DynamicAssetCollections<State: States> {
+pub struct DynamicAssetCollections<State: FreelyMutableState> {
     files: HashMap<State, HashMap<TypeId, Vec<String>>>,
     _marker: PhantomData<State>,
 }
 
-impl<State: States> DynamicAssetCollections<State> {
+impl<State: FreelyMutableState> DynamicAssetCollections<State> {
     /// Register a file containing dynamic asset definitions to be loaded and applied to the given loading state
     ///
     /// The file will be read every time the loading state is entered
@@ -129,7 +129,7 @@ impl<State: States> DynamicAssetCollections<State> {
     }
 }
 
-impl<State: States> Default for DynamicAssetCollections<State> {
+impl<State: FreelyMutableState> Default for DynamicAssetCollections<State> {
     fn default() -> Self {
         DynamicAssetCollections {
             files: HashMap::default(),
diff --git a/bevy_asset_loader/src/lib.rs b/bevy_asset_loader/src/lib.rs
index 4d29daf..8cb2e7d 100644
--- a/bevy_asset_loader/src/lib.rs
+++ b/bevy_asset_loader/src/lib.rs
@@ -24,7 +24,7 @@
 //!                 .load_collection::<ImageAssets>()
 //!         )
 //!         .add_systems(Update, use_asset_handles.run_if(in_state(GameState::Next)))
-//! #       .set_runner(|mut app| app.update())
+//! #       .set_runner(|mut app| {app.update(); AppExit::Success})
 //!         .run();
 //! }
 //!
@@ -61,7 +61,8 @@
 //! }
 //! ```
 
-#![forbid(unsafe_code)]
+// Todo: remove usage of UnsafeWorldCell
+// #![forbid(unsafe_code)]
 #![warn(unused_imports, missing_docs)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 
diff --git a/bevy_asset_loader/src/loading_state.rs b/bevy_asset_loader/src/loading_state.rs
index 2ed8fb6..bde424f 100644
--- a/bevy_asset_loader/src/loading_state.rs
+++ b/bevy_asset_loader/src/loading_state.rs
@@ -8,13 +8,13 @@ use bevy::app::{App, Plugin};
 use bevy::asset::{Asset, UntypedHandle};
 use bevy::ecs::{
     schedule::{
-        common_conditions::in_state, InternedScheduleLabel, IntoSystemConfigs,
-        IntoSystemSetConfigs, NextState, OnEnter, ScheduleLabel, State, States, SystemSet,
+        InternedScheduleLabel, IntoSystemConfigs, IntoSystemSetConfigs, ScheduleLabel, SystemSet,
     },
     system::Resource,
     world::FromWorld,
 };
-use bevy::prelude::{StateTransition, Update};
+use bevy::prelude::{in_state, NextState, OnEnter, State, StateTransition, States, Update};
+use bevy::state::state::FreelyMutableState;
 use bevy::utils::{default, HashMap, HashSet};
 use std::any::TypeId;
 use std::marker::PhantomData;
@@ -64,7 +64,7 @@ use crate::loading_state::systems::{apply_internal_state_transition, run_loading
 ///             .load_collection::<ImageAssets>()
 ///         )
 ///         .add_systems(OnEnter(GameState::Menu), play_audio)
-/// #       .set_runner(|mut app| app.update())
+/// #       .set_runner(|mut app| {app.update(); AppExit::Success})
 ///         .run();
 /// }
 ///
@@ -96,7 +96,7 @@ use crate::loading_state::systems::{apply_internal_state_transition, run_loading
 ///     pub tree: Handle<Image>,
 /// }
 /// ```
-pub struct LoadingState<State: States> {
+pub struct LoadingState<State: FreelyMutableState> {
     next_state: Option<State>,
     failure_state: Option<State>,
     loading_state: State,
@@ -109,7 +109,7 @@ pub struct LoadingState<State: States> {
 
 impl<S> LoadingState<S>
 where
-    S: States,
+    S: FreelyMutableState,
 {
     /// Create a new [`LoadingState`]
     ///
@@ -130,7 +130,7 @@ where
     ///             .load_collection::<AudioAssets>()
     ///             .load_collection::<ImageAssets>()
     ///         )
-    /// #       .set_runner(|mut app| app.update())
+    /// #       .set_runner(|mut app| {app.update(); AppExit::Success})
     /// #       .run();
     /// # }
     /// # #[derive(Clone, Eq, PartialEq, Debug, Hash, Default, States)]
@@ -182,7 +182,7 @@ where
     ///             .load_collection::<AudioAssets>()
     ///             .load_collection::<ImageAssets>()
     ///         )
-    /// #       .set_runner(|mut app| app.update())
+    /// #       .set_runner(|mut app| {app.update(); AppExit::Success})
     /// #       .run();
     /// # }
     /// # #[derive(Clone, Eq, PartialEq, Debug, Hash, Default, States)]
@@ -227,7 +227,7 @@ where
     ///             .on_failure_continue_to_state(GameState::Error)
     ///             .load_collection::<MyAssets>()
     ///         )
-    /// #       .set_runner(|mut app| app.update())
+    /// #       .set_runner(|mut app| {app.update(); AppExit::Success})
     /// #       .run();
     /// # }
     /// # #[derive(Clone, Eq, PartialEq, Debug, Hash, Default, States)]
@@ -300,7 +300,7 @@ where
     ///             .load_collection::<AudioAssets>()
     ///             .load_collection::<ImageAssets>()
     ///         )
-    /// #       .set_runner(|mut app| app.update())
+    /// #       .set_runner(|mut app| {app.update(); AppExit::Success})
     /// #       .run();
     /// # }
     /// # #[derive(Clone, Eq, PartialEq, Debug, Hash, Default, States)]
@@ -327,7 +327,7 @@ where
         app.init_resource::<AssetLoaderConfiguration<S>>();
         {
             let mut asset_loader_configuration = app
-                .world
+                .world_mut()
                 .get_resource_mut::<AssetLoaderConfiguration<S>>()
                 .unwrap();
             let mut loading_config = asset_loader_configuration
@@ -454,7 +454,7 @@ where
         }
 
         app.init_resource::<DynamicAssets>();
-        let mut dynamic_assets = app.world.get_resource_mut::<DynamicAssets>().unwrap();
+        let mut dynamic_assets = app.world_mut().get_resource_mut::<DynamicAssets>().unwrap();
         for (key, asset) in self.dynamic_assets {
             dynamic_assets.register_asset(key, asset);
         }
@@ -462,7 +462,7 @@ where
     }
 }
 
-impl<S: States> ConfigureLoadingState for LoadingState<S> {
+impl<S: FreelyMutableState> ConfigureLoadingState for LoadingState<S> {
     fn load_collection<A: AssetCollection>(mut self) -> Self {
         self.config = self.config.load_collection::<A>();
 
@@ -491,7 +491,7 @@ impl<S: States> ConfigureLoadingState for LoadingState<S> {
 
 ///  Systems in this set check the loading state of assets.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SystemSet)]
-pub struct LoadingStateSet<S: States>(pub S);
+pub struct LoadingStateSet<S: FreelyMutableState>(pub S);
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, SystemSet)]
 pub(crate) enum InternalLoadingStateSet {
@@ -503,12 +503,15 @@ pub(crate) enum InternalLoadingStateSet {
 }
 
 #[derive(ScheduleLabel, Clone, Debug, PartialEq, Eq, Hash)]
-pub(crate) struct OnEnterInternalLoadingState<S: States>(pub S, pub InternalLoadingState<S>);
+pub(crate) struct OnEnterInternalLoadingState<S: FreelyMutableState>(
+    pub S,
+    pub InternalLoadingState<S>,
+);
 #[derive(ScheduleLabel, Clone, Debug, PartialEq, Eq, Hash)]
-pub(crate) struct LoadingStateSchedule<S: States>(pub S);
+pub(crate) struct LoadingStateSchedule<S: FreelyMutableState>(pub S);
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, States)]
-pub(crate) enum InternalLoadingState<S: States> {
+pub(crate) enum InternalLoadingState<S: FreelyMutableState> {
     /// Starting point. Here it will be decided whether dynamic asset collections need to be loaded.
     #[default]
     Initialize,
@@ -540,11 +543,11 @@ impl<T> Default for LoadingAssetHandles<T> {
 }
 
 #[derive(Resource)]
-pub(crate) struct AssetLoaderConfiguration<State: States> {
+pub(crate) struct AssetLoaderConfiguration<State: FreelyMutableState> {
     state_configurations: HashMap<State, LoadingConfiguration<State>>,
 }
 
-impl<State: States> Default for AssetLoaderConfiguration<State> {
+impl<State: FreelyMutableState> Default for AssetLoaderConfiguration<State> {
     fn default() -> Self {
         AssetLoaderConfiguration {
             state_configurations: HashMap::default(),
@@ -552,7 +555,7 @@ impl<State: States> Default for AssetLoaderConfiguration<State> {
     }
 }
 
-struct LoadingConfiguration<State: States> {
+struct LoadingConfiguration<State: FreelyMutableState> {
     next: Option<State>,
     failure: Option<State>,
     loading_failed: bool,
@@ -560,7 +563,7 @@ struct LoadingConfiguration<State: States> {
     loading_dynamic_collections: HashSet<TypeId>,
 }
 
-impl<State: States> Default for LoadingConfiguration<State> {
+impl<State: FreelyMutableState> Default for LoadingConfiguration<State> {
     fn default() -> Self {
         LoadingConfiguration {
             next: None,
@@ -574,12 +577,12 @@ impl<State: States> Default for LoadingConfiguration<State> {
 
 /// Resource to store the schedules for loading states
 #[derive(Resource)]
-pub struct LoadingStateSchedules<State: States> {
+pub struct LoadingStateSchedules<State: FreelyMutableState> {
     /// Map to store a schedule per loading state
     pub schedules: HashMap<State, InternedScheduleLabel>,
 }
 
-impl<State: States> Default for LoadingStateSchedules<State> {
+impl<State: FreelyMutableState> Default for LoadingStateSchedules<State> {
     fn default() -> Self {
         LoadingStateSchedules {
             schedules: HashMap::default(),
@@ -590,10 +593,13 @@ impl<State: States> Default for LoadingStateSchedules<State> {
 /// Extension trait for Bevy Apps to add loading states idiomatically
 pub trait LoadingStateAppExt {
     /// Add a loading state to your app
-    fn add_loading_state<S: States>(&mut self, loading_state: LoadingState<S>) -> &mut Self;
+    fn add_loading_state<S: FreelyMutableState>(
+        &mut self,
+        loading_state: LoadingState<S>,
+    ) -> &mut Self;
 
     /// Configure an existing loading state with, for example, additional asset collections.
-    fn configure_loading_state<S: States>(
+    fn configure_loading_state<S: FreelyMutableState>(
         &mut self,
         configuration: LoadingStateConfig<S>,
     ) -> &mut Self;
@@ -616,7 +622,7 @@ pub trait LoadingStateAppExt {
     ///             .load_collection::<AudioAssets>()
     ///             .load_collection::<ImageAssets>()
     ///         )
-    /// #       .set_runner(|mut app| app.update())
+    /// #       .set_runner(|mut app| {app.update(); AppExit::Success})
     /// #       .run();
     /// # }
     /// # #[derive(Clone, Eq, PartialEq, Debug, Hash, Default, States)]
@@ -642,7 +648,7 @@ pub trait LoadingStateAppExt {
         since = "0.19.0",
         note = "Use `LoadingStateConfig::load_collection` or `LoadingState::load_collection` instead."
     )]
-    fn add_collection_to_loading_state<S: States, A: AssetCollection>(
+    fn add_collection_to_loading_state<S: FreelyMutableState, A: AssetCollection>(
         &mut self,
         loading_state: S,
     ) -> &mut Self;
@@ -655,7 +661,7 @@ pub trait LoadingStateAppExt {
         since = "0.19.0",
         note = "Use `LoadingStateConfig::register_dynamic_asset_collection` or `LoadingState::register_dynamic_asset_collection` instead."
     )]
-    fn register_dynamic_asset_collection<S: States, C: DynamicAssetCollection + Asset>(
+    fn register_dynamic_asset_collection<S: FreelyMutableState, C: DynamicAssetCollection + Asset>(
         &mut self,
         loading_state: S,
     ) -> &mut Self;
@@ -672,7 +678,10 @@ pub trait LoadingStateAppExt {
         since = "0.19.0",
         note = "Use `LoadingState::with_dynamic_assets_file` or `LoadingStateConfig::with_dynamic_assets_file` instead."
     )]
-    fn add_dynamic_collection_to_loading_state<S: States, C: DynamicAssetCollection + Asset>(
+    fn add_dynamic_collection_to_loading_state<
+        S: FreelyMutableState,
+        C: DynamicAssetCollection + Asset,
+    >(
         &mut self,
         loading_state: S,
         file: &str,
@@ -694,7 +703,7 @@ pub trait LoadingStateAppExt {
     ///             .load_collection::<TextureForAtlas>()
     ///             .init_resource::<TextureAtlasLayoutFromWorld>()
     ///         )
-    /// #       .set_runner(|mut app| app.update())
+    /// #       .set_runner(|mut app| {app.update(); AppExit::Success})
     /// #       .run();
     /// # }
     /// # #[derive(Clone, Eq, PartialEq, Debug, Hash, Default, States)]
@@ -726,20 +735,23 @@ pub trait LoadingStateAppExt {
         since = "0.19.0",
         note = "Use `LoadingState::init_resource` or `LoadingStateConfig::init_resource` instead."
     )]
-    fn init_resource_after_loading_state<S: States, A: Resource + FromWorld>(
+    fn init_resource_after_loading_state<S: FreelyMutableState, A: Resource + FromWorld>(
         &mut self,
         loading_state: S,
     ) -> &mut Self;
 }
 
 impl LoadingStateAppExt for App {
-    fn add_loading_state<S: States>(&mut self, loading_state: LoadingState<S>) -> &mut Self {
+    fn add_loading_state<S: FreelyMutableState>(
+        &mut self,
+        loading_state: LoadingState<S>,
+    ) -> &mut Self {
         loading_state.build(self);
 
         self
     }
 
-    fn configure_loading_state<S: States>(
+    fn configure_loading_state<S: FreelyMutableState>(
         &mut self,
         configuration: LoadingStateConfig<S>,
     ) -> &mut Self {
@@ -748,7 +760,7 @@ impl LoadingStateAppExt for App {
         self
     }
 
-    fn add_collection_to_loading_state<S: States, A: AssetCollection>(
+    fn add_collection_to_loading_state<S: FreelyMutableState, A: AssetCollection>(
         &mut self,
         loading_state: S,
     ) -> &mut Self {
@@ -762,7 +774,10 @@ impl LoadingStateAppExt for App {
         )
     }
 
-    fn register_dynamic_asset_collection<S: States, C: DynamicAssetCollection + Asset>(
+    fn register_dynamic_asset_collection<
+        S: FreelyMutableState,
+        C: DynamicAssetCollection + Asset,
+    >(
         &mut self,
         loading_state: S,
     ) -> &mut Self {
@@ -780,13 +795,16 @@ impl LoadingStateAppExt for App {
         )
     }
 
-    fn add_dynamic_collection_to_loading_state<S: States, C: DynamicAssetCollection + Asset>(
+    fn add_dynamic_collection_to_loading_state<
+        S: FreelyMutableState,
+        C: DynamicAssetCollection + Asset,
+    >(
         &mut self,
         loading_state: S,
         file: &str,
     ) -> &mut Self {
         let mut dynamic_asset_collections = self
-            .world
+            .world_mut()
             .get_resource_mut::<DynamicAssetCollections<S>>()
             .unwrap();
 
@@ -794,7 +812,7 @@ impl LoadingStateAppExt for App {
         self
     }
 
-    fn init_resource_after_loading_state<S: States, A: Resource + FromWorld>(
+    fn init_resource_after_loading_state<S: FreelyMutableState, A: Resource + FromWorld>(
         &mut self,
         loading_state: S,
     ) -> &mut Self {
@@ -811,7 +829,7 @@ struct InternalAssetLoaderPlugin<S> {
 
 impl<S> InternalAssetLoaderPlugin<S>
 where
-    S: States,
+    S: FreelyMutableState,
 {
     fn new() -> Self {
         InternalAssetLoaderPlugin {
@@ -822,7 +840,7 @@ where
 
 impl<S> Plugin for InternalAssetLoaderPlugin<S>
 where
-    S: States,
+    S: FreelyMutableState,
 {
     fn build(&self, app: &mut App) {
         app.add_systems(StateTransition, apply_internal_state_transition::<S>);
diff --git a/bevy_asset_loader/src/loading_state/config.rs b/bevy_asset_loader/src/loading_state/config.rs
index b412bc3..582bdda 100644
--- a/bevy_asset_loader/src/loading_state/config.rs
+++ b/bevy_asset_loader/src/loading_state/config.rs
@@ -13,7 +13,8 @@ use crate::loading_state::{
 use bevy::app::App;
 use bevy::asset::Asset;
 use bevy::ecs::schedule::SystemConfigs;
-use bevy::prelude::{default, FromWorld, IntoSystemConfigs, Resource, States};
+use bevy::prelude::{default, FromWorld, IntoSystemConfigs, Resource};
+use bevy::state::state::FreelyMutableState;
 use bevy::utils::HashMap;
 use std::any::TypeId;
 
@@ -67,7 +68,7 @@ pub trait ConfigureLoadingState {
 ///             .continue_to_state(GameState::Menu)
 ///         )
 ///         .configure_loading_state(LoadingStateConfig::new(GameState::Loading).load_collection::<AudioAssets>())
-/// #       .set_runner(|mut app| app.update())
+/// #       .set_runner(|mut app| {app.update(); AppExit::Success})
 ///         .run();
 /// # }
 ///
@@ -85,7 +86,7 @@ pub trait ConfigureLoadingState {
 /// #     plop: Handle<AudioSource>
 /// # }
 /// ```
-pub struct LoadingStateConfig<S: States> {
+pub struct LoadingStateConfig<S: FreelyMutableState> {
     state: S,
 
     on_enter_loading_assets: Vec<SystemConfigs>,
@@ -96,7 +97,7 @@ pub struct LoadingStateConfig<S: States> {
     dynamic_assets: HashMap<TypeId, Vec<String>>,
 }
 
-impl<S: States> LoadingStateConfig<S> {
+impl<S: FreelyMutableState> LoadingStateConfig<S> {
     /// Create a new configuration for the given loading state
     pub fn new(state: S) -> Self {
         Self {
@@ -144,7 +145,7 @@ impl<S: States> LoadingStateConfig<S> {
             );
         }
         let mut dynamic_assets = app
-            .world
+            .world_mut()
             .get_resource_mut::<DynamicAssetCollections<S>>()
             .unwrap_or_else(|| {
                 panic!("Failed to get the DynamicAssetCollections resource for the loading state. Are you trying to configure a loading state before it was added to the bevy App?")
@@ -155,7 +156,7 @@ impl<S: States> LoadingStateConfig<S> {
     }
 }
 
-impl<S: States> ConfigureLoadingState for LoadingStateConfig<S> {
+impl<S: FreelyMutableState> ConfigureLoadingState for LoadingStateConfig<S> {
     fn load_collection<A: AssetCollection>(mut self) -> Self {
         self.on_enter_loading_assets
             .push(start_loading_collection::<S, A>.into_configs());
diff --git a/bevy_asset_loader/src/loading_state/dynamic_asset_systems.rs b/bevy_asset_loader/src/loading_state/dynamic_asset_systems.rs
index 0e644c0..c2ba588 100644
--- a/bevy_asset_loader/src/loading_state/dynamic_asset_systems.rs
+++ b/bevy_asset_loader/src/loading_state/dynamic_asset_systems.rs
@@ -2,14 +2,18 @@ use crate::dynamic_asset::{DynamicAssetCollection, DynamicAssetCollections, Dyna
 use crate::loading_state::{AssetLoaderConfiguration, InternalLoadingState, LoadingAssetHandles};
 use bevy::asset::{Asset, AssetServer, Assets, LoadState};
 use bevy::ecs::change_detection::ResMut;
-use bevy::ecs::schedule::{NextState, State, States};
 use bevy::ecs::system::{Res, SystemState};
 use bevy::ecs::world::World;
 use bevy::log::{debug, warn};
+use bevy::prelude::NextState;
+use bevy::state::state::{FreelyMutableState, State};
 use std::any::{type_name, TypeId};
 
 #[allow(clippy::type_complexity)]
-pub(crate) fn load_dynamic_asset_collections<S: States, C: DynamicAssetCollection + Asset>(
+pub(crate) fn load_dynamic_asset_collections<
+    S: FreelyMutableState,
+    C: DynamicAssetCollection + Asset,
+>(
     world: &mut World,
     system_state: &mut SystemState<(
         Res<DynamicAssetCollections<S>>,
@@ -41,7 +45,10 @@ pub(crate) fn load_dynamic_asset_collections<S: States, C: DynamicAssetCollectio
 }
 
 #[allow(clippy::type_complexity)]
-pub(crate) fn check_dynamic_asset_collections<S: States, C: DynamicAssetCollection + Asset>(
+pub(crate) fn check_dynamic_asset_collections<
+    S: FreelyMutableState,
+    C: DynamicAssetCollection + Asset,
+>(
     world: &mut World,
     system_state: &mut SystemState<(
         Res<AssetServer>,
@@ -72,19 +79,20 @@ pub(crate) fn check_dynamic_asset_collections<S: States, C: DynamicAssetCollecti
         let loading_collections = loading_collections.as_mut().unwrap();
         for handle in &loading_collections.handles {
             if let Some(load_state) = asset_server.get_load_state(handle.id()) {
-                if load_state == LoadState::Failed {
-                    config.loading_failed = true;
-                    continue;
-                }
-                if load_state != LoadState::Loaded {
-                    return;
+                match load_state {
+                    LoadState::Loaded => {}
+                    LoadState::Failed(_) => {
+                        config.loading_failed = true;
+                        continue;
+                    }
+                    _ => return,
                 }
             } else {
                 return;
             }
         }
         for collection in loading_collections.handles.drain(..) {
-            if let Some(collection) = dynamic_asset_collections.get(collection.typed::<C>()) {
+            if let Some(collection) = dynamic_asset_collections.get(&collection.typed::<C>()) {
                 collection.register(&mut asset_keys);
             }
         }
@@ -95,7 +103,7 @@ pub(crate) fn check_dynamic_asset_collections<S: States, C: DynamicAssetCollecti
     world.remove_resource::<LoadingAssetHandles<(S, C)>>();
 }
 
-pub(crate) fn resume_to_loading_asset_collections<S: States>(
+pub(crate) fn resume_to_loading_asset_collections<S: FreelyMutableState>(
     state: Res<State<S>>,
     mut loading_state: ResMut<NextState<InternalLoadingState<S>>>,
     asset_loader_config: Res<AssetLoaderConfiguration<S>>,
diff --git a/bevy_asset_loader/src/loading_state/systems.rs b/bevy_asset_loader/src/loading_state/systems.rs
index a662036..c59a08b 100644
--- a/bevy_asset_loader/src/loading_state/systems.rs
+++ b/bevy_asset_loader/src/loading_state/systems.rs
@@ -1,9 +1,9 @@
 use bevy::asset::{AssetServer, LoadState};
-use bevy::ecs::schedule::{State, States};
 use bevy::ecs::system::SystemState;
-use bevy::ecs::world::{FromWorld, World, WorldCell};
+use bevy::ecs::world::{FromWorld, World};
 use bevy::log::{debug, info, trace, warn};
 use bevy::prelude::{NextState, Res, ResMut, Resource, Schedules};
+use bevy::state::state::{FreelyMutableState, State};
 use std::any::{type_name, TypeId};
 use std::marker::PhantomData;
 
@@ -22,7 +22,7 @@ pub(crate) fn init_resource<Asset: Resource + FromWorld>(world: &mut World) {
 }
 
 #[allow(clippy::type_complexity)]
-pub(crate) fn start_loading_collection<S: States, Assets: AssetCollection>(
+pub(crate) fn start_loading_collection<S: FreelyMutableState, Assets: AssetCollection>(
     world: &mut World,
     system_state: &mut SystemState<(ResMut<AssetLoaderConfiguration<S>>, Res<State<S>>)>,
 ) {
@@ -55,12 +55,29 @@ pub(crate) fn start_loading_collection<S: States, Assets: AssetCollection>(
     world.insert_resource(handles);
 }
 
-pub(crate) fn check_loading_collection<S: States, Assets: AssetCollection>(world: &mut World) {
+pub(crate) fn check_loading_collection<S: FreelyMutableState, Assets: AssetCollection>(
+    world: &mut World,
+    system_state: &mut SystemState<(
+        Option<Res<LoadingAssetHandles<Assets>>>,
+        Res<State<S>>,
+        Res<AssetServer>,
+        ResMut<AssetLoaderConfiguration<S>>,
+    )>,
+) {
     debug!(
         "Check loading of collection for type id {:?}",
         TypeId::of::<Assets>()
     );
-    if let Some((done, total)) = count_loaded_handles::<S, Assets>(world.cell()) {
+    let (loading_asset_handles, state, asset_server, mut asset_loader_configuration) =
+        system_state.get_mut(world);
+
+    if let Some(loading_asset_handles) = loading_asset_handles {
+        let (done, total) = count_loaded_handles::<S, Assets>(
+            &loading_asset_handles,
+            &state,
+            &asset_server,
+            &mut asset_loader_configuration,
+        );
         if total == done {
             let asset_collection = Assets::create(world);
             world.insert_resource(asset_collection);
@@ -79,17 +96,20 @@ pub(crate) fn check_loading_collection<S: States, Assets: AssetCollection>(world
     }
 }
 
-fn count_loaded_handles<S: States, Assets: AssetCollection>(cell: WorldCell) -> Option<(u32, u32)> {
-    let loading_asset_handles = cell.get_resource::<LoadingAssetHandles<Assets>>()?;
+fn count_loaded_handles<S: FreelyMutableState, Assets: AssetCollection>(
+    loading_asset_handles: &LoadingAssetHandles<Assets>,
+    state: &State<S>,
+    asset_server: &AssetServer,
+    asset_loader_configuration: &mut AssetLoaderConfiguration<S>,
+) -> (u32, u32) {
     let total = loading_asset_handles.handles.len();
 
-    let asset_server = cell
-        .get_resource::<AssetServer>()
-        .expect("Cannot get AssetServer resource");
-    let failure = loading_asset_handles
-        .handles
-        .iter()
-        .any(|handle| asset_server.get_load_state(handle.id()) == Some(LoadState::Failed));
+    let failure = loading_asset_handles.handles.iter().any(|handle| {
+        matches!(
+            asset_server.get_load_state(handle.id()),
+            Some(LoadState::Failed(_))
+        )
+    });
     let done = loading_asset_handles
         .handles
         .iter()
@@ -97,15 +117,9 @@ fn count_loaded_handles<S: States, Assets: AssetCollection>(cell: WorldCell) ->
         .filter(|state| state == &Some(LoadState::Loaded))
         .count();
     if done < total && !failure {
-        return Some((done as u32, total as u32));
+        return (done as u32, total as u32);
     }
 
-    let state = cell
-        .get_resource::<State<S>>()
-        .expect("Cannot get State resource");
-    let mut asset_loader_configuration = cell
-        .get_resource_mut::<AssetLoaderConfiguration<S>>()
-        .expect("Cannot get AssetLoaderConfiguration resource");
     if let Some(config) = asset_loader_configuration
         .state_configurations
         .get_mut(state.get())
@@ -119,10 +133,10 @@ fn count_loaded_handles<S: States, Assets: AssetCollection>(cell: WorldCell) ->
         warn!("Failed to read loading state configuration in count_loaded_handles");
     }
 
-    Some((done as u32, total as u32))
+    (done as u32, total as u32)
 }
 
-pub(crate) fn resume_to_finalize<S: States>(
+pub(crate) fn resume_to_finalize<S: FreelyMutableState>(
     loader_configuration: Res<AssetLoaderConfiguration<S>>,
     mut internal_state: ResMut<NextState<InternalLoadingState<S>>>,
     user_state: Res<State<S>>,
@@ -144,7 +158,7 @@ pub(crate) fn resume_to_finalize<S: States>(
     }
 }
 
-pub(crate) fn initialize_loading_state<S: States>(
+pub(crate) fn initialize_loading_state<S: FreelyMutableState>(
     mut loading_state: ResMut<NextState<InternalLoadingState<S>>>,
     #[cfg(feature = "progress_tracking")] mut progress_counter: ResMut<ProgressCounter>,
 ) {
@@ -153,7 +167,7 @@ pub(crate) fn initialize_loading_state<S: States>(
     loading_state.set(InternalLoadingState::LoadingDynamicAssetCollections);
 }
 
-pub(crate) fn finish_loading_state<S: States>(
+pub(crate) fn finish_loading_state<S: FreelyMutableState>(
     state: Res<State<S>>,
     mut next_state: ResMut<NextState<S>>,
     #[cfg(feature = "progress_tracking")] mut progress_counter: ResMut<ProgressCounter>,
@@ -180,42 +194,38 @@ pub(crate) fn finish_loading_state<S: States>(
     loading_state.set(InternalLoadingState::Done(PhantomData));
 }
 
-pub(crate) fn reset_loading_state<S: States>(world: &mut World) {
+pub(crate) fn reset_loading_state<S: FreelyMutableState>(world: &mut World) {
     world.remove_resource::<State<InternalLoadingState<S>>>();
     world.init_resource::<State<InternalLoadingState<S>>>();
 }
 
-pub(crate) fn run_loading_state<S: States>(world: &mut World) {
+pub(crate) fn run_loading_state<S: FreelyMutableState>(world: &mut World) {
     let state = world.resource::<State<S>>().get().clone();
     world.run_schedule(LoadingStateSchedule(state));
 }
 
-pub fn apply_internal_state_transition<S: States>(world: &mut World) {
+pub fn apply_internal_state_transition<S: FreelyMutableState>(world: &mut World) {
     let state = world.resource::<State<S>>().get().clone();
-    if world
-        .resource::<NextState<InternalLoadingState<S>>>()
-        .0
-        .is_some()
-    {
-        let entered_state = world
-            .resource_mut::<NextState<InternalLoadingState<S>>>()
-            .0
-            .take()
-            .unwrap();
-
-        let exited_state = world.remove_resource::<State<InternalLoadingState<S>>>();
-        world.insert_resource(State::new(entered_state.clone()));
-        trace!(
+    let next_state = world.remove_resource::<NextState<InternalLoadingState<S>>>();
+    match next_state {
+        Some(NextState::Pending(entered_state)) => {
+            let exited_state = world.remove_resource::<State<InternalLoadingState<S>>>();
+            world.insert_resource(State::new(entered_state.clone()));
+            trace!(
             "Switching internal state of loading state from {exited_state:?} to {entered_state:?}"
         );
-        if world
-            .resource::<Schedules>()
-            .contains(OnEnterInternalLoadingState(
-                state.clone(),
-                entered_state.clone(),
-            ))
-        {
-            world.run_schedule(OnEnterInternalLoadingState(state, entered_state));
+            if world
+                .resource::<Schedules>()
+                .contains(OnEnterInternalLoadingState(
+                    state.clone(),
+                    entered_state.clone(),
+                ))
+            {
+                world.run_schedule(OnEnterInternalLoadingState(state, entered_state));
+            }
+            world.insert_resource(NextState::<InternalLoadingState<S>>::Unchanged)
         }
+        Some(next_state) => world.insert_resource(next_state),
+        _ => {}
     }
 }
diff --git a/bevy_asset_loader/src/standard_dynamic_asset.rs b/bevy_asset_loader/src/standard_dynamic_asset.rs
index 6999149..1292bf4 100644
--- a/bevy_asset_loader/src/standard_dynamic_asset.rs
+++ b/bevy_asset_loader/src/standard_dynamic_asset.rs
@@ -1,14 +1,13 @@
 use crate::dynamic_asset::{DynamicAsset, DynamicAssetType};
 use crate::dynamic_asset::{DynamicAssetCollection, DynamicAssets};
 use bevy::asset::{Asset, AssetServer, Assets, LoadedFolder, UntypedHandle};
-use bevy::ecs::system::Command;
-use bevy::ecs::world::World;
+use bevy::ecs::world::{Command, World};
 use bevy::reflect::TypePath;
 use bevy::utils::HashMap;
 use serde::{Deserialize, Serialize};
 
 #[cfg(feature = "2d")]
-use bevy::math::Vec2;
+use bevy::math::UVec2;
 #[cfg(feature = "3d")]
 use bevy::pbr::StandardMaterial;
 #[cfg(feature = "2d")]
@@ -60,25 +59,25 @@ pub enum StandardDynamicAsset {
     #[cfg(feature = "2d")]
     TextureAtlasLayout {
         /// The image width in pixels
-        tile_size_x: f32,
+        tile_size_x: u32,
         /// The image height in pixels
-        tile_size_y: f32,
+        tile_size_y: u32,
         /// Columns on the sprite sheet
-        columns: usize,
+        columns: u32,
         /// Rows on the sprite sheet
-        rows: usize,
+        rows: u32,
         /// Padding between columns in pixels
         #[serde(with = "optional", skip_serializing_if = "Option::is_none", default)]
-        padding_x: Option<f32>,
+        padding_x: Option<u32>,
         /// Padding between rows in pixels
         #[serde(with = "optional", skip_serializing_if = "Option::is_none", default)]
-        padding_y: Option<f32>,
+        padding_y: Option<u32>,
         /// Number of pixels offset of the first tile
         #[serde(with = "optional", skip_serializing_if = "Option::is_none", default)]
-        offset_x: Option<f32>,
+        offset_x: Option<u32>,
         /// Number of pixels offset of the first tile
         #[serde(with = "optional", skip_serializing_if = "Option::is_none", default)]
-        offset_y: Option<f32>,
+        offset_y: Option<u32>,
     },
 }
 
@@ -162,10 +161,11 @@ impl DynamicAsset for StandardDynamicAsset {
     }
 
     fn build(&self, world: &mut World) -> Result<DynamicAssetType, anyhow::Error> {
-        let cell = world.cell();
-        let asset_server = cell
-            .get_resource::<AssetServer>()
-            .expect("Cannot get AssetServer");
+        let cell = world.as_unsafe_world_cell();
+        let asset_server = unsafe {
+            cell.get_resource::<AssetServer>()
+                .expect("Cannot get AssetServer")
+        };
         match self {
             StandardDynamicAsset::File { path } => Ok(DynamicAssetType::Single(
                 asset_server.get_handle_untyped(path).unwrap(),
@@ -174,9 +174,10 @@ impl DynamicAsset for StandardDynamicAsset {
             StandardDynamicAsset::Image { path, sampler } => {
                 let mut handle = asset_server.load(path);
                 if let Some(sampler) = sampler {
-                    let mut images = cell
-                        .get_resource_mut::<Assets<Image>>()
-                        .expect("Cannot get resource Assets<Image>");
+                    let mut images = unsafe {
+                        cell.get_resource_mut::<Assets<Image>>()
+                            .expect("Cannot get resource Assets<Image>")
+                    };
                     Self::update_image_sampler(&mut handle, &mut images, sampler);
                 }
 
@@ -184,9 +185,10 @@ impl DynamicAsset for StandardDynamicAsset {
             }
             #[cfg(feature = "3d")]
             StandardDynamicAsset::StandardMaterial { path } => {
-                let mut materials = cell
-                    .get_resource_mut::<Assets<StandardMaterial>>()
-                    .expect("Cannot get resource Assets<StandardMaterial>");
+                let mut materials = unsafe {
+                    cell.get_resource_mut::<Assets<StandardMaterial>>()
+                        .expect("Cannot get resource Assets<StandardMaterial>")
+                };
                 let handle = materials
                     .add(StandardMaterial::from(
                         asset_server.get_handle::<Image>(path).unwrap(),
@@ -206,28 +208,30 @@ impl DynamicAsset for StandardDynamicAsset {
                 offset_x,
                 offset_y,
             } => {
-                let mut atlases = cell
-                    .get_resource_mut::<Assets<TextureAtlasLayout>>()
-                    .expect("Cannot get resource Assets<TextureAtlasLayout>");
+                let mut atlases = unsafe {
+                    cell.get_resource_mut::<Assets<TextureAtlasLayout>>()
+                        .expect("Cannot get resource Assets<TextureAtlasLayout>")
+                };
                 let texture_atlas_handle = atlases
                     .add(TextureAtlasLayout::from_grid(
-                        Vec2::new(*tile_size_x, *tile_size_y),
+                        UVec2::new(*tile_size_x, *tile_size_y),
                         *columns,
                         *rows,
-                        Some(Vec2::new(padding_x.unwrap_or(0.), padding_y.unwrap_or(0.))),
-                        Some(Vec2::new(offset_x.unwrap_or(0.), offset_y.unwrap_or(0.))),
+                        Some(UVec2::new(padding_x.unwrap_or(0), padding_y.unwrap_or(0))),
+                        Some(UVec2::new(offset_x.unwrap_or(0), offset_y.unwrap_or(0))),
                     ))
                     .untyped();
 
                 Ok(DynamicAssetType::Single(texture_atlas_handle))
             }
             StandardDynamicAsset::Folder { path } => {
-                let folders = cell
-                    .get_resource_mut::<Assets<LoadedFolder>>()
-                    .expect("Cannot get resource Assets<LoadedFolder>");
+                let folders = unsafe {
+                    cell.get_resource_mut::<Assets<LoadedFolder>>()
+                        .expect("Cannot get resource Assets<LoadedFolder>")
+                };
                 Ok(DynamicAssetType::Collection(
                     folders
-                        .get(asset_server.get_handle(path).unwrap())
+                        .get(&asset_server.get_handle(path).unwrap())
                         .unwrap()
                         .handles
                         .to_vec(),
diff --git a/bevy_asset_loader/tests/can_run_without_next_state.rs b/bevy_asset_loader/tests/can_run_without_next_state.rs
index 75c2094..056d00d 100644
--- a/bevy_asset_loader/tests/can_run_without_next_state.rs
+++ b/bevy_asset_loader/tests/can_run_without_next_state.rs
@@ -41,7 +41,7 @@ fn expect(
 ) {
     if collection.is_some() {
         if test_state.wait_frames_after_load == 0 {
-            exit.send(AppExit);
+            exit.send(AppExit::Success);
             return;
         }
         test_state.wait_frames_after_load -= 1;
diff --git a/bevy_asset_loader/tests/continues_to_failure_state.rs b/bevy_asset_loader/tests/continues_to_failure_state.rs
index da5fa13..10cb172 100644
--- a/bevy_asset_loader/tests/continues_to_failure_state.rs
+++ b/bevy_asset_loader/tests/continues_to_failure_state.rs
@@ -28,7 +28,7 @@ fn fail() {
 }
 
 fn exit(mut exit: EventWriter<AppExit>) {
-    exit.send(AppExit);
+    exit.send(AppExit::Success);
 }
 
 fn timeout(time: Res<Time>) {
diff --git a/bevy_asset_loader/tests/continues_without_collection.rs b/bevy_asset_loader/tests/continues_without_collection.rs
index e8aedf7..52be405 100644
--- a/bevy_asset_loader/tests/continues_without_collection.rs
+++ b/bevy_asset_loader/tests/continues_without_collection.rs
@@ -26,7 +26,7 @@ fn expect(mut test_state: ResMut<TestState>) {
 }
 
 fn exit(mut exit: EventWriter<AppExit>) {
-    exit.send(AppExit);
+    exit.send(AppExit::Success);
 }
 
 #[derive(Resource)]
diff --git a/bevy_asset_loader/tests/init_resource.rs b/bevy_asset_loader/tests/init_resource.rs
index 1905389..7b0e453 100644
--- a/bevy_asset_loader/tests/init_resource.rs
+++ b/bevy_asset_loader/tests/init_resource.rs
@@ -37,7 +37,7 @@ fn expect(collection: Option<Res<PostProcessed>>, mut exit: EventWriter<AppExit>
     if collection.is_none() {
         panic!("Post processed collection was not inserted");
     } else {
-        exit.send(AppExit);
+        exit.send(AppExit::Success);
     }
 }
 
diff --git a/bevy_asset_loader/tests/mapped_path_use_slash.rs b/bevy_asset_loader/tests/mapped_path_use_slash.rs
index 56eb3a3..50ff470 100644
--- a/bevy_asset_loader/tests/mapped_path_use_slash.rs
+++ b/bevy_asset_loader/tests/mapped_path_use_slash.rs
@@ -48,7 +48,7 @@ fn expect(collection: Option<Res<AudioCollection>>, mut exit: EventWriter<AppExi
             "Expected path 'audio/plop.ogg' was not in {:?}",
             files
         );
-        exit.send(AppExit);
+        exit.send(AppExit::Success);
     }
 }
 
diff --git a/bevy_asset_loader/tests/multiple_asset_collections.rs b/bevy_asset_loader/tests/multiple_asset_collections.rs
index 362a627..4485669 100644
--- a/bevy_asset_loader/tests/multiple_asset_collections.rs
+++ b/bevy_asset_loader/tests/multiple_asset_collections.rs
@@ -41,7 +41,7 @@ fn expect(
     if collection.is_none() || other_collection.is_none() {
         panic!("At least one asset collection was not inserted");
     } else {
-        exit.send(AppExit);
+        exit.send(AppExit::Success);
     }
 }
 
diff --git a/bevy_asset_loader/tests/multiple_loading_states.rs b/bevy_asset_loader/tests/multiple_loading_states.rs
index f2d455b..2c06d35 100644
--- a/bevy_asset_loader/tests/multiple_loading_states.rs
+++ b/bevy_asset_loader/tests/multiple_loading_states.rs
@@ -55,7 +55,7 @@ fn use_loading_assets(
 
 fn quit(mut exit: EventWriter<AppExit>) {
     info!("Everything fine, quitting the app");
-    exit.send(AppExit);
+    exit.send(AppExit::Success);
 }
 
 #[derive(AssetCollection, Resource)]
diff --git a/bevy_asset_loader/tests/multiple_states.rs b/bevy_asset_loader/tests/multiple_states.rs
index f2a6282..42fde3d 100644
--- a/bevy_asset_loader/tests/multiple_states.rs
+++ b/bevy_asset_loader/tests/multiple_states.rs
@@ -90,5 +90,5 @@ fn timeout(time: Res<Time>) {
 
 fn quit(mut exit: EventWriter<AppExit>) {
     info!("Everything fine, quitting the app");
-    exit.send(AppExit);
+    exit.send(AppExit::Success);
 }
diff --git a/bevy_asset_loader/tests/reload_dynamic_asset_files.rs b/bevy_asset_loader/tests/reload_dynamic_asset_files.rs
index e204863..69dba80 100644
--- a/bevy_asset_loader/tests/reload_dynamic_asset_files.rs
+++ b/bevy_asset_loader/tests/reload_dynamic_asset_files.rs
@@ -84,5 +84,5 @@ fn timeout(time: Res<Time>) {
 
 fn quit(mut exit: EventWriter<AppExit>) {
     info!("Everything fine, quitting the app");
-    exit.send(AppExit);
+    exit.send(AppExit::Success);
 }
diff --git a/bevy_asset_loader/tests/same_collection_multiple_times.rs b/bevy_asset_loader/tests/same_collection_multiple_times.rs
index cdec1e5..3346a5e 100644
--- a/bevy_asset_loader/tests/same_collection_multiple_times.rs
+++ b/bevy_asset_loader/tests/same_collection_multiple_times.rs
@@ -55,5 +55,5 @@ fn timeout(time: Res<Time>) {
 
 fn quit(mut exit: EventWriter<AppExit>) {
     info!("Everything fine, quitting the app");
-    exit.send(AppExit);
+    exit.send(AppExit::Success);
 }
diff --git a/bevy_asset_loader_derive/Cargo.toml b/bevy_asset_loader_derive/Cargo.toml
index d3feb34..132403e 100644
--- a/bevy_asset_loader_derive/Cargo.toml
+++ b/bevy_asset_loader_derive/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "bevy_asset_loader_derive"
-version = "0.20.2"
+version = "0.21.0-rc2.1"
 authors = ["Niklas Eicker <git@nikl.me>"]
 edition = "2021"
 license = "MIT OR Apache-2.0"
diff --git a/bevy_asset_loader_derive/src/assets.rs b/bevy_asset_loader_derive/src/assets.rs
index 70eb713..a0f1e13 100644
--- a/bevy_asset_loader_derive/src/assets.rs
+++ b/bevy_asset_loader_derive/src/assets.rs
@@ -5,14 +5,14 @@ use quote::quote;
 #[derive(PartialEq, Debug)]
 pub(crate) struct TextureAtlasLayoutAssetField {
     pub field_ident: Ident,
-    pub tile_size_x: f32,
-    pub tile_size_y: f32,
-    pub columns: usize,
-    pub rows: usize,
-    pub padding_x: f32,
-    pub padding_y: f32,
-    pub offset_x: f32,
-    pub offset_y: f32,
+    pub tile_size_x: u32,
+    pub tile_size_y: u32,
+    pub columns: u32,
+    pub rows: u32,
+    pub padding_x: u32,
+    pub padding_y: u32,
+    pub offset_x: u32,
+    pub offset_y: u32,
 }
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
@@ -133,9 +133,11 @@ impl AssetField {
 
                 quote!(#token_stream #field_ident : {
                     use bevy::render::texture::{ImageSampler, ImageSamplerDescriptor};
-                    let cell = world.cell();
-                    let asset_server = cell.get_resource::<AssetServer>().expect("Cannot get AssetServer");
-                    let mut images = cell.get_resource_mut::<Assets<Image>>().expect("Cannot get resource Assets<Image>");
+                    let mut system_state = ::bevy::ecs::system::SystemState::<(
+                        ResMut<::bevy::prelude::Assets<::bevy::prelude::Image>>,
+                        Res<::bevy::prelude::AssetServer>,
+                    )>::new(world);
+                    let (mut images, asset_server) = system_state.get_mut(world);
 
                     let mut handle = asset_server.load(#asset_path);
                     let mut image = images.get_mut(&handle).expect("Only asset collection fields holding an `Image` handle can be annotated with `image`");
@@ -165,11 +167,13 @@ impl AssetField {
                     Typed::Yes => match mapped {
                         Mapped::No => {
                             quote!(#token_stream #field_ident : {
-                                    let cell = world.cell();
-                                    let asset_server = cell.get_resource::<::bevy::asset::AssetServer>().expect("Cannot get AssetServer");
-                                    let folders = cell.get_resource::<::bevy::asset::Assets<::bevy::asset::LoadedFolder>>().expect("Cannot get Assets<LoadedFolder>");
+                                    let mut system_state = ::bevy::ecs::system::SystemState::<(
+                                        Res<::bevy::asset::Assets<::bevy::asset::LoadedFolder>>,
+                                        Res<::bevy::prelude::AssetServer>,
+                                    )>::new(world);
+                                    let (folders, asset_server) = system_state.get(world);
                                     let handle = asset_server.get_handle(#asset_path).unwrap_or_else(|| panic!("Folders are only supported when using a loading state. Consider using 'paths' for {}.{}.", #name, #field));
-                                    folders.get(handle)
+                                    folders.get(&handle)
                                         .unwrap()
                                         .handles
                                         .iter()
@@ -179,12 +183,14 @@ impl AssetField {
                         }
                         Mapped::Yes => {
                             quote!(#token_stream #field_ident : {
-                                    let cell = world.cell();
-                                    let asset_server = cell.get_resource::<::bevy::asset::AssetServer>().expect("Cannot get AssetServer");
+                                    let mut system_state = ::bevy::ecs::system::SystemState::<(
+                                        Res<::bevy::asset::Assets<::bevy::asset::LoadedFolder>>,
+                                        Res<::bevy::prelude::AssetServer>,
+                                    )>::new(world);
+                                    let (folders, asset_server) = system_state.get(world);
                                     let mut folder_map = ::bevy::utils::HashMap::default();
-                                    let folders = cell.get_resource::<::bevy::asset::Assets<::bevy::asset::LoadedFolder>>().expect("Cannot get Assets<LoadedFolder>");
                                     let handle = asset_server.get_handle(#asset_path).unwrap_or_else(|| panic!("Folders are only supported when using a loading state. Consider using 'paths' for {}.{}.", #name, #field));
-                                    let folder = &folders.get(handle).unwrap().handles;
+                                    let folder = &folders.get(&handle).unwrap().handles;
                                     for handle in folder {
                                         let path = handle.path().unwrap();
                                         let key = ::bevy_asset_loader::mapped::MapKey::from_asset_path(path);
@@ -197,21 +203,25 @@ impl AssetField {
                     Typed::No => match mapped {
                         Mapped::No => {
                             quote!(#token_stream #field_ident : {
-                                    let cell = world.cell();
-                                    let asset_server = cell.get_resource::<::bevy::asset::AssetServer>().expect("Cannot get AssetServer");
-                                    let folders = cell.get_resource::<::bevy::asset::Assets<::bevy::asset::LoadedFolder>>().expect("Cannot get Assets<LoadedFolder>");
+                                    let mut system_state = ::bevy::ecs::system::SystemState::<(
+                                        Res<::bevy::asset::Assets<::bevy::asset::LoadedFolder>>,
+                                        Res<::bevy::prelude::AssetServer>,
+                                    )>::new(world);
+                                    let (folders, asset_server) = system_state.get(world);
                                     let handle = asset_server.get_handle(#asset_path).unwrap_or_else(|| panic!("Folders are only supported when using a loading state. Consider using 'paths' for {}.{}.", #name, #field));
-                                    folders.get(handle).expect("test").handles.iter().cloned().collect()
+                                    folders.get(&handle).expect("test").handles.iter().cloned().collect()
                                 },)
                         }
                         Mapped::Yes => {
                             quote!(#token_stream #field_ident : {
-                                    let cell = world.cell();
-                                    let asset_server = cell.get_resource::<::bevy::asset::AssetServer>().expect("Cannot get AssetServer");
+                                    let mut system_state = ::bevy::ecs::system::SystemState::<(
+                                        Res<::bevy::asset::Assets<::bevy::asset::LoadedFolder>>,
+                                        Res<::bevy::prelude::AssetServer>,
+                                    )>::new(world);
+                                    let (folders, asset_server) = system_state.get(world);
                                     let mut folder_map = ::bevy::utils::HashMap::default();
-                                    let folders = cell.get_resource::<::bevy::asset::Assets<::bevy::asset::LoadedFolder>>().expect("Cannot get Assets<LoadedFolder>");
                                     let handle = asset_server.get_handle(#asset_path).unwrap_or_else(|| panic!("Folders are only supported when using a loading state. Consider using 'paths' for {}.{}.", #name, #field));
-                                    let folder = &folders.get(handle).unwrap().handles;
+                                    let folder = &folders.get(&handle).unwrap().handles;
                                     for handle in folder {
                                         let path = handle.path().unwrap();
                                         let key = ::bevy_asset_loader::mapped::MapKey::from_asset_path(path);
@@ -227,11 +237,11 @@ impl AssetField {
                 let field_ident = basic.field_ident.clone();
                 let asset_path = basic.asset_path.clone();
                 quote!(#token_stream #field_ident : {
-                    let cell = world.cell();
-                    let asset_server = cell.get_resource::<::bevy::asset::AssetServer>().expect("Cannot get AssetServer");
-                    let mut materials = cell
-                        .get_resource_mut::<::bevy::asset::Assets<::bevy::pbr::StandardMaterial>>()
-                        .expect("Cannot get resource Assets<StandardMaterial>");
+                    let mut system_state = ::bevy::ecs::system::SystemState::<(
+                        ResMut<::bevy::asset::Assets<::bevy::pbr::StandardMaterial>>,
+                        Res<::bevy::prelude::AssetServer>,
+                    )>::new(world);
+                    let (mut materials, asset_server) = system_state.get_mut(world);
                     materials.add(::bevy::pbr::StandardMaterial::from(asset_server.load::<::bevy::render::texture::Image>(#asset_path)))
                 },)
             }
@@ -247,16 +257,13 @@ impl AssetField {
                 let offset_y = texture_atlas.offset_y;
 
                 quote!(#token_stream #field_ident : {
-                    let cell = world.cell();
-                    let mut atlases = cell
-                        .get_resource_mut::<::bevy::asset::Assets<TextureAtlasLayout>>()
-                        .expect("Cannot get resource Assets<TextureAtlasLayout>");
+                    let mut atlases = world.get_resource_mut::<::bevy::asset::Assets<::bevy::sprite::TextureAtlasLayout>>().expect("Cannot get Assets<TextureAtlasLayout>");
                     atlases.add(TextureAtlasLayout::from_grid(
-                        Vec2::new(#tile_size_x, #tile_size_y),
+                        ::bevy::math::UVec2::new(#tile_size_x, #tile_size_y),
                         #columns,
                         #rows,
-                        Some(Vec2::new(#padding_x, #padding_y)),
-                        Some(Vec2::new(#offset_x, #offset_y)),
+                        Some(::bevy::math::UVec2::new(#padding_x, #padding_y)),
+                        Some(::bevy::math::UVec2::new(#offset_x, #offset_y)),
                     ))
                 },)
             }
@@ -437,17 +444,29 @@ impl AssetField {
         match self {
             AssetField::Basic(asset) => {
                 let asset_path = asset.asset_path.clone();
-                quote!(#token_stream handles.push(asset_server.load_untyped(#asset_path).untyped());)
+                quote!(#token_stream {
+                    let asset_server = world.get_resource::<::bevy::prelude::AssetServer>().expect("Cannot get AssetServer");
+                    handles.push(asset_server.load_untyped(#asset_path).untyped());
+                })
             }
             AssetField::Folder(asset, _, _) => {
                 let asset_path = asset.asset_path.clone();
-                quote!(#token_stream handles.push(asset_server.load_folder(#asset_path).untyped());)
+                quote!(#token_stream {
+                    let asset_server = world.get_resource::<::bevy::prelude::AssetServer>().expect("Cannot get AssetServer");
+                    handles.push(asset_server.load_folder(#asset_path).untyped());
+                })
             }
             AssetField::OptionalDynamic(dynamic)
             | AssetField::OptionalDynamicFileCollection(dynamic, _, _) => {
                 let asset_key = dynamic.key.clone();
                 quote!(
                     #token_stream {
+                        let mut system_state = ::bevy::ecs::system::SystemState::<(
+                            Res<::bevy::prelude::AssetServer>,
+                            Res<::bevy_asset_loader::prelude::DynamicAssets>,
+                        )>::new(world);
+                        let (asset_server, asset_keys) =
+                            system_state.get(world);
                         let dynamic_asset = asset_keys.get_asset(#asset_key.into());
                         if let Some(dynamic_asset) = dynamic_asset {
                             handles.extend(dynamic_asset.load(&asset_server));
@@ -459,6 +478,12 @@ impl AssetField {
                 let asset_key = dynamic.key.clone();
                 quote!(
                     #token_stream {
+                        let mut system_state = ::bevy::ecs::system::SystemState::<(
+                            Res<::bevy::prelude::AssetServer>,
+                            Res<::bevy_asset_loader::prelude::DynamicAssets>,
+                        )>::new(world);
+                        let (asset_server, asset_keys) =
+                            system_state.get(world);
                         let dynamic_asset = asset_keys.get_asset(#asset_key.into()).unwrap_or_else(|| panic!("Failed to get asset for key '{}'", #asset_key));
                         handles.extend(dynamic_asset.load(&asset_server));
                     }
@@ -470,11 +495,17 @@ impl AssetField {
             AssetField::StandardMaterial(BasicAssetField { asset_path, .. })
             | AssetField::Image(ImageAssetField { asset_path, .. }) => {
                 let asset_path = asset_path.clone();
-                quote!(#token_stream handles.push(asset_server.load::<::bevy::render::texture::Image>(#asset_path).untyped());)
+                quote!(#token_stream {
+                    let asset_server = world.get_resource::<::bevy::prelude::AssetServer>().expect("Cannot get AssetServer");
+                    handles.push(asset_server.load::<::bevy::render::texture::Image>(#asset_path).untyped());
+                })
             }
             AssetField::Files(assets, _, _) => {
                 let asset_paths = assets.asset_paths.clone();
-                quote!(#token_stream #(handles.push(asset_server.load_untyped(#asset_paths).untyped()));*;)
+                quote!(#token_stream {
+                    let asset_server = world.get_resource::<::bevy::prelude::AssetServer>().expect("Cannot get AssetServer");
+                    #(handles.push(asset_server.load_untyped(#asset_paths).untyped()));*;
+                })
             }
         }
     }
@@ -491,14 +522,14 @@ pub(crate) struct AssetBuilder {
     pub is_typed: bool,
     pub is_mapped: bool,
     pub key: Option<String>,
-    pub tile_size_x: Option<f32>,
-    pub tile_size_y: Option<f32>,
-    pub columns: Option<usize>,
-    pub rows: Option<usize>,
-    pub padding_x: Option<f32>,
-    pub padding_y: Option<f32>,
-    pub offset_x: Option<f32>,
-    pub offset_y: Option<f32>,
+    pub tile_size_x: Option<u32>,
+    pub tile_size_y: Option<u32>,
+    pub columns: Option<u32>,
+    pub rows: Option<u32>,
+    pub padding_x: Option<u32>,
+    pub padding_y: Option<u32>,
+    pub offset_x: Option<u32>,
+    pub offset_y: Option<u32>,
     pub sampler: Option<SamplerType>,
 }
 
@@ -854,12 +885,12 @@ mod test {
     fn texture_atlas_layout() {
         let builder = AssetBuilder {
             field_ident: Some(Ident::new("test", Span::call_site())),
-            tile_size_x: Some(100.),
-            tile_size_y: Some(50.),
+            tile_size_x: Some(100),
+            tile_size_y: Some(50),
             columns: Some(10),
             rows: Some(5),
-            padding_x: Some(2.),
-            offset_y: Some(3.),
+            padding_x: Some(2),
+            offset_y: Some(3),
             ..Default::default()
         };
 
@@ -870,14 +901,14 @@ mod test {
             asset,
             AssetField::TextureAtlasLayout(TextureAtlasLayoutAssetField {
                 field_ident: Ident::new("test", Span::call_site()),
-                tile_size_x: 100.0,
-                tile_size_y: 50.0,
+                tile_size_x: 100,
+                tile_size_y: 50,
                 columns: 10,
                 rows: 5,
-                padding_x: 2.0,
-                padding_y: 0.0,
-                offset_x: 0.0,
-                offset_y: 3.0,
+                padding_x: 2,
+                padding_y: 0,
+                offset_x: 0,
+                offset_y: 3,
             })
         );
     }
@@ -940,11 +971,11 @@ mod test {
 
         // Optional texture atlas field
         let mut builder = asset_builder_dynamic();
-        builder.padding_y = Some(5.0);
+        builder.padding_y = Some(5);
         assert!(builder.build().is_err());
 
         let mut builder = asset_builder_dynamic();
-        builder.offset_x = Some(2.5);
+        builder.offset_x = Some(2);
         assert!(builder.build().is_err());
 
         let mut builder = asset_builder_dynamic();
diff --git a/bevy_asset_loader_derive/src/lib.rs b/bevy_asset_loader_derive/src/lib.rs
index 95ac305..9e7f8e1 100644
--- a/bevy_asset_loader_derive/src/lib.rs
+++ b/bevy_asset_loader_derive/src/lib.rs
@@ -178,9 +178,6 @@ fn impl_asset_collection(
     });
     let load_function = quote! {
             fn load(world: &mut ::bevy::ecs::world::World) -> Vec<::bevy::prelude::UntypedHandle> {
-                let cell = world.cell();
-                let asset_server = cell.get_resource::<::bevy::prelude::AssetServer>().expect("Cannot get AssetServer");
-                let asset_keys = cell.get_resource::<bevy_asset_loader::prelude::DynamicAssets>().expect("Cannot get bevy_asset_loader::prelude::DynamicAssets");
                 let mut handles = vec![];
                 #asset_loading
                 handles
@@ -281,30 +278,30 @@ fn parse_field(field: &Field) -> Result<AssetField, Vec<ParseFieldError>> {
                                     let path = named_value.path.get_ident().unwrap().clone();
                                     if path == TextureAtlasAttribute::TILE_SIZE_X {
                                         if let Expr::Lit(ExprLit {
-                                            lit: Lit::Float(width),
+                                            lit: Lit::Int(width),
                                             ..
                                         }) = &named_value.value
                                         {
                                             builder.tile_size_x =
-                                                Some(width.base10_parse::<f32>().unwrap());
+                                                Some(width.base10_parse::<u32>().unwrap());
                                         } else {
                                             errors.push(ParseFieldError::WrongAttributeType(
                                                 named_value.into_token_stream(),
-                                                "float",
+                                                "u32",
                                             ));
                                         }
                                     } else if path == TextureAtlasAttribute::TILE_SIZE_Y {
                                         if let Expr::Lit(ExprLit {
-                                            lit: Lit::Float(height),
+                                            lit: Lit::Int(height),
                                             ..
                                         }) = &named_value.value
                                         {
                                             builder.tile_size_y =
-                                                Some(height.base10_parse::<f32>().unwrap());
+                                                Some(height.base10_parse::<u32>().unwrap());
                                         } else {
                                             errors.push(ParseFieldError::WrongAttributeType(
                                                 named_value.into_token_stream(),
-                                                "float",
+                                                "u32",
                                             ));
                                         }
                                     } else if path == TextureAtlasAttribute::COLUMNS {
@@ -314,11 +311,11 @@ fn parse_field(field: &Field) -> Result<AssetField, Vec<ParseFieldError>> {
                                         }) = &named_value.value
                                         {
                                             builder.columns =
-                                                Some(columns.base10_parse::<usize>().unwrap());
+                                                Some(columns.base10_parse::<u32>().unwrap());
                                         } else {
                                             errors.push(ParseFieldError::WrongAttributeType(
                                                 named_value.into_token_stream(),
-                                                "integer",
+                                                "u32",
                                             ));
                                         }
                                     } else if path == TextureAtlasAttribute::ROWS {
@@ -328,67 +325,67 @@ fn parse_field(field: &Field) -> Result<AssetField, Vec<ParseFieldError>> {
                                         }) = &named_value.value
                                         {
                                             builder.rows =
-                                                Some(rows.base10_parse::<usize>().unwrap());
+                                                Some(rows.base10_parse::<u32>().unwrap());
                                         } else {
                                             errors.push(ParseFieldError::WrongAttributeType(
                                                 named_value.into_token_stream(),
-                                                "integer",
+                                                "u32",
                                             ));
                                         }
                                     } else if path == TextureAtlasAttribute::PADDING_X {
                                         if let Expr::Lit(ExprLit {
-                                            lit: Lit::Float(padding_x),
+                                            lit: Lit::Int(padding_x),
                                             ..
                                         }) = &named_value.value
                                         {
                                             builder.padding_x =
-                                                Some(padding_x.base10_parse::<f32>().unwrap());
+                                                Some(padding_x.base10_parse::<u32>().unwrap());
                                         } else {
                                             errors.push(ParseFieldError::WrongAttributeType(
                                                 named_value.into_token_stream(),
-                                                "float",
+                                                "u32",
                                             ));
                                         }
                                     } else if path == TextureAtlasAttribute::PADDING_Y {
                                         if let Expr::Lit(ExprLit {
-                                            lit: Lit::Float(padding_y),
+                                            lit: Lit::Int(padding_y),
                                             ..
                                         }) = &named_value.value
                                         {
                                             builder.padding_y =
-                                                Some(padding_y.base10_parse::<f32>().unwrap());
+                                                Some(padding_y.base10_parse::<u32>().unwrap());
                                         } else {
                                             errors.push(ParseFieldError::WrongAttributeType(
                                                 named_value.into_token_stream(),
-                                                "float",
+                                                "u32",
                                             ));
                                         }
                                     } else if path == TextureAtlasAttribute::OFFSET_X {
                                         if let Expr::Lit(ExprLit {
-                                            lit: Lit::Float(offset_x),
+                                            lit: Lit::Int(offset_x),
                                             ..
                                         }) = &named_value.value
                                         {
                                             builder.offset_x =
-                                                Some(offset_x.base10_parse::<f32>().unwrap());
+                                                Some(offset_x.base10_parse::<u32>().unwrap());
                                         } else {
                                             errors.push(ParseFieldError::WrongAttributeType(
                                                 named_value.into_token_stream(),
-                                                "float",
+                                                "u32",
                                             ));
                                         }
                                     } else if path == TextureAtlasAttribute::OFFSET_Y {
                                         if let Expr::Lit(ExprLit {
-                                            lit: Lit::Float(offset_y),
+                                            lit: Lit::Int(offset_y),
                                             ..
                                         }) = &named_value.value
                                         {
                                             builder.offset_y =
-                                                Some(offset_y.base10_parse::<f32>().unwrap());
+                                                Some(offset_y.base10_parse::<u32>().unwrap());
                                         } else {
                                             errors.push(ParseFieldError::WrongAttributeType(
                                                 named_value.into_token_stream(),
-                                                "float",
+                                                "u32",
                                             ));
                                         }
                                     } else {