diff --git a/Cargo.toml b/Cargo.toml
index 88da737..fd40ff7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -32,7 +32,7 @@ name = "voxel-generation"
 required-features = ["generate_voxels"]
 
 [dependencies]
-bevy = { version = "0.13.0", default-features = false, features = [
+bevy = { version = "0.14.0", default-features = false, features = [
   "bevy_render",
   "bevy_asset",
   "bevy_pbr",
@@ -47,7 +47,7 @@ thiserror = "1.0.50"
 serde = "1.0.193"
 
 [dev-dependencies]
-bevy = "0.13.0"
+bevy = "0.14.0"
 utilities = { path = "utilities" }
 rand = "0.8.5"
 async-std = { version = "1.12.0", features = ["attributes"] }
diff --git a/README.md b/README.md
index 2e0c075..6880c86 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@
 [![Latest version](https://img.shields.io/crates/v/bevy_vox_scene.svg)](https://crates.io/crates/bevy_vox_scene)
 [![docs.rs](https://docs.rs/bevy_vox_scene/badge.svg)](https://docs.rs/bevy_vox_scene)
 [![CI](https://github.com/Utsira/bevy_vox_scene/actions/workflows/ci.yml/badge.svg)](https://github.com/Utsira/bevy_vox_scene/actions/workflows/ci.yml)
-[![dependency status](https://deps.rs/crate/bevy_vox_scene/0.13.0/status.svg)](https://deps.rs/crate/bevy_vox_scene/0.13.0)
+[![dependency status](https://deps.rs/crate/bevy_vox_scene/0.14.0/status.svg)](https://deps.rs/crate/bevy_vox_scene/0.14.0)
 [![Bevy tracking](https://img.shields.io/badge/Bevy%20tracking-released%20version-lightblue)](https://bevyengine.org/learn/book/plugin-development/#main-branch-tracking)
 [![codecov](https://codecov.io/gh/Utsira/bevy_vox_scene/graph/badge.svg?token=29AR6PVOYP)](https://codecov.io/gh/Utsira/bevy_vox_scene)
 
@@ -34,7 +34,7 @@ All Magica Voxel material types except "cloud" are supported. Bevy's screen spac
 
 ```toml
 [dependencies]
-bevy_vox_scene = "0.13.0"
+bevy_vox_scene = "0.14.0"
 ```
 
    Then in code:
@@ -78,6 +78,7 @@ cargo run --example <example name>
 | ------------ | -------------- | --- |
 | 0.12         | 0.99.6               | 0.9, 0.10, 0.11, 0.12    | 
 | 0.13         |                      | 0.13                     |
+| 0.14         |                      | 0.14                     |
 
 ## Limitations and workarounds
 
diff --git a/examples/modify-scene.rs b/examples/modify-scene.rs
index 28e574d..38ebd80 100644
--- a/examples/modify-scene.rs
+++ b/examples/modify-scene.rs
@@ -126,7 +126,7 @@ fn swim_fish(mut query: Query<(&mut Transform, &Fish)>, time: Res<Time>) {
             || (x_direction > 0.5 && transform.translation.x > tank_half_extents.x)
         {
             // change direction at tank edges
-            transform.rotate_axis(Vec3::Y, PI);
+            transform.rotate_axis(Dir3::Y, PI);
         }
         // slow down when near the edge
         let slow_down = 1.0
diff --git a/examples/ssao-model.rs b/examples/ssao-model.rs
index 294ab2d..8d367b4 100644
--- a/examples/ssao-model.rs
+++ b/examples/ssao-model.rs
@@ -16,7 +16,7 @@ fn main() {
 
     app.add_plugins((DefaultPlugins, PanOrbitCameraPlugin, VoxScenePlugin))
         .insert_resource(AmbientLight {
-            color: Color::rgb_u8(128, 126, 124),
+            color: Color::srgb_u8(128, 126, 124),
             brightness: 0.5,
         })
         .add_systems(Startup, setup)
diff --git a/examples/transmission-scene.rs b/examples/transmission-scene.rs
index ad0036d..23c81b1 100644
--- a/examples/transmission-scene.rs
+++ b/examples/transmission-scene.rs
@@ -1,28 +1,24 @@
 use bevy::{
     core_pipeline::{
-        bloom::BloomSettings,
-        core_3d::ScreenSpaceTransmissionQuality,
-        experimental::taa::{TemporalAntiAliasBundle, TemporalAntiAliasPlugin},
-        tonemapping::Tonemapping,
-    },
-    prelude::*,
+        bloom::BloomSettings, core_3d::ScreenSpaceTransmissionQuality, experimental::taa::{TemporalAntiAliasBundle, TemporalAntiAliasPlugin}, tonemapping::Tonemapping
+    }, pbr::{VolumetricFogSettings, VolumetricLight}, prelude::*
 };
 use utilities::{PanOrbitCamera, PanOrbitCameraPlugin};
 use bevy_vox_scene::{VoxScenePlugin, VoxelSceneBundle};
 
 fn main() {
     let mut app = App::new();
-
+    
     app.add_plugins((DefaultPlugins, PanOrbitCameraPlugin, VoxScenePlugin))
-        .add_systems(Startup, setup);
-
+    .add_systems(Startup, setup);
+    
     // *Note:* TAA is not _required_ for specular transmission, but
     // it _greatly enhances_ the look of the resulting blur effects.
     // Sadly, it's not available under WebGL.
     #[cfg(not(all(feature = "webgl2", target_arch = "wasm32")))]
     app.insert_resource(Msaa::Off)
-        .add_plugins(TemporalAntiAliasPlugin);
-
+    .add_plugins(TemporalAntiAliasPlugin);
+    
     app.run();
 }
 
@@ -39,7 +35,7 @@ fn setup(mut commands: Commands, assets: Res<AssetServer>) {
                 ..default()
             },
             transform: Transform::from_xyz(8.0, 1.5, 8.0).looking_at(Vec3::ZERO, Vec3::Y),
-            tonemapping: Tonemapping::SomewhatBoringDisplayTransform,
+            tonemapping: Tonemapping::BlenderFilmic,
             ..Default::default()
         },
         PanOrbitCamera::default(),
@@ -54,18 +50,22 @@ fn setup(mut commands: Commands, assets: Res<AssetServer>) {
             specular_map: assets.load("pisa_specular.ktx2"),
             intensity: 500.0,
         },
+        VolumetricFogSettings::default(),
     ));
-
-    commands.spawn(DirectionalLightBundle {
-        directional_light: DirectionalLight {
-            illuminance: 5000.0,
-            shadows_enabled: true,
-            ..Default::default()
+    
+    commands.spawn((
+        DirectionalLightBundle {
+            directional_light: DirectionalLight {
+                illuminance: 5000.0,
+                shadows_enabled: true,
+                ..Default::default()
+            },
+            transform: Transform::IDENTITY.looking_to(Vec3::new(2.5, -1., 0.85), Vec3::Y),
+            ..default()
         },
-        transform: Transform::IDENTITY.looking_to(Vec3::new(1.0, -2.5, 0.85), Vec3::Y),
-        ..default()
-    });
-
+        VolumetricLight,
+    ));
+    
     commands.spawn(VoxelSceneBundle {
         scene: assets.load("study.vox"),
         transform: Transform::from_scale(Vec3::splat(0.05)),
diff --git a/examples/voxel-collisions.rs b/examples/voxel-collisions.rs
index e0b8bff..b38139d 100644
--- a/examples/voxel-collisions.rs
+++ b/examples/voxel-collisions.rs
@@ -1,9 +1,7 @@
 use std::time::Duration;
 
 use bevy::{
-    core_pipeline::{bloom::BloomSettings, tonemapping::Tonemapping},
-    prelude::*,
-    time::common_conditions::on_timer,
+    core_pipeline::{bloom::BloomSettings, dof::{DepthOfFieldMode, DepthOfFieldSettings}, tonemapping::Tonemapping}, gizmos::gizmos, prelude::*, time::common_conditions::on_timer
 };
 use utilities::{PanOrbitCamera, PanOrbitCameraPlugin};
 use bevy_vox_scene::{
@@ -21,9 +19,12 @@ fn main() {
     App::new()
         .add_plugins((DefaultPlugins, PanOrbitCameraPlugin, VoxScenePlugin))
         .add_systems(Startup, setup)
-        .add_systems(
-            Update,
-            (spawn_snow.run_if(on_timer(snow_spawn_freq)), update_snow),
+        .add_systems(Update,
+            (
+                spawn_snow.run_if(on_timer(snow_spawn_freq)), 
+                update_snow,
+                focus_camera,
+            ),
         )
         .run();
 }
@@ -54,6 +55,12 @@ fn setup(mut commands: Commands, assets: Res<AssetServer>) {
             specular_map: assets.load("pisa_specular.ktx2"),
             intensity: 500.0,
         },
+        DepthOfFieldSettings {
+            mode: DepthOfFieldMode::Bokeh,
+            focal_distance: 8.,
+            aperture_f_stops: 0.003,
+            ..default()
+        },
     ));
     commands.insert_resource(Scenes {
         snowflake: assets.load("study.vox#snowflake"),
@@ -66,6 +73,12 @@ fn setup(mut commands: Commands, assets: Res<AssetServer>) {
             if entity.get::<VoxelModelInstance>().is_some() {
                 commands.insert(Scenery);
             }
+            if let Some(name) = entity.get::<Name>() {
+                if name.as_str() == "workstation/computer" {
+                    // Focus on the computer screen
+                    commands.insert(FocalPoint(Vec3::new(0., 0., 9.)));
+                }
+            }
         }),
         ..default()
     });
@@ -77,6 +90,9 @@ struct Snowflake(Quat);
 #[derive(Component)]
 struct Scenery;
 
+#[derive(Component)]
+struct FocalPoint(Vec3);
+
 fn spawn_snow(mut commands: Commands, scenes: Res<Scenes>) {
     let mut rng = rand::thread_rng();
     let position = Vec3::new(rng.gen_range(-30.0..30.0), 80.0, rng.gen_range(-20.0..20.0)).round()
@@ -152,3 +168,14 @@ fn update_snow(
         }
     }
 }
+
+// Focus the camera on the focal point when the camera moves
+fn focus_camera(
+    mut camera: Query<(&mut DepthOfFieldSettings, &GlobalTransform), Changed<Transform>>,
+    target: Query<(&GlobalTransform, &FocalPoint)>,
+) {
+    let Some((target_xform, focal_point)) = target.iter().next() else { return };
+    let Ok((mut dof, camera_xform)) = camera.get_single_mut() else { return };
+    let target_point = target_xform.transform_point(focal_point.0);
+    dof.focal_distance = camera_xform.translation().distance(target_point);
+}
diff --git a/examples/voxel-generation.rs b/examples/voxel-generation.rs
index 1981f26..3977ac0 100644
--- a/examples/voxel-generation.rs
+++ b/examples/voxel-generation.rs
@@ -35,7 +35,7 @@ fn setup_camera(mut commands: Commands, assets: Res<AssetServer>) {
 }
 
 fn setup(world: &mut World) {
-    let palette = VoxelPalette::from_colors(vec![Color::BLUE, Color::ALICE_BLUE, Color::BISQUE]);
+    let palette = VoxelPalette::from_colors(vec![bevy::color::palettes::css::BLUE.into(), bevy::color::palettes::css::ALICE_BLUE.into(), bevy::color::palettes::css::BISQUE.into()]);
     let data = SDF::cuboid(Vec3::splat(13.0))
         .subtract(SDF::sphere(16.0))
         .map_to_voxels(UVec3::splat(32), |d, _| match d {
diff --git a/src/lib.rs b/src/lib.rs
index aa42c13..8323aa2 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -42,7 +42,7 @@
 //! #     if all_names.is_empty() { return };
 //! #     let expected_names: HashSet<&str> = ["snowflake", "wall-tile", "brick-tile", "floor", "workstation", "workstation/keyboard" , "workstation/desk", "workstation/computer", "stairs", "glass", "tank", "tank/tetra", "tank/black-light", "tank/goldfish", "tank/wall", "tank/water", "tank/scenery"].into();
 //! #     assert_eq!(all_names, expected_names);
-//! #     exit.send(AppExit);
+//! #     exit.send(AppExit::Success);
 //! # }
 //!```
 
diff --git a/src/load/mod.rs b/src/load/mod.rs
index 59e1f39..e35289a 100644
--- a/src/load/mod.rs
+++ b/src/load/mod.rs
@@ -3,11 +3,7 @@ mod parse_scene;
 
 use anyhow::anyhow;
 use bevy::{
-    asset::{io::Reader, AssetLoader, AsyncReadExt, Handle, LoadContext},
-    log::info,
-    pbr::StandardMaterial,
-    render::color::Color,
-    utils::{hashbrown::HashMap, BoxedFuture},
+    asset::{io::Reader, AssetLoader, AsyncReadExt, Handle, LoadContext}, color::LinearRgba, log::info, pbr::StandardMaterial, utils::hashbrown::HashMap
 };
 use parse_scene::{find_model_names, find_subasset_names, parse_xform_node};
 use serde::{Deserialize, Serialize};
@@ -45,7 +41,7 @@ impl Default for VoxLoaderSettings {
     fn default() -> Self {
         Self {
             mesh_outer_faces: true,
-            emission_strength: 4000.0,
+            emission_strength: 10.0,
             uses_srgb: true,
             diffuse_roughness: 0.8,
         }
@@ -62,23 +58,21 @@ impl AssetLoader for VoxSceneLoader {
     type Asset = VoxelScene;
     type Settings = VoxLoaderSettings;
     type Error = VoxLoaderError;
-
-    fn load<'a>(
+    
+    async fn load<'a>(
         &'a self,
-        reader: &'a mut Reader,
-        _settings: &'a Self::Settings,
-        load_context: &'a mut LoadContext,
-    ) -> BoxedFuture<'a, Result<Self::Asset, VoxLoaderError>> {
-        Box::pin(async move {
-            let mut bytes = Vec::new();
-            reader
-                .read_to_end(&mut bytes)
-                .await
-                .map_err(|e| VoxLoaderError::InvalidAsset(anyhow!(e)))?;
-            self.process_vox_file(&bytes, load_context, _settings)
-        })
+        reader: &'a mut Reader<'_>,
+        _settings: &'a VoxLoaderSettings,
+        _load_context: &'a mut LoadContext<'_>,
+    ) -> Result<Self::Asset, Self::Error> {
+        let mut bytes = Vec::new();
+        reader
+        .read_to_end(&mut bytes)
+        .await
+        .map_err(|e| VoxLoaderError::InvalidAsset(anyhow!(e)))?;
+        self.process_vox_file(&bytes, _load_context, _settings)
     }
-
+    
     fn extensions(&self) -> &[&str] {
         &["vox"]
     }
@@ -96,7 +90,7 @@ impl VoxSceneLoader {
             Err(error) => return Err(VoxLoaderError::InvalidAsset(anyhow!(error))),
         };
         info!("Loading {}", load_context.asset_path());
-
+        
         // Palette
         let palette = VoxelPalette::from_data(
             &file,
@@ -105,86 +99,86 @@ impl VoxSceneLoader {
         );
         let translucent_material = palette.create_material_in_load_context(load_context);
         let opaque_material_handle =
-            load_context.labeled_asset_scope("material".to_string(), |_| {
-                let mut opaque_material = translucent_material.clone();
-                opaque_material.specular_transmission_texture = None;
-                opaque_material.specular_transmission = 0.0;
-                opaque_material
-            });
+        load_context.labeled_asset_scope("material".to_string(), |_| {
+            let mut opaque_material = translucent_material.clone();
+            opaque_material.specular_transmission_texture = None;
+            opaque_material.specular_transmission = 0.0;
+            opaque_material
+        });
         if palette.emission == MaterialProperty::VariesPerElement {
             load_context.labeled_asset_scope("material-no-emission".to_string(), |_| {
                 let mut non_emissive = translucent_material.clone();
                 non_emissive.emissive_texture = None;
-                non_emissive.emissive = Color::BLACK;
+                non_emissive.emissive = LinearRgba::BLACK;
                 non_emissive
             });
         }
         let indices_of_refraction = palette.indices_of_refraction.clone();
-
+        
         // Scene graph
-
+        
         let root = parse_xform_node(&file.scenes, &file.scenes[0], None, load_context);
         let layers: Vec<LayerInfo> = file
-            .layers
-            .iter()
-            .map(|layer| LayerInfo {
-                name: layer.name(),
-                is_hidden: layer.hidden(),
-            })
-            .collect();
+        .layers
+        .iter()
+        .map(|layer| LayerInfo {
+            name: layer.name(),
+            is_hidden: layer.hidden(),
+        })
+        .collect();
         let mut subasset_by_name: HashMap<String, VoxelNode> = HashMap::new();
         find_subasset_names(&mut subasset_by_name, &root);
-
+        
         let mut model_names: Vec<Option<String>> = vec![None; file.models.len()];
         find_model_names(&mut model_names, &root);
         let mut index_for_model_name: HashMap<String, usize> = HashMap::new();
-
+        
         let models: Vec<VoxelModel> = model_names
-            .iter()
-            .zip(file.models)
-            .enumerate()
-            .map(|(index, (maybe_name, model))| {
-                let name = maybe_name.clone().unwrap_or(format!("model-{}", index));
-                index_for_model_name.insert(name.to_string(), index);
-                let data = VoxelData::from_model(&model, settings.mesh_outer_faces);
-                let (visible_voxels, ior) = data.visible_voxels(&indices_of_refraction);
-                let mesh = load_context.labeled_asset_scope(format!("{}@mesh", name), |_| {
-                    crate::model::mesh::mesh_model(&visible_voxels, &data)
-                });
-
-                let material: Handle<StandardMaterial> = if let Some(ior) = ior {
-                    load_context.labeled_asset_scope(format!("{}@material", name), |_| {
-                        let mut material = translucent_material.clone();
-                        material.ior = ior;
-                        material.thickness = data.size().min_element() as f32;
-                        material
-                    })
-                } else {
-                    opaque_material_handle.clone()
-                };
-                VoxelModel {
-                    name,
-                    data,
-                    mesh,
-                    material,
-                    has_translucency: ior.is_some(),
-                }
-            })
-            .collect();
-
-        let model_collection =
-            load_context.labeled_asset_scope("model-collection".to_string(), |context| {
-                let transmissive_material_handle = context
-                    .add_labeled_asset("material-transmissive".to_string(), translucent_material);
-                VoxelModelCollection {
-                    palette,
-                    models,
-                    index_for_model_name,
-                    opaque_material: opaque_material_handle,
-                    transmissive_material: transmissive_material_handle,
-                }
+        .iter()
+        .zip(file.models)
+        .enumerate()
+        .map(|(index, (maybe_name, model))| {
+            let name = maybe_name.clone().unwrap_or(format!("model-{}", index));
+            index_for_model_name.insert(name.to_string(), index);
+            let data = VoxelData::from_model(&model, settings.mesh_outer_faces);
+            let (visible_voxels, ior) = data.visible_voxels(&indices_of_refraction);
+            let mesh = load_context.labeled_asset_scope(format!("{}@mesh", name), |_| {
+                crate::model::mesh::mesh_model(&visible_voxels, &data)
             });
-
+            
+            let material: Handle<StandardMaterial> = if let Some(ior) = ior {
+                load_context.labeled_asset_scope(format!("{}@material", name), |_| {
+                    let mut material = translucent_material.clone();
+                    material.ior = ior;
+                    material.thickness = data.size().min_element() as f32;
+                    material
+                })
+            } else {
+                opaque_material_handle.clone()
+            };
+            VoxelModel {
+                name,
+                data,
+                mesh,
+                material,
+                has_translucency: ior.is_some(),
+            }
+        })
+        .collect();
+        
+        let model_collection =
+        load_context.labeled_asset_scope("model-collection".to_string(), |context| {
+            let transmissive_material_handle = context
+            .add_labeled_asset("material-transmissive".to_string(), translucent_material);
+            VoxelModelCollection {
+                palette,
+                models,
+                index_for_model_name,
+                opaque_material: opaque_material_handle,
+                transmissive_material: transmissive_material_handle,
+            }
+        });
+        
         for (subscene_name, node) in subasset_by_name {
             load_context.labeled_asset_scope(subscene_name.clone(), |_| VoxelScene {
                 root: node,
diff --git a/src/model/mod.rs b/src/model/mod.rs
index a0c4791..d8c9155 100644
--- a/src/model/mod.rs
+++ b/src/model/mod.rs
@@ -101,7 +101,7 @@ impl VoxelModelCollection {
         mut materials: ResMut<Assets<StandardMaterial>>,
         mut collections: ResMut<Assets<VoxelModelCollection>>,
     ) -> Option<VoxelModel> {
-        let collection = collections.get_mut(collection_handle)?;
+        let collection = collections.get_mut(collection_handle.id())?;
         let (mesh, average_ior) = data.remesh(&collection.palette.indices_of_refraction);
         let material = if let Some(ior) = average_ior {
             let mut transmissive_material = materials
diff --git a/src/model/modify.rs b/src/model/modify.rs
index ac52f5e..6118f94 100644
--- a/src/model/modify.rs
+++ b/src/model/modify.rs
@@ -1,8 +1,8 @@
 use bevy::{
     asset::{Assets, Handle},
     ecs::{
-        system::{Command, Commands},
-        world::World,
+        system::{Commands, ResMut, SystemState},
+        world::{Command, World},
     },
     math::{IVec3, Vec3},
     pbr::StandardMaterial,
@@ -98,11 +98,13 @@ struct ModifyVoxelModel {
 
 impl Command for ModifyVoxelModel {
     fn apply(self, world: &mut World) {
-        let cell = world.cell();
-        let perform = || -> Option<()> {
-            let mut meshes = cell.get_resource_mut::<Assets<Mesh>>()?;
-            let mut materials = cell.get_resource_mut::<Assets<StandardMaterial>>()?;
-            let mut collections = cell.get_resource_mut::<Assets<VoxelModelCollection>>()?;
+        let mut perform = || -> Option<()> {
+            let mut system_state: SystemState<(
+                ResMut<Assets<Mesh>>,
+                ResMut<Assets<StandardMaterial>>,
+                ResMut<Assets<VoxelModelCollection>>,
+            )> = SystemState::new(world);
+            let (mut meshes, mut materials, mut collections) = system_state.get_mut(world);
             let collection = collections.get_mut(self.model.collection.id())?;
             let index = collection
                 .index_for_model_name
@@ -163,7 +165,7 @@ impl ModifyVoxelModel {
                 model.material = opaque_material;
             }
             (false, Some(ior)) => {
-                let Some(mut translucent_material) = materials.get(transmissive_material).cloned()
+                let Some(mut translucent_material) = materials.get(transmissive_material.id()).cloned()
                 else {
                     return;
                 };
diff --git a/src/model/palette.rs b/src/model/palette.rs
index ab8097f..3b00d21 100644
--- a/src/model/palette.rs
+++ b/src/model/palette.rs
@@ -1,6 +1,5 @@
 use bevy::{
-    asset::{Assets, Handle, LoadContext}, math::FloatExt, pbr::StandardMaterial, render::{
-        color::Color,
+    asset::{Assets, Handle, LoadContext}, color::{Color, ColorToComponents, ColorToPacked, LinearRgba}, math::FloatExt, pbr::StandardMaterial, render::{
         render_asset::RenderAssetUsages,
         render_resource::{Extent3d, TextureDimension, TextureFormat},
         texture::Image,
@@ -55,7 +54,7 @@ pub struct VoxelElement {
 impl Default for VoxelElement {
     fn default() -> Self {
         Self {
-            color: Color::PINK,
+            color: Color::LinearRgba(LinearRgba::RED),
             emission: 0.0,
             roughness: 0.5,
             metalness: 0.0,
@@ -72,18 +71,18 @@ impl VoxelPalette {
         let roughness_data: Vec<f32> = elements.iter().map(|e| e.roughness).collect();
         let metalness_data: Vec<f32> = elements.iter().map(|e| e.metalness).collect();
         let translucency_data: Vec<f32> = elements.iter().map(|e| e.translucency).collect();
-
+        
         elements.resize_with(256, VoxelElement::default);
         let indices_of_refraction: Vec<Option<f32>> = elements
-            .iter()
-            .map(|e| {
-                if e.translucency > 0.0 {
-                    Some(e.refraction_index)
-                } else {
-                    None
-                }
-            })
-            .collect();
+        .iter()
+        .map(|e| {
+            if e.translucency > 0.0 {
+                Some(e.refraction_index)
+            } else {
+                None
+            }
+        })
+        .collect();
         VoxelPalette {
             elements,
             emission: MaterialProperty::from_slice(&emission_data),
@@ -93,20 +92,20 @@ impl VoxelPalette {
             indices_of_refraction,
         }
     }
-
+    
     /// Create a new [`VoxelPalette`] from the supplied [`Color`]s
     pub fn from_colors(colors: Vec<Color>) -> Self {
         VoxelPalette::new(
             colors
-                .iter()
-                .map(|color| VoxelElement {
-                    color: *color,
-                    ..Default::default()
-                })
-                .collect(),
+            .iter()
+            .map(|color| VoxelElement {
+                color: *color,
+                ..Default::default()
+            })
+            .collect(),
         )
     }
-
+    
     /// Create a new [`VoxelPalette`] by interpolating between the [`VoxelElement`] in the gradient stops
     pub fn from_gradient(stops: &[(u8, VoxelElement)]) -> Self {
         let mut elements = vec![VoxelElement::default(); 256];
@@ -117,7 +116,7 @@ impl VoxelPalette {
             for i in *stop..*next_stop {
                 let fraction = (i - stop) as f32 / distance;
                 elements[i as usize] = VoxelElement {
-                    color: element.color.lerp(next_element.color, fraction),
+                    color: Color::LinearRgba(element.color.to_linear().lerp(next_element.color.to_linear(), fraction)),
                     emission: element.emission.lerp(next_element.emission, fraction),
                     roughness: element.roughness.lerp(next_element.roughness, fraction),
                     metalness: element.metalness.lerp(next_element.metalness, fraction),
@@ -136,41 +135,41 @@ impl VoxelPalette {
     ) -> Self {
         VoxelPalette::new(
             data.palette
-                .iter()
-                .zip(data.materials.iter())
-                .map(|(color, material)| VoxelElement {
-                    color: Color::rgba_u8(color.r, color.g, color.b, color.a),
-                    emission: material.emission().unwrap_or(0.0)
-                        * (material.radiant_flux().unwrap_or(0.0) + 1.0)
-                        * emission_strength,
-                    roughness: if material.material_type() == Some("_diffuse") {
-                        diffuse_roughness
-                    } else {
-                        material.roughness().unwrap_or(0.0)
-                    },
-                    metalness: material.metalness().unwrap_or(0.0),
-                    translucency: material.opacity().unwrap_or(0.0),
-                    refraction_index: if material.material_type() == Some("_glass") {
-                        1.0 + material.refractive_index().unwrap_or(0.0)
-                    } else {
-                        0.0
-                    },
-                })
-                .collect(),
+            .iter()
+            .zip(data.materials.iter())
+            .map(|(color, material)| VoxelElement {
+                color: Color::linear_rgba(color.r as f32 / 255., color.g as f32 / 255., color.b as f32 / 255., color.a as f32 / 255.),//srgba_u8(color.r, color.g, color.b, color.a),
+                emission: material.emission().unwrap_or(0.0)
+                * (material.radiant_flux().unwrap_or(0.0) + 1.0)
+                * emission_strength,
+                roughness: if material.material_type() == Some("_diffuse") {
+                    diffuse_roughness
+                } else {
+                    material.roughness().unwrap_or(0.0)
+                },
+                metalness: material.metalness().unwrap_or(0.0),
+                translucency: material.opacity().unwrap_or(0.0),
+                refraction_index: if material.material_type() == Some("_glass") {
+                    1.0 + material.refractive_index().unwrap_or(0.0)
+                } else {
+                    0.0
+                },
+            })
+            .collect(),
         )
     }
-
+    
     pub(crate) fn create_material_in_load_context(
         &self,
         load_context: &mut LoadContext,
     ) -> StandardMaterial {
         self._create_material(|name, image| load_context.add_labeled_asset(name.to_string(), image))
     }
-
+    
     pub(crate) fn create_material(&self, images: &mut Assets<Image>) -> StandardMaterial {
         self._create_material(|_, image| images.add(image))
     }
-
+    
     fn _create_material(
         &self,
         mut get_handle: impl FnMut(&str, Image) -> Handle<Image>,
@@ -181,15 +180,15 @@ impl VoxelPalette {
             depth_or_array_layers: 1,
         };
         let color_data: Vec<u8> = self
-            .elements
-            .iter()
-            .flat_map(|e| e.color.as_rgba_u8())
-            .collect();
+        .elements
+        .iter()
+        .flat_map(|e| e.color.to_linear().to_u8_array())
+        .collect();
         let emission_data: Vec<f32> = self.elements.iter().map(|e| e.emission).collect();
         let roughness_data: Vec<f32> = self.elements.iter().map(|e| e.roughness).collect();
         let metalness_data: Vec<f32> = self.elements.iter().map(|e| e.metalness).collect();
         let translucency_data: Vec<f32> = self.elements.iter().map(|e| e.translucency).collect();
-
+        
         let has_emission = match self.emission {
             MaterialProperty::VariesPerElement => true,
             MaterialProperty::Constant(emission) => emission > 0.0,
@@ -198,7 +197,7 @@ impl VoxelPalette {
         let has_metalness = self.metalness == MaterialProperty::VariesPerElement;
         let has_roughness_metalness = has_roughness || has_metalness;
         let has_translucency = self.transmission == MaterialProperty::VariesPerElement;
-
+        
         let base_color_texture = Some(get_handle(
             "material_color",
             Image::new(
@@ -209,19 +208,19 @@ impl VoxelPalette {
                 RenderAssetUsages::default(),
             ),
         ));
-
+        
         let emissive_texture = if has_emission {
             let emission_bytes: Vec<u8> = emission_data
+            .iter()
+            .zip(self.elements.iter().map(|e| e.color))
+            .flat_map(|(emission, color)| {
+                (color.to_linear() * *emission)
+                .to_f32_array()
                 .iter()
-                .zip(self.elements.iter().map(|e| e.color))
-                .flat_map(|(emission, color)| {
-                    (color * *emission)
-                        .as_rgba_f32()
-                        .iter()
-                        .flat_map(|c| c.to_le_bytes())
-                        .collect::<Vec<u8>>()
-                })
-                .collect();
+                .flat_map(|c| c.to_le_bytes())
+                .collect::<Vec<u8>>()
+            })
+            .collect();
             Some(get_handle(
                 "material_emission",
                 Image::new(
@@ -235,19 +234,19 @@ impl VoxelPalette {
         } else {
             None
         };
-
+        
         let metallic_roughness_texture: Option<Handle<Image>> = if has_roughness_metalness {
             let raw: Vec<u8> = roughness_data
+            .iter()
+            .zip(metalness_data.iter())
+            .flat_map(|(rough, metal)| {
+                let output: Vec<u8> = [0.0, *rough, *metal, 0.0]
                 .iter()
-                .zip(metalness_data.iter())
-                .flat_map(|(rough, metal)| {
-                    let output: Vec<u8> = [0.0, *rough, *metal, 0.0]
-                        .iter()
-                        .flat_map(|b| ((b * u16::MAX as f32) as u16).to_le_bytes())
-                        .collect();
-                    output
-                })
+                .flat_map(|b| ((b * u16::MAX as f32) as u16).to_le_bytes())
                 .collect();
+                output
+            })
+            .collect();
             let handle = get_handle(
                 "material_metallic_roughness",
                 Image::new(
@@ -262,12 +261,12 @@ impl VoxelPalette {
         } else {
             None
         };
-
+        
         let specular_transmission_texture: Option<Handle<Image>> = if has_translucency {
             let raw: Vec<u8> = translucency_data
-                .iter()
-                .flat_map(|t| ((t * u16::MAX as f32) as u16).to_le_bytes())
-                .collect();
+            .iter()
+            .flat_map(|t| ((t * u16::MAX as f32) as u16).to_le_bytes())
+            .collect();
             let handle = get_handle(
                 "material_specular_transmission",
                 Image::new(
@@ -282,13 +281,13 @@ impl VoxelPalette {
         } else {
             None
         };
-
+        
         StandardMaterial {
             base_color_texture,
             emissive: if has_emission {
-                Color::WHITE
+                LinearRgba::WHITE
             } else {
-                Color::BLACK
+                LinearRgba::BLACK
             },
             emissive_texture,
             perceptual_roughness: match (has_roughness_metalness, &self.roughness) {
@@ -312,7 +311,7 @@ impl VoxelPalette {
 
 trait VecComparable<T> {
     fn max_element(&self) -> T;
-
+    
     fn min_element(&self) -> T;
 }
 
@@ -320,42 +319,42 @@ trait Lerpable {
     fn lerp(&self, rhs: Self, amount: f32) -> Self;
 }
 
-impl Lerpable for Color {
+impl Lerpable for LinearRgba {
     fn lerp(&self, rhs: Self, amount: f32) -> Self {
-        let lhs = self.as_rgba_f32();
-        let rhs = rhs.as_rgba_f32();
+        let lhs = self.to_f32_array();
+        let rhs = rhs.to_f32_array();
         let mixed: [f32; 4] = std::array::from_fn(|i| lhs[i].lerp(rhs[i], amount));
-        Color::rgba_from_array(mixed)
+        LinearRgba::from_f32_array(mixed)
     }
 }
 impl VecComparable<f32> for Vec<f32> {
     fn max_element(&self) -> f32 {
         self.iter()
-            .cloned()
-            .max_by(|a, b| a.partial_cmp(b).expect("tried to compare NaN"))
-            .unwrap()
+        .cloned()
+        .max_by(|a, b| a.partial_cmp(b).expect("tried to compare NaN"))
+        .unwrap()
     }
-
+    
     fn min_element(&self) -> f32 {
         self.iter()
-            .cloned()
-            .min_by(|a, b| a.partial_cmp(b).expect("tried to compare NaN"))
-            .unwrap()
+        .cloned()
+        .min_by(|a, b| a.partial_cmp(b).expect("tried to compare NaN"))
+        .unwrap()
     }
 }
 
 impl VecComparable<f32> for &[f32] {
     fn max_element(&self) -> f32 {
         self.iter()
-            .cloned()
-            .max_by(|a, b| a.partial_cmp(b).expect("tried to compare NaN"))
-            .unwrap()
+        .cloned()
+        .max_by(|a, b| a.partial_cmp(b).expect("tried to compare NaN"))
+        .unwrap()
     }
-
+    
     fn min_element(&self) -> f32 {
         self.iter()
-            .cloned()
-            .min_by(|a, b| a.partial_cmp(b).expect("tried to compare NaN"))
-            .unwrap()
+        .cloned()
+        .min_by(|a, b| a.partial_cmp(b).expect("tried to compare NaN"))
+        .unwrap()
     }
 }
diff --git a/src/model/queryable.rs b/src/model/queryable.rs
index 4c0a634..2aa722f 100644
--- a/src/model/queryable.rs
+++ b/src/model/queryable.rs
@@ -41,14 +41,21 @@ pub trait VoxelQueryable {
     /// ### Returns
     /// A voxel coordinate
     fn local_point_to_voxel_space(&self, local_point: Vec3) -> IVec3 {
-        let size = self.size();
-        let half_extents = Vec3::new(size.x as f32, size.y as f32, size.z as f32) * 0.5;
+        let half_extents = self.size().as_vec3() * 0.5;
         let voxel_postition = local_point + half_extents;
-        IVec3::new(
-            voxel_postition.x as i32,
-            voxel_postition.y as i32,
-            voxel_postition.z as i32,
-        )
+        voxel_postition.as_ivec3()
+    }
+
+    /// Converts a voxel coordinate to a point in local space
+    ///
+    /// ### Arguments
+    /// * `voxel_coord` - a voxel coordinate
+    ///
+    /// ### Returns
+    /// the point in the local space of the entity that owns this [`crate::VoxelModelInstance`]
+    fn voxel_coord_to_local_space(&self, voxel_coord: IVec3) -> Vec3 {
+        let half_extents = self.size().as_vec3() * 0.5;
+        voxel_coord.as_vec3() - half_extents
     }
 
     /// If the voxel-space `point` is within the bounds of the model, it will be returned as a [`bevy::math::UVec3`].
diff --git a/src/scene/hook.rs b/src/scene/hook.rs
index e2050a5..51e9083 100644
--- a/src/scene/hook.rs
+++ b/src/scene/hook.rs
@@ -63,7 +63,7 @@ use bevy::{
 /// #     let expected_names: HashSet<&str> = ["tank/tetra", "tank/goldfish"].into();
 /// #     let all_names: HashSet<&str> = HashSet::from_iter(all_fish);
 /// #     assert_eq!(expected_names, all_names);
-/// #     exit.send(AppExit);
+/// #     exit.send(AppExit::Success);
 /// # }
 /// ```
 #[derive(Component)]
diff --git a/src/tests.rs b/src/tests.rs
index 16ccc46..824b28d 100644
--- a/src/tests.rs
+++ b/src/tests.rs
@@ -10,11 +10,11 @@ use bevy::{
     app::App,
     asset::{AssetApp, AssetPlugin, AssetServer, Assets, Handle, LoadState},
     core::Name,
-    ecs::system::{Commands, Res, RunSystemOnce},
+    ecs::system::{Commands, Res},
     hierarchy::Children,
     math::{IVec3, Quat, UVec3, Vec3, Vec3A},
     pbr::StandardMaterial,
-    render::{color::Color, mesh::Mesh, texture::ImagePlugin},
+    render::{mesh::Mesh, texture::ImagePlugin},
     utils::hashbrown::HashSet,
     MinimalPlugins,
 };
@@ -42,12 +42,12 @@ async fn test_load_scene() {
     let handle = setup_and_load_voxel_scene(&mut app, "test.vox").await;
     app.update();
     let scene = app
-        .world
+        .world()
         .resource::<Assets<VoxelScene>>()
-        .get(handle)
+        .get(handle.id())
         .expect("retrieve test.vox from Res<Assets>");
     let collection = app
-        .world
+        .world()
         .resource::<Assets<VoxelModelCollection>>()
         .get(scene.model_collection.id())
         .expect("Retrieve collection");
@@ -89,9 +89,9 @@ async fn test_load_scene_slice() {
     let handle = setup_and_load_voxel_scene(&mut app, "test.vox#outer-group/inner-group").await;
     app.update();
     let scene = app
-        .world
+        .world()
         .resource::<Assets<VoxelScene>>()
-        .get(handle)
+        .get(handle.id())
         .expect("retrieve test.vox from Res<Assets>");
     assert_eq!(scene.layers.len(), 8);
     assert_eq!(
@@ -127,21 +127,21 @@ async fn test_transmissive_mat() {
         setup_and_load_voxel_scene(&mut app, "test.vox#outer-group/inner-group/walls").await;
     app.update();
     let scene = app
-        .world
+        .world()
         .resource::<Assets<VoxelScene>>()
-        .get(handle)
+        .get(handle.id())
         .expect("retrieve scene from Res<Assets>");
     let walls = &scene.root;
     let model_id = walls.model_id.expect("Walls has a model id");
     let collection = app
-        .world
+        .world()
         .resource::<Assets<VoxelModelCollection>>()
         .get(scene.model_collection.id())
         .expect("Retrieve collection");
     let model = collection.models.get(model_id).expect("Walls has a model");
     let mat_handle = &model.material;
     let material = app
-        .world
+        .world()
         .resource::<Assets<StandardMaterial>>()
         .get(mat_handle)
         .expect("material");
@@ -158,14 +158,14 @@ async fn test_opaque_mat() {
         setup_and_load_voxel_scene(&mut app, "test.vox#outer-group/inner-group/dice").await;
     app.update();
     let scene = app
-        .world
+        .world()
         .resource::<Assets<VoxelScene>>()
-        .get(handle)
+        .get(handle.id())
         .expect("retrieve scene from Res<Assets>");
     let dice = &scene.root;
     let model_id = dice.model_id.expect("Dice has a model id");
     let collection = app
-        .world
+        .world()
         .resource::<Assets<VoxelModelCollection>>()
         .get(scene.model_collection.id())
         .expect("Retrieve collection");
@@ -175,7 +175,7 @@ async fn test_opaque_mat() {
         .expect("retrieve model from collection");
     let mat_handle = &model.material;
     let material = app
-        .world
+        .world()
         .resource::<Assets<StandardMaterial>>()
         .get(mat_handle)
         .expect("material");
@@ -191,13 +191,13 @@ async fn test_spawn_system() {
     app.update();
 
     assert_eq!(
-        app.world
+        app.world()
             .resource::<AssetServer>()
-            .load_state(handle.clone()),
+            .load_state(handle.id()),
         LoadState::Loaded
     );
     let entity = app
-        .world
+        .world_mut()
         .spawn(VoxelSceneHookBundle {
             scene: handle,
             hook: VoxelSceneHook::new(move |entity, _| {
@@ -215,43 +215,43 @@ async fn test_spawn_system() {
         })
         .id();
     app.update();
-    assert!(app.world.get::<Handle<VoxelScene>>(entity).is_none());
+    assert!(app.world().get::<Handle<VoxelScene>>(entity).is_none());
     assert_eq!(
-        app.world.query::<&VoxelLayer>().iter(&app.world).len(),
+        app.world_mut().query::<&VoxelLayer>().iter(&app.world()).len(),
         5,
         "5 voxel nodes spawned in this scene slice"
     );
     assert_eq!(
-        app.world.query::<&Name>().iter(&app.world).len(),
+        app.world_mut().query::<&Name>().iter(&app.world()).len(),
         3,
         "But only 3 of the voxel nodes are named"
     );
-    let mut instance_query = app.world.query::<&VoxelModelInstance>();
+    let mut instance_query = app.world_mut().query::<&VoxelModelInstance>();
     assert_eq!(
-        instance_query.iter(&app.world).len(),
+        instance_query.iter(&app.world()).len(),
         4,
         "4 model instances spawned in this scene slice"
     );
     let models: HashSet<String> = instance_query
-        .iter(&app.world)
+        .iter(&app.world())
         .map(|c| c.model_name.clone())
         .collect();
     assert_eq!(models.len(), 2, "Instances point to 2 unique models");
     assert_eq!(
-        app.world
+        app.world()
             .get::<Name>(entity)
             .expect("Name component")
             .as_str(),
         "outer-group/inner-group"
     );
     let children = app
-        .world
+        .world()
         .get::<Children>(entity)
         .expect("children of inner-group")
         .as_ref();
     assert_eq!(children.len(), 4, "inner-group has 4 children");
     assert_eq!(
-        app.world
+        app.world()
             .get::<Name>(*children.last().expect("last child"))
             .expect("Name component")
             .as_str(),
@@ -263,20 +263,22 @@ async fn test_spawn_system() {
 #[cfg(feature = "modify_voxels")]
 #[async_std::test]
 async fn test_modify_voxels() {
+    use bevy::ecs::system::RunSystemOnce;
+
     let mut app = App::new();
     let handle =
         setup_and_load_voxel_scene(&mut app, "test.vox#outer-group/inner-group/dice").await;
     app.update();
-    app.world.run_system_once(modify_voxels);
+    app.world_mut().run_system_once(modify_voxels);
     app.update();
     let scene = app
-        .world
+        .world()
         .resource::<Assets<VoxelScene>>()
-        .get(handle)
+        .get(handle.id())
         .expect("retrieve scene from Res<Assets>");
     let model_id = scene.root.model_id.expect("Root should have a model");
     let collection = app
-        .world
+        .world()
         .resource::<Assets<VoxelModelCollection>>()
         .get(scene.model_collection.id())
         .expect("Retrieve collection");
@@ -325,9 +327,9 @@ fn modify_voxels(mut commands: Commands, scenes: Res<Assets<VoxelScene>>) {
 fn test_generate_voxels() {
     let mut app = App::new();
     setup_app(&mut app);
-    let palette = VoxelPalette::from_colors(vec![Color::GREEN]);
+    let palette = VoxelPalette::from_colors(vec![bevy::color::palettes::css::GREEN.into()]);
     let tall_box = SDF::cuboid(Vec3::new(0.5, 2.5, 0.5)).voxelize(UVec3::splat(6), Voxel(1));
-    let world = &mut app.world;
+    let world = app.world_mut();
     let collection = VoxelModelCollection::new(world, palette).expect("create collection");
     let tall_box_model =
         VoxelModelCollection::add(world, tall_box, "tall box".to_string(), collection)
@@ -335,9 +337,9 @@ fn test_generate_voxels() {
     assert_eq!(tall_box_model.name, "tall box");
     assert_eq!(tall_box_model.has_translucency, false);
     let mesh = app
-        .world
+        .world()
         .resource::<Assets<Mesh>>()
-        .get(tall_box_model.mesh)
+        .get(tall_box_model.mesh.id())
         .expect("mesh generated");
     assert_eq!(
         mesh.compute_aabb().expect("aabb").half_extents,
@@ -397,7 +399,7 @@ fn test_voxel_queryable() {
 
 async fn setup_and_load_voxel_scene(app: &mut App, filename: &'static str) -> Handle<VoxelScene> {
     setup_app(app);
-    let assets = app.world.resource::<AssetServer>();
+    let assets = app.world().resource::<AssetServer>();
     assets
         .load_untyped_async(filename)
         .await
diff --git a/utilities/Cargo.toml b/utilities/Cargo.toml
index 7f6823c..45acca4 100644
--- a/utilities/Cargo.toml
+++ b/utilities/Cargo.toml
@@ -6,4 +6,4 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-bevy = "0.13.0"
\ No newline at end of file
+bevy = "0.14.0"
\ No newline at end of file
diff --git a/utilities/src/lib.rs b/utilities/src/lib.rs
index 1c4630c..6e4008e 100644
--- a/utilities/src/lib.rs
+++ b/utilities/src/lib.rs
@@ -36,7 +36,7 @@ fn on_spawn_camera(
     }
 }
 
-/// Pan the camera with middle mouse click, zoom with scroll wheel, orbit with right mouse click.
+/// Pan the camera with right mouse click, zoom with scroll wheel, orbit with left mouse click.
 fn pan_orbit_camera(
     window_query: Query<&Window, With<PrimaryWindow>>,
     mut ev_motion: EventReader<MouseMotion>,