diff --git a/Cargo.lock b/Cargo.lock
index b6ae571a20..dce0f7d744 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1093,6 +1093,7 @@ dependencies = [
 name = "bones_framework"
 version = "0.3.0"
 dependencies = [
+ "bones_asset",
  "bones_lib",
  "document-features",
  "egui",
@@ -1116,7 +1117,6 @@ dependencies = [
 name = "bones_lib"
 version = "0.3.0"
 dependencies = [
- "bones_asset",
  "bones_ecs",
 ]
 
diff --git a/demos/assets_minimal/src/main.rs b/demos/assets_minimal/src/main.rs
index 8a577c804d..095fc1986f 100644
--- a/demos/assets_minimal/src/main.rs
+++ b/demos/assets_minimal/src/main.rs
@@ -22,8 +22,11 @@ fn main() {
     // First create bones game.
     let mut game = Game::new();
 
-    // We must register all of our asset types before they can be loaded.
-    game.asset_server().register_asset::<GameMeta>();
+    game
+        // We initialize the asset server.
+        .init_shared_resource::<AssetServer>()
+        // We must register all of our asset types before they can be loaded.
+        .register_asset::<GameMeta>();
 
     // Create a new session for the game menu. Each session is it's own bones world with it's own
     // plugins, systems, and entities.
diff --git a/demos/features/assets/game.yaml b/demos/features/assets/game.yaml
index f212544e2e..91240b9199 100644
--- a/demos/features/assets/game.yaml
+++ b/demos/features/assets/game.yaml
@@ -1,3 +1,4 @@
+menu_image: ./menu-image.png
 sprite_demo: ./sprite/fractal.png
 atlas_demo: ./atlas/atlas-demo.yaml
 tilemap_demo: ./tilemap/tilemap.yaml
diff --git a/demos/features/assets/menu-image.png b/demos/features/assets/menu-image.png
new file mode 100644
index 0000000000..39b5937521
Binary files /dev/null and b/demos/features/assets/menu-image.png differ
diff --git a/demos/features/src/main.rs b/demos/features/src/main.rs
index 8fc7240704..9667ea4c5a 100644
--- a/demos/features/src/main.rs
+++ b/demos/features/src/main.rs
@@ -14,6 +14,8 @@ use bones_framework::prelude::*;
 // Allow asset to be loaded from "game.yaml" assets.
 #[type_data(metadata_asset("game"))]
 struct GameMeta {
+    /// The image displayed on the menu.
+    menu_image: Handle<Image>,
     /// The image for the sprite demo
     sprite_demo: Handle<Image>,
     /// Character information that will be loaded from a separate asset file.
@@ -80,7 +82,7 @@ pub fn create_game() -> Game {
     let mut game = Game::new();
 
     // Configure the asset server
-    game.asset_server()
+    game.init_shared_resource::<AssetServer>()
         // Register the default asset types
         .register_default_assets()
         // Register our custom asset types
@@ -118,9 +120,11 @@ fn menu_startup(
 
 /// Our main menu system.
 fn menu_system(
+    meta: Root<GameMeta>,
     egui_ctx: ResMut<EguiCtx>,
     mut sessions: ResMut<Sessions>,
     mut session_options: ResMut<SessionOptions>,
+    egui_textures: Res<EguiTextures>,
     // Get the localization field from our `GameMeta`
     localization: Localization<GameMeta>,
 ) {
@@ -172,6 +176,13 @@ fn menu_system(
                         .create("path2d_demo")
                         .install_plugin(path2d_demo_plugin);
                 }
+
+                ui.add_space(40.0);
+
+                // When using a bones image in egui, we have to get it's corresponding egui texture
+                // from the egui textures resource.
+                ui.label("Bones Image Rendered in Egui");
+                ui.image(egui_textures.get(meta.menu_image), [100., 100.]);
             });
         });
 }
diff --git a/framework_crates/bones_bevy_renderer/src/lib.rs b/framework_crates/bones_bevy_renderer/src/lib.rs
index 127f365831..04fd22bacd 100644
--- a/framework_crates/bones_bevy_renderer/src/lib.rs
+++ b/framework_crates/bones_bevy_renderer/src/lib.rs
@@ -74,22 +74,40 @@ impl BonesImageIds {
     pub fn load_bones_images(
         &mut self,
         bones_assets: &mut bones::AssetServer,
+        bones_egui_textures: &mut bones::EguiTextures,
         bevy_images: &mut Assets<Image>,
+        bevy_egui_textures: &mut bevy_egui::EguiUserTextures,
     ) {
-        for asset in bones_assets.store.assets.values_mut() {
+        for (handle, cid) in bones_assets.store.asset_ids.iter() {
+            let asset = bones_assets.store.assets.get_mut(cid).unwrap();
             if let Ok(image) = asset.data.try_cast_mut::<bones::Image>() {
-                self.load_bones_image(image, bevy_images)
+                self.load_bones_image(
+                    handle.typed(),
+                    image,
+                    bones_egui_textures,
+                    bevy_images,
+                    bevy_egui_textures,
+                )
             }
         }
     }
 
     /// Load a bones image into bevy.
-    pub fn load_bones_image(&mut self, image: &mut bones::Image, bevy_images: &mut Assets<Image>) {
+    pub fn load_bones_image(
+        &mut self,
+        bones_handle: bones::Handle<bones::Image>,
+        image: &mut bones::Image,
+        bones_egui_textures: &mut bones::EguiTextures,
+        bevy_images: &mut Assets<Image>,
+        bevy_egui_textures: &mut bevy_egui::EguiUserTextures,
+    ) {
         let Self { map, next_id } = self;
         let mut taken_image = bones::Image::External(0); // Dummy value temporarily
         std::mem::swap(image, &mut taken_image);
         if let bones::Image::Data(data) = taken_image {
             let handle = bevy_images.add(Image::from_dynamic(data, true));
+            let egui_texture = bevy_egui_textures.add_image(handle.clone());
+            bones_egui_textures.insert(bones_handle, egui_texture);
             map.insert(*next_id, handle);
             *image = bones::Image::External(*next_id);
             *next_id += 1;
@@ -103,7 +121,7 @@ pub struct BonesData {
     /// The bones game.
     pub game: bones::Game,
     /// The bones asset server cell.
-    pub asset_server: bones::AtomicResource<bones::AssetServer>,
+    pub asset_server: Option<bones::AtomicResource<bones::AssetServer>>,
 }
 
 impl BonesBevyRenderer {
@@ -122,7 +140,7 @@ impl BonesBevyRenderer {
     }
 
     /// Return a bevy [`App`] configured to run the bones game.
-    pub fn app(self) -> App {
+    pub fn app(mut self) -> App {
         let mut app = App::new();
 
         // Initialize Bevy plugins we use
@@ -142,10 +160,15 @@ impl BonesBevyRenderer {
             })
             .init_resource::<BonesImageIds>();
 
-        {
-            let mut bones_image_ids = BonesImageIds::default();
-            let mut asset_server = self.game.asset_server();
-            let mut bevy_images = app.world.resource_mut::<Assets<Image>>();
+        let mut bones_image_ids = BonesImageIds::default();
+        let mut bones_egui_textures = bones::EguiTextures::default();
+        'asset_load: {
+            let Some(mut asset_server) = self.game.shared_resource::<bones::AssetServer>() else {
+                break 'asset_load;
+            };
+            let world = app.world.cell();
+            let mut bevy_images = world.resource_mut::<Assets<Image>>();
+            let mut bevy_egui_textures = world.resource_mut::<bevy_egui::EguiUserTextures>();
 
             if !asset_server.asset_types.is_empty() {
                 #[cfg(not(target_arch = "wasm32"))]
@@ -160,22 +183,33 @@ impl BonesBevyRenderer {
                         .expect("Could not load game assets");
 
                     // Take all loaded image assets and conver them to external images that reference bevy handles
-                    bones_image_ids.load_bones_images(&mut asset_server, &mut bevy_images);
+                    bones_image_ids.load_bones_images(
+                        &mut asset_server,
+                        &mut bones_egui_textures,
+                        &mut bevy_images,
+                        &mut bevy_egui_textures,
+                    );
                 }
                 #[cfg(target_arch = "wasm32")]
                 {
-                    bones_image_ids.load_bones_images(&mut asset_server, &mut bevy_images);
+                    bones_image_ids.load_bones_images(
+                        &mut asset_server,
+                        &mut bones_egui_textures,
+                        &mut bevy_images,
+                        &mut bevy_egui_textures,
+                    );
                     // TODO: Implement WASM asset loader.
                     unimplemented!("WASM asset loading is not implemented yet.");
                 }
             }
-
-            app.insert_resource(bones_image_ids);
         }
 
+        self.game.insert_shared_resource(bones_egui_textures);
+        app.insert_resource(bones_image_ids);
+
         // Insert the bones data
         app.insert_resource(BonesData {
-            asset_server: self.game.asset_server.clone_cell(),
+            asset_server: self.game.shared_resource_cell::<bones::AssetServer>(),
             game: self.game,
         })
         .init_resource::<BonesGameEntity>();
@@ -257,76 +291,82 @@ fn step_bones_game(
     In((mouse_inputs, keyboard_inputs)): In<(bones::MouseInputs, bones::KeyboardInputs)>,
     world: &mut World,
 ) {
-    world.resource_scope(|world: &mut World, mut data: Mut<BonesData>| {
-        world.resource_scope(
-            |world: &mut World, mut bones_image_ids: Mut<BonesImageIds>| {
-                world.resource_scope(|world: &mut World, mut bevy_images: Mut<Assets<Image>>| {
-                    let egui_ctx = {
-                        let mut egui_query =
-                            world.query_filtered::<&mut EguiContext, With<Window>>();
-                        let mut egui_ctx = egui_query.get_single_mut(world).unwrap();
-                        egui_ctx.get_mut().clone()
-                    };
-                    let BonesData { game, asset_server } = &mut *data;
-                    let bevy_time = world.resource::<Time>();
-
-                    let mouse_inputs = bones::AtomicResource::new(mouse_inputs);
-                    let keyboard_inputs = bones::AtomicResource::new(keyboard_inputs);
-
-                    // Reload assets if necessary
-                    game.asset_server()
-                        .handle_asset_changes(|asset_server, handle| {
-                            let asset = asset_server.get_untyped_mut(handle).unwrap();
-
-                            if let Ok(image) = asset.data.try_cast_mut::<bones::Image>() {
-                                bones_image_ids.load_bones_image(image, &mut bevy_images);
-                            }
-                        });
-
-                    // Step the game simulation
-                    game.step(|bones_world| {
-                        // Insert egui context if not present
-                        if !bones_world
-                            .resources
-                            .contains::<bones_framework::render::ui::EguiCtx>()
-                        {
-                            bones_world
-                                .resources
-                                .insert(bones_framework::render::ui::EguiCtx(egui_ctx.clone()));
-                        }
-
-                        // Update bones time
-                        {
-                            // Initialize the time resource if it doesn't exist.
-                            if !bones_world.resources.contains::<bones::Time>() {
-                                bones_world.init_resource::<bones::Time>();
-                            }
-
-                            let mut time = bones_world.resource_mut::<bones::Time>();
-
-                            // Use the Bevy time if it's available, otherwise use the default time.
-                            if let Some(instant) = bevy_time.last_update() {
-                                time.update_with_instant(instant);
-                            } else {
-                                time.update();
-                            }
-                        }
-
-                        // Insert asset server if not present
-                        if !bones_world.resources.contains::<bones::AssetServer>() {
-                            bones_world.resources.insert_cell(asset_server.clone_cell());
-                        }
-
-                        // Update the inputs.
-                        bones_world.resources.insert_cell(mouse_inputs.clone_cell());
-                        bones_world
-                            .resources
-                            .insert_cell(keyboard_inputs.clone_cell());
-                    });
-                });
-            },
-        );
+    let mut data = world.remove_resource::<BonesData>().unwrap();
+    let mut bones_image_ids = world.remove_resource::<BonesImageIds>().unwrap();
+    let mut bevy_egui_textures = world
+        .remove_resource::<bevy_egui::EguiUserTextures>()
+        .unwrap();
+    let mut bevy_images = world.remove_resource::<Assets<Image>>().unwrap();
+
+    let egui_ctx = {
+        let mut egui_query = world.query_filtered::<&mut EguiContext, With<Window>>();
+        let mut egui_ctx = egui_query.get_single_mut(world).unwrap();
+        egui_ctx.get_mut().clone()
+    };
+    let BonesData { game, .. } = &mut data;
+    let bevy_time = world.resource::<Time>();
+
+    let mouse_inputs = bones::AtomicResource::new(mouse_inputs);
+    let keyboard_inputs = bones::AtomicResource::new(keyboard_inputs);
+
+    // Reload assets if necessary
+    if let Some(mut asset_server) = game.shared_resource::<bones::AssetServer>() {
+        asset_server.handle_asset_changes(|asset_server, handle| {
+            let mut bones_egui_textures = game.shared_resource::<bones::EguiTextures>().unwrap();
+            let asset = asset_server.get_untyped_mut(handle).unwrap();
+
+            if let Ok(image) = asset.data.try_cast_mut::<bones::Image>() {
+                bones_image_ids.load_bones_image(
+                    handle.typed(),
+                    image,
+                    &mut bones_egui_textures,
+                    &mut bevy_images,
+                    &mut bevy_egui_textures,
+                );
+            }
+        })
+    }
+
+    // Step the game simulation
+    game.step(|bones_world| {
+        // Insert egui context if not present
+        if !bones_world
+            .resources
+            .contains::<bones_framework::render::ui::EguiCtx>()
+        {
+            bones_world
+                .resources
+                .insert(bones_framework::render::ui::EguiCtx(egui_ctx.clone()));
+        }
+
+        // Update bones time
+        {
+            // Initialize the time resource if it doesn't exist.
+            if !bones_world.resources.contains::<bones::Time>() {
+                bones_world.init_resource::<bones::Time>();
+            }
+
+            let mut time = bones_world.resource_mut::<bones::Time>();
+
+            // Use the Bevy time if it's available, otherwise use the default time.
+            if let Some(instant) = bevy_time.last_update() {
+                time.update_with_instant(instant);
+            } else {
+                time.update();
+            }
+        }
+
+        // Update the inputs.
+        bones_world.resources.insert_cell(mouse_inputs.clone_cell());
+        bones_world
+            .resources
+            .insert_cell(keyboard_inputs.clone_cell());
     });
+
+    world.insert_resource(data);
+    world.insert_resource(bones_image_ids);
+    world.insert_resource(bevy_egui_textures);
+    world.insert_resource(bevy_images);
 }
 
 fn sync_clear_color(mut clear_color: ResMut<ClearColor>, mut data: ResMut<BonesData>) {
@@ -438,7 +478,10 @@ fn extract_bones_sprites(
     bones_renderable_entity: Extract<Res<BonesGameEntity>>,
 ) {
     let game = &data.game;
-    let bones_assets = data.asset_server.borrow();
+    let Some(bones_assets) = &data.asset_server else {
+        return;
+    };
+    let bones_assets = bones_assets.borrow();
 
     for session_name in &game.sorted_session_keys {
         let session = game.sessions.get(*session_name).unwrap();
@@ -534,7 +577,10 @@ fn extract_bones_tilemaps(
     bones_renderable_entity: Extract<Res<BonesGameEntity>>,
 ) {
     let game = &data.game;
-    let bones_assets = data.asset_server.borrow();
+    let Some(bones_assets) = &data.asset_server else {
+        return;
+    };
+    let bones_assets = bones_assets.borrow();
 
     for session_name in &game.sorted_session_keys {
         let session = game.sessions.get(*session_name).unwrap();
diff --git a/framework_crates/bones_ecs/src/resources.rs b/framework_crates/bones_ecs/src/resources.rs
index 7fc02d368f..1a63e3c078 100644
--- a/framework_crates/bones_ecs/src/resources.rs
+++ b/framework_crates/bones_ecs/src/resources.rs
@@ -6,17 +6,6 @@ use atomicell::borrow::{AtomicBorrow, AtomicBorrowMut};
 
 use crate::prelude::*;
 
-/// Storage for un-typed resources.
-///
-/// This is the backing data store used by [`Resources`].
-///
-/// Unless you are intending to do modding or otherwise need raw pointers to your resource data, you
-/// should use [`Resources`] instead.
-#[derive(Clone, Default)]
-pub struct UntypedResources {
-    resources: HashMap<SchemaId, UntypedAtomicResource>,
-}
-
 /// An untyped resource that may be inserted into [`UntypedResources`].
 pub struct UntypedAtomicResource {
     cell: Arc<AtomicCell<SchemaBox>>,
@@ -85,6 +74,14 @@ impl<'a> AtomicSchemaRef<'a> {
     pub unsafe fn deref<T>(self) -> Ref<'a, T> {
         Ref::with_borrow(self.schema_ref.deref(), self.borrow)
     }
+
+    /// Convert into typed [`Ref`]. This panics if the schema doesn't match.
+    #[track_caller]
+    pub fn typed<T: HasSchema>(self) -> Ref<'a, T> {
+        assert_eq!(T::schema(), self.schema(), "Schema mismatch");
+        // SOUND: we've checked for matching schema.
+        unsafe { self.deref() }
+    }
 }
 
 /// An atomic borrow of a [`SchemaRefMut`].
@@ -101,6 +98,14 @@ impl<'a> AtomicSchemaRefMut<'a> {
     pub unsafe fn deref_mut<T>(self) -> RefMut<'a, T> {
         RefMut::with_borrow(self.schema_ref.deref_mut(), self.borrow)
     }
+
+    /// Convert into typed [`RefMut`]. This panics if the schema doesn't match.
+    #[track_caller]
+    pub fn typed<T: HasSchema>(self) -> RefMut<'a, T> {
+        assert_eq!(T::schema(), self.schema(), "Schema mismatch");
+        // SOUND: we've checked for matching schema.
+        unsafe { self.deref_mut() }
+    }
 }
 
 impl Clone for UntypedAtomicResource {
@@ -112,6 +117,17 @@ impl Clone for UntypedAtomicResource {
     }
 }
 
+/// Storage for un-typed resources.
+///
+/// This is the backing data store used by [`Resources`].
+///
+/// Unless you are intending to do modding or otherwise need raw pointers to your resource data, you
+/// should use [`Resources`] instead.
+#[derive(Clone, Default)]
+pub struct UntypedResources {
+    resources: HashMap<SchemaId, UntypedAtomicResource>,
+}
+
 impl UntypedResources {
     /// Create an empty [`UntypedResources`].
     pub fn new() -> Self {
@@ -125,6 +141,11 @@ impl UntypedResources {
             .insert(id, UntypedAtomicResource::new(resource))
     }
 
+    /// Check whether or not the resoruce with the given ID is present.
+    pub fn contains(&self, id: SchemaId) -> bool {
+        self.resources.contains_key(&id)
+    }
+
     /// Insert a resource.
     pub fn insert_cell(
         &mut self,
diff --git a/framework_crates/bones_framework/Cargo.toml b/framework_crates/bones_framework/Cargo.toml
index 899138c9c8..c6a0f6e1c7 100644
--- a/framework_crates/bones_framework/Cargo.toml
+++ b/framework_crates/bones_framework/Cargo.toml
@@ -47,6 +47,7 @@ document-features = ["dep:document-features"]
 [dependencies]
 # Bones
 bones_lib = { version = "0.3", path = "../bones_lib", features = ["glam"] }
+bones_asset = { version = "0.3", path = "../bones_asset" }
 
 # Other
 glam      = "0.24"
diff --git a/framework_crates/bones_framework/src/lib.rs b/framework_crates/bones_framework/src/lib.rs
index 4bbb628794..fac956c6c6 100644
--- a/framework_crates/bones_framework/src/lib.rs
+++ b/framework_crates/bones_framework/src/lib.rs
@@ -10,6 +10,9 @@
 #[doc(inline)]
 pub use bones_lib as lib;
 
+#[doc(inline)]
+pub use bones_asset as asset;
+
 /// Math library.
 #[doc(inline)]
 pub use glam;
@@ -20,6 +23,8 @@ pub mod prelude {
         animation::*, input::prelude::*, params::*, render::prelude::*, AssetServerExt,
         DefaultPlugin,
     };
+    pub use bones_asset::anyhow::Context;
+    pub use bones_asset::prelude::*;
     pub use bones_lib::prelude::*;
     pub use glam::*;
 
@@ -43,12 +48,12 @@ impl lib::Plugin for DefaultPlugin {
     }
 }
 
-/// Extension trait for the bones [`AssetServer`][bones_lib::prelude::AssetServer].
+/// Extension trait for the bones [`AssetServer`][bones_asset::AssetServer].
 pub trait AssetServerExt {
     /// Register the default assets from `bones_framework`.
     fn register_default_assets(self) -> Self;
 }
-impl AssetServerExt for &mut bones_lib::prelude::AssetServer {
+impl AssetServerExt for &mut bones_asset::AssetServer {
     fn register_default_assets(self) -> Self {
         use crate::prelude::*;
 
diff --git a/framework_crates/bones_framework/src/localization.rs b/framework_crates/bones_framework/src/localization.rs
index 6bf9913529..4fa29233c9 100644
--- a/framework_crates/bones_framework/src/localization.rs
+++ b/framework_crates/bones_framework/src/localization.rs
@@ -8,13 +8,12 @@ use std::{
     sync::{Arc, OnceLock},
 };
 
-use bones_lib::prelude::anyhow::Context;
+use crate::prelude::*;
+
 use fluent_bundle::{FluentArgs, FluentResource};
 use intl_memoizer::concurrent::IntlLangMemoizer;
 use unic_langid::LanguageIdentifier;
 
-use crate::prelude::*;
-
 pub use fluent_bundle;
 pub use fluent_langneg;
 pub use intl_memoizer;
diff --git a/framework_crates/bones_framework/src/render/ui.rs b/framework_crates/bones_framework/src/render/ui.rs
index b41be53975..0bc819f076 100644
--- a/framework_crates/bones_framework/src/render/ui.rs
+++ b/framework_crates/bones_framework/src/render/ui.rs
@@ -12,6 +12,14 @@ pub struct EguiCtx(pub egui::Context);
 #[derive(HasSchema, Clone, Debug, Default, Deref, DerefMut)]
 pub struct EguiTextures(pub HashMap<Handle<Image>, egui::TextureId>);
 
+impl EguiTextures {
+    /// Get the [`egui::TextureId`] for the given bones [`Handle<Image>`].
+    #[track_caller]
+    pub fn get(&self, handle: Handle<Image>) -> egui::TextureId {
+        *self.0.get(&handle).unwrap()
+    }
+}
+
 /// Resource for configuring egui rendering.
 #[derive(HasSchema, Clone, Debug)]
 #[repr(C)]
diff --git a/framework_crates/bones_lib/Cargo.toml b/framework_crates/bones_lib/Cargo.toml
index 3b8c366d9b..cb6248fdce 100644
--- a/framework_crates/bones_lib/Cargo.toml
+++ b/framework_crates/bones_lib/Cargo.toml
@@ -16,4 +16,3 @@ glam    = ["bones_ecs/glam"]
 
 [dependencies]
 bones_ecs   = { version = "0.3", path = "../bones_ecs" }
-bones_asset = { version = "0.3", path = "../bones_asset" }
diff --git a/framework_crates/bones_lib/src/lib.rs b/framework_crates/bones_lib/src/lib.rs
index 5d7bdce547..654d783fb4 100644
--- a/framework_crates/bones_lib/src/lib.rs
+++ b/framework_crates/bones_lib/src/lib.rs
@@ -5,16 +5,13 @@
 #![cfg_attr(doc, allow(unknown_lints))]
 #![deny(rustdoc::all)]
 
-#[doc(inline)]
-pub use bones_asset as asset;
 #[doc(inline)]
 pub use bones_ecs as ecs;
 
 /// Bones lib prelude
 pub mod prelude {
     pub use crate::{
-        asset::prelude::*, ecs::prelude::*, Game, Plugin, Session, SessionOptions, SessionRunner,
-        Sessions,
+        ecs::prelude::*, Game, Plugin, Session, SessionOptions, SessionRunner, Sessions,
     };
 }
 
@@ -145,19 +142,60 @@ pub struct Game {
     /// These are only guaranteed to be sorted and up-to-date immediately after calling
     /// [`Game::step()`].
     pub sorted_session_keys: Vec<Key>,
-    /// The asset server cell.
-    pub asset_server: AtomicResource<AssetServer>,
+    /// Collection of resources that will have a shared instance of each be inserted into each
+    /// session automatically.
+    pub shared_resources: Vec<UntypedAtomicResource>,
 }
 
 impl Game {
-    /// Create an empty game.
+    /// Create an empty game with an asset server.
     pub fn new() -> Self {
         Self::default()
     }
 
-    /// Borrow the asset server.
-    pub fn asset_server(&self) -> RefMut<AssetServer> {
-        self.asset_server.borrow_mut()
+    /// Get the shared resource of a given type out of this [`Game`]s shared resources.
+    pub fn shared_resource<T: HasSchema>(&self) -> Option<RefMut<T>> {
+        self.shared_resources
+            .iter()
+            .find(|x| x.schema() == T::schema())
+            .map(|x| x.borrow_mut().typed())
+    }
+
+    /// Get the shared resource cell of a given type out of this [`Game`]s shared resources.
+    pub fn shared_resource_cell<T: HasSchema>(&self) -> Option<AtomicResource<T>> {
+        self.shared_resources
+            .iter()
+            .find(|x| x.schema() == T::schema())
+            .map(|x| AtomicResource::from_untyped(x.clone_cell()))
+    }
+
+    /// Initialize a resource that will be shared across game sessions using it's [`Default`] value
+    /// if it is not already initialized, and borrow it for modification.
+    pub fn init_shared_resource<T: HasSchema + Default>(&mut self) -> RefMut<T> {
+        if !self
+            .shared_resources
+            .iter()
+            .any(|x| x.schema() == T::schema())
+        {
+            self.insert_shared_resource(T::default());
+        }
+        self.shared_resource::<T>().unwrap()
+    }
+
+    /// Insert a resource that will be shared across all game sessions.
+    pub fn insert_shared_resource<T: HasSchema + Default>(&mut self, resource: T) {
+        let resource = UntypedAtomicResource::new(SchemaBox::new(resource));
+
+        // Replace an existing resource of the same type.
+        for r in &mut self.shared_resources {
+            if r.schema() == T::schema() {
+                *r = resource;
+                return;
+            }
+        }
+
+        // Or insert a new resource if we couldn't find one
+        self.shared_resources.push(resource);
     }
 
     /// Step the game simulation.
@@ -185,12 +223,20 @@ impl Game {
 
             // If this session is active
             let options = if current_session.active {
-                // Make sure the asset server is inserted
-                if !current_session.world.resources.contains::<AssetServer>() {
-                    current_session
+                // Make sure session contains all of the shared resources
+                for r in &self.shared_resources {
+                    if !current_session
                         .world
                         .resources
-                        .insert_cell(self.asset_server.clone_cell());
+                        .untyped()
+                        .contains(r.schema().id())
+                    {
+                        current_session
+                            .world
+                            .resources
+                            .untyped_mut()
+                            .insert_cell(r.clone_cell());
+                    }
                 }
 
                 // Insert the session options