diff --git a/character_window/src/abilities/ability_right_side.rs b/character_window/src/abilities/ability_right_side.rs
index 54d1d78..5d8dc1c 100644
--- a/character_window/src/abilities/ability_right_side.rs
+++ b/character_window/src/abilities/ability_right_side.rs
@@ -28,37 +28,47 @@ impl<A: Ability + 'static> AbilityPageRightSide<A> {
         "fourth_ability",
     ];
 
-    pub fn new(world: &World, hero: Entity) -> Result<Self> {
+    pub fn new(world: &mut World, hero: Entity, reference: &Weak<CharacterWindow>) -> Result<Self> {
         let snippet = GuiSnippet::from_str(
-            world.resources.get::<Arc<GuiHandler>>(),
+            world,
             include_str!("../../resources/abilities/right_side.xml"),
         )?;
 
-        let color_settings = world.resources.get::<ItemSettings>().rarity_color_settings;
+        let mut resources = world.resources.multi_mut();
+        let gui_handler = resources.get::<GuiHandler>();
+        let engine_settings = resources.get::<EngineSettings>();
+        let context = resources.get::<Context>();
 
-        Self::rarity_icon_background(&snippet, "common", color_settings.common)?;
-        Self::rarity_icon_background(&snippet, "uncommon", color_settings.uncommon)?;
-        Self::rarity_icon_background(&snippet, "magical", color_settings.magical)?;
-        Self::rarity_icon_background(&snippet, "rare", color_settings.rare)?;
-        Self::rarity_icon_background(&snippet, "epic", color_settings.epic)?;
-        Self::rarity_icon_background(&snippet, "legendary", color_settings.legendary)?;
+        let color_settings = resources
+            .get::<ItemSettings>()
+            .rarity_color_settings
+            .clone();
+
+        Self::rarity_icon_background(gui_handler, &snippet, "common", color_settings.common)?;
+        Self::rarity_icon_background(gui_handler, &snippet, "uncommon", color_settings.uncommon)?;
+        Self::rarity_icon_background(gui_handler, &snippet, "magical", color_settings.magical)?;
+        Self::rarity_icon_background(gui_handler, &snippet, "rare", color_settings.rare)?;
+        Self::rarity_icon_background(gui_handler, &snippet, "epic", color_settings.epic)?;
+        Self::rarity_icon_background(gui_handler, &snippet, "legendary", color_settings.legendary)?;
 
         for (index, name) in Self::ABILITY_BUTTON_NAMES.iter().enumerate() {
             let button: Arc<Button> = snippet.element(name)?;
 
-            button.set_info_icon(&world.resources.get::<EngineSettings>().controller_icon(
-                world.resources.get::<Context>(),
-                ControllerButton::RightStick,
-            )?)?;
+            button.set_info_icon(
+                gui_handler,
+                &engine_settings.controller_icon(context, ControllerButton::RightStick)?,
+            )?;
 
             button.set_callback({
-                || {
+                let reference = reference.clone();
+
+                move |world: &mut World| {
                     if let Some(menu) = reference.upgrade() {
                         let mut tabs = menu.tabs_mut();
                         let abilities = tabs.abilities::<A>();
 
                         abilities.right_side.ability_index = index;
-                        abilities.update_page()?;
+                        abilities.update_page(world)?;
                     }
 
                     Ok(())
@@ -66,39 +76,35 @@ impl<A: Ability + 'static> AbilityPageRightSide<A> {
             });
 
             button.set_select_callback({
-                let engine = engine.clone();
                 let reference = reference.clone();
                 let weak_button = Arc::downgrade(&button);
 
-                move |selected| {
+                move |world, selected| {
                     if let Some(menu) = reference.upgrade() {
                         if selected {
-                            engine.on_scene(|scene| {
-                                let entity = scene.entity(hero)?;
-                                let abilities = entity.get_component::<AbilitySlots<A>>()?;
+                            let entity = unsafe { remove_life_time(world.entity(hero)?) };
+                            let abilities = entity.get_component::<AbilitySlots<A>>()?;
 
-                                if let Some(book) = abilities.book(index) {
-                                    let button = weak_button.upgrade().unwrap();
-                                    let button_pos = button.position_extent();
+                            if let Some(book) = abilities.book(index) {
+                                let button = weak_button.upgrade().unwrap();
+                                let button_pos = button.position_extent();
 
-                                    let target_x = button_pos.0 + button_pos.2 as i32;
-                                    let target_y = button_pos.1;
+                                let target_x = button_pos.0 + button_pos.2 as i32;
+                                let target_y = button_pos.1;
 
-                                    let statistics = entity.get_component::<Statistics>()?;
+                                let statistics = entity.get_component::<Statistics>()?;
 
-                                    let gui = book.create_tooltip(
-                                        engine.gui_handler(),
-                                        statistics,
-                                        (target_x, target_y),
-                                    )?;
-                                    gui.enable()?;
-                                    gui.perform_single_check(button_pos.0, button_pos.1)?;
+                                let gui =
+                                    book.create_tooltip(world, statistics, (target_x, target_y))?;
+                                gui.enable(world)?;
+                                gui.perform_single_check(
+                                    world.resources.get_mut::<GuiHandler>(),
+                                    button_pos.0,
+                                    button_pos.1,
+                                )?;
 
-                                    menu.add_tooltip("active_ability", gui);
-                                }
-
-                                Ok(())
-                            })?;
+                                menu.add_tooltip("active_ability", gui);
+                            }
                         } else {
                             menu.remove_tooltip("active_ability");
                         }
@@ -109,32 +115,27 @@ impl<A: Ability + 'static> AbilityPageRightSide<A> {
             });
 
             button.set_custom_callback({
-                let engine = engine.clone();
                 let reference = reference.clone();
 
-                move |button| match button {
+                move |world, button| match button {
                     ControllerButton::Y => {
-                        engine.on_scene_mut(|scene| {
-                            let entity = scene.entity_mut(hero)?;
-                            let mut multi_mut = entity.multi_mut();
+                        let entity = world.entity_mut(hero)?;
+                        let mut multi_mut = entity.multi_mut();
 
-                            let abilities = multi_mut.get::<AbilitySlots<A>>()?;
+                        let abilities = multi_mut.get::<AbilitySlots<A>>()?;
 
-                            if let Some(ability) = abilities.book_mut(index) {
-                                let materials = multi_mut.get::<CraftingMaterials>()?;
+                        if let Some(ability) = abilities.book_mut(index) {
+                            let materials = multi_mut.get::<CraftingMaterials>()?;
 
-                                ability.upgrade(materials);
+                            ability.upgrade(materials);
 
-                                if let Some(menu) = reference.upgrade() {
-                                    menu.tabs_mut()
-                                        .abilities::<A>()
-                                        .right_side
-                                        .refresh(&engine, hero)?;
-                                }
+                            if let Some(menu) = reference.upgrade() {
+                                menu.tabs_mut()
+                                    .abilities::<A>()
+                                    .right_side
+                                    .refresh(world, hero)?;
                             }
-
-                            Ok(())
-                        })?;
+                        }
 
                         Ok(true)
                     }
@@ -155,43 +156,61 @@ impl<A: Ability + 'static> AbilityPageRightSide<A> {
         self.ability_index
     }
 
-    fn rarity_icon_background(gui: &GuiSnippet, element: &str, color: Color) -> Result<()> {
+    fn rarity_icon_background(
+        gui_handler: &mut GuiHandler,
+        gui: &GuiSnippet,
+        element: &str,
+        color: Color,
+    ) -> Result<()> {
         let icon: Arc<Icon> = gui.element(element)?;
 
-        icon.set_background(FillTypeInfo::Element(
-            ElementDescriptor::new(color, Color::Black, 2),
-            DisplayableFillType::Square,
-        ))
+        icon.set_background(
+            gui_handler,
+            FillTypeInfo::Element(
+                ElementDescriptor::new(color, Color::Black, 2),
+                DisplayableFillType::Square,
+            ),
+        )
     }
 
-    fn update_crafting_count(&self, element: &str, value: u32) -> Result<()> {
+    fn update_crafting_count(
+        &self,
+        gui_handler: &mut GuiHandler,
+        element: &str,
+        value: u32,
+    ) -> Result<()> {
         let icon: Arc<Icon> = self.snippet.element(element)?;
-        icon.set_text(value)?;
+        icon.set_text(gui_handler, value)?;
 
         Ok(())
     }
 
-    fn update_ability_icon(&self, element: &str, image: Option<Arc<Image>>) -> Result<()> {
+    fn update_ability_icon(
+        &self,
+        gui_handler: &mut GuiHandler,
+        element: &str,
+        image: Option<Arc<Image>>,
+    ) -> Result<()> {
         let button: Arc<Button> = self.snippet.element(element)?;
 
         match image {
             Some(image) => {
-                button.set_icon(&image)?;
+                button.set_icon(gui_handler, &image)?;
             }
             None => {
-                button.clear_icon()?;
+                button.clear_icon(gui_handler)?;
             }
         }
 
         Ok(())
     }
 
-    fn update_active_ability(&self, engine: &Engine, abilities: &AbilitySlots<A>) -> Result<()> {
+    fn update_active_ability(&self, world: &mut World, abilities: &AbilitySlots<A>) -> Result<()> {
         let grid: Arc<Grid> = self.snippet.element("ability_content")?;
         let (_, rows) = grid.dimensions();
 
         for y in 0..rows {
-            grid.detach(0, y)?;
+            grid.detach(world, 0, y)?;
         }
 
         if let Some(ability) = abilities.book(self.ability_index) {
@@ -199,7 +218,7 @@ impl<A: Ability + 'static> AbilityPageRightSide<A> {
                 match addon.as_ref() {
                     Some(addon) => {
                         let addon_type_snippet = GuiSnippet::from_str(
-                            engine.gui_handler(),
+                            world,
                             include_str!("../../resources/abilities/addon_type_snippet.xml"),
                         )?;
 
@@ -207,19 +226,21 @@ impl<A: Ability + 'static> AbilityPageRightSide<A> {
                         let addon_type: Arc<Label> = addon_type_snippet.element("addon_type")?;
                         let addon_value: Arc<Label> = addon_type_snippet.element("addon_value")?;
 
-                        addon_icon.set_icon(&addon.icon())?;
-                        addon_type.set_text(&format!("{}", addon.addon_type()))?;
-                        addon_value.set_text(&addon.addon_type().val_as_str())?;
+                        let gui_handler = world.resources.get_mut::<GuiHandler>();
 
-                        grid.attach(addon_type_snippet, 0, index, 1, 1)?;
+                        addon_icon.set_icon(gui_handler, &addon.icon())?;
+                        addon_type.set_text(gui_handler, &format!("{}", addon.addon_type()))?;
+                        addon_value.set_text(gui_handler, &addon.addon_type().val_as_str())?;
+
+                        grid.attach(world, addon_type_snippet, 0, index, 1, 1)?;
                     }
                     None => {
                         let empty_addon = GuiSnippet::from_str(
-                            engine.gui_handler(),
+                            world,
                             include_str!("../../resources/abilities/empty_addon_snippet.xml"),
                         )?;
 
-                        grid.attach(empty_addon, 0, index, 1, 1)?;
+                        grid.attach(world, empty_addon, 0, index, 1, 1)?;
                     }
                 }
             }
@@ -228,36 +249,44 @@ impl<A: Ability + 'static> AbilityPageRightSide<A> {
         Ok(())
     }
 
-    pub fn next_ability(&mut self, engine: &Arc<Engine>, hero: Entity) -> Result<()> {
+    pub fn next_ability(&mut self, world: &mut World, hero: Entity) -> Result<()> {
         self.ability_index = (self.ability_index + 1) % 4;
-        self.refresh(engine, hero)
+        self.refresh(world, hero)
     }
 }
 
 impl<A: Ability + 'static> RightSide for AbilityPageRightSide<A> {
-    fn refresh(&mut self, engine: &Engine, hero: Entity) -> Result<()> {
-        engine.on_scene(|scene| {
-            let entity = scene.entity(hero)?;
+    fn refresh(&mut self, world: &mut World, hero: Entity) -> Result<()> {
+        let entity = unsafe { remove_life_time(world.entity(hero)?) };
 
-            let crafting = entity.get_component::<CraftingMaterials>()?;
+        let crafting = entity.get_component::<CraftingMaterials>()?;
 
-            self.update_crafting_count("common", crafting.count(Rarities::Common))?;
-            self.update_crafting_count("uncommon", crafting.count(Rarities::Uncommon))?;
-            self.update_crafting_count("magical", crafting.count(Rarities::Magical))?;
-            self.update_crafting_count("rare", crafting.count(Rarities::Rare))?;
-            self.update_crafting_count("epic", crafting.count(Rarities::Epic))?;
-            self.update_crafting_count("legendary", crafting.count(Rarities::Legendary))?;
+        let gui_handler = world.resources.get_mut::<GuiHandler>();
 
-            let abilities = entity.get_component::<AbilitySlots<A>>()?;
+        self.update_crafting_count(gui_handler, "common", crafting.count(Rarities::Common))?;
+        self.update_crafting_count(gui_handler, "uncommon", crafting.count(Rarities::Uncommon))?;
+        self.update_crafting_count(gui_handler, "magical", crafting.count(Rarities::Magical))?;
+        self.update_crafting_count(gui_handler, "rare", crafting.count(Rarities::Rare))?;
+        self.update_crafting_count(gui_handler, "epic", crafting.count(Rarities::Epic))?;
+        self.update_crafting_count(
+            gui_handler,
+            "legendary",
+            crafting.count(Rarities::Legendary),
+        )?;
 
-            for (index, name) in Self::ABILITY_BUTTON_NAMES.iter().enumerate() {
-                self.update_ability_icon(name, abilities.book(index).map(|book| book.icon()))?;
-            }
+        let abilities = entity.get_component::<AbilitySlots<A>>()?;
 
-            self.update_active_ability(engine, abilities)?;
+        for (index, name) in Self::ABILITY_BUTTON_NAMES.iter().enumerate() {
+            self.update_ability_icon(
+                gui_handler,
+                name,
+                abilities.book(index).map(|book| book.icon()),
+            )?;
+        }
 
-            Ok(())
-        })
+        self.update_active_ability(world, abilities)?;
+
+        Ok(())
     }
 
     fn base(&self) -> &Arc<GuiSnippet> {
diff --git a/character_window/src/abilities/content.rs b/character_window/src/abilities/content.rs
index e2ef6f7..a9413f3 100644
--- a/character_window/src/abilities/content.rs
+++ b/character_window/src/abilities/content.rs
@@ -9,79 +9,74 @@ use rpg_components::items::ability_book::AbilityBook;
 use crate::*;
 
 use crate::{
-    content::{Content, ContentUpdate},
     CharacterWindow,
+    content::{Content, ContentUpdate},
 };
 
 use super::AbilityPage;
 
 impl<A: Ability + 'static> Content<A, AbilityAddon> {
     fn show_addon_tooltip(
-        engine: &Arc<Engine>,
+        world: &mut World,
         hero: Entity,
         addon_index: usize,
         reference: &Weak<CharacterWindow>,
         (x, y, w, _h): (i32, i32, u32, u32),
     ) -> Result<()> {
-        engine.on_scene(|scene| {
-            let entity = scene.entity(hero)?;
-            let inventory = entity.get_component::<Inventory<A>>()?;
+        let entity = unsafe { remove_life_time(world.entity(hero)?) };
+        let inventory = entity.get_component::<Inventory<A>>()?;
 
-            let target_x = x + w as i32;
-            let target_y = y;
+        let target_x = x + w as i32;
+        let target_y = y;
 
-            let addon = inventory.addon_at(addon_index);
-            let gui = addon.create_tooltip(engine.gui_handler(), (target_x, target_y))?;
-            gui.enable()?;
-            gui.perform_single_check(x, y)?;
+        let addon = inventory.addon_at(addon_index);
+        let gui = addon.create_tooltip(world, (target_x, target_y))?;
+        gui.enable(world)?;
+        gui.perform_single_check(world.resources.get_mut::<GuiHandler>(), x, y)?;
 
-            let window = reference.upgrade().unwrap();
-            window.add_tooltip(format!("addon_{addon_index}"), gui);
+        let window = reference.upgrade().unwrap();
+        window.add_tooltip(format!("addon_{addon_index}"), gui);
 
-            Ok(())
-        })
+        Ok(())
     }
 
     fn insert_addon(
-        engine: &Arc<Engine>,
+        world: &mut World,
         hero: Entity,
         addon_index: usize,
         ability_page: &AbilityPage<A>,
     ) -> Result<()> {
-        engine.on_scene_mut(|scene| {
-            let entity = scene.entity_mut(hero)?;
-            let mut multi_mut = entity.multi_mut();
+        let entity = world.entity_mut(hero)?;
+        let mut multi_mut = entity.multi_mut();
 
-            let inventory = multi_mut.get::<Inventory<A>>()?;
-            let abilities = multi_mut.get::<AbilitySlots<A>>()?;
+        let inventory = multi_mut.get::<Inventory<A>>()?;
+        let abilities = multi_mut.get::<AbilitySlots<A>>()?;
 
-            if let Some(book) = abilities.book_mut(ability_page.right_side.selected_ability()) {
-                if book.has_free_addon_slots() {
-                    book.addons_mut()
-                        .insert_addon(inventory.remove_addon(addon_index));
-                }
+        if let Some(book) = abilities.book_mut(ability_page.right_side.selected_ability()) {
+            if book.has_free_addon_slots() {
+                book.addons_mut()
+                    .insert_addon(inventory.remove_addon(addon_index));
             }
+        }
 
-            Ok(())
-        })
+        Ok(())
     }
 }
 
 impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityAddon> {
-    fn update(&mut self, engine: &Arc<Engine>, hero: Entity) -> Result<()> {
+    fn update(&mut self, world: &mut World, hero: Entity) -> Result<()> {
         let reference = self.reference.clone();
 
-        self.update_base(engine, |button, t, index| {
-            button.set_icon(&t.icon())?;
+        self.update_base(world, |world, button, t, index| {
+            button.set_icon(world.resources.get_mut::<GuiHandler>(), &t.icon())?;
 
             button.set_custom_callback({
-                let engine = engine.clone();
                 let reference = reference.clone();
 
-                move |controller_button| {
+                move |world, controller_button| {
                     if let ControllerButton::X = controller_button {
                         CharacterWindow::salvage_from_inventory::<A, _, _>(
-                            &engine,
+                            world,
                             hero,
                             |inventory| inventory.remove_addon(index),
                         )?;
@@ -90,7 +85,7 @@ impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityAddon> {
                             let mut tabs = menu.tabs_mut();
                             let abilities = tabs.abilities::<A>();
 
-                            abilities.update_page()?;
+                            abilities.update_page(world)?;
                         }
 
                         return Ok(true);
@@ -101,17 +96,16 @@ impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityAddon> {
             });
 
             button.set_callback({
-                let engine = engine.clone();
                 let reference = reference.clone();
 
-                move || {
+                move |world| {
                     if let Some(menu) = reference.upgrade() {
                         let mut tabs = menu.tabs_mut();
                         let abilities = tabs.abilities();
 
-                        Self::insert_addon(&engine, hero, index, abilities)?;
+                        Self::insert_addon(world, hero, index, abilities)?;
 
-                        abilities.update_page()?;
+                        abilities.update_page(world)?;
                     }
 
                     Ok(())
@@ -120,14 +114,13 @@ impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityAddon> {
 
             button.set_select_callback({
                 let weak_button = Arc::downgrade(&button);
-                let engine = engine.clone();
                 let reference = reference.clone();
 
-                move |selected| {
+                move |world, selected| {
                     if selected {
                         let button_pos = weak_button.upgrade().unwrap().position_extent();
 
-                        Self::show_addon_tooltip(&engine, hero, index, &reference, button_pos)?;
+                        Self::show_addon_tooltip(world, hero, index, &reference, button_pos)?;
                     } else {
                         let window = reference.upgrade().unwrap();
 
@@ -142,103 +135,99 @@ impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityAddon> {
         })
     }
 
-    fn select(&self) -> Result<()> {
-        self.select()
+    fn select(&self, world: &mut World) -> Result<()> {
+        self.select(world.resources.get_mut::<GuiHandler>())
     }
 }
 
 impl<A: Ability + 'static> Content<A, AbilityBook<A>> {
     fn equip_book(
-        engine: &Arc<Engine>,
+        world: &mut World,
         hero: Entity,
         book_index: usize,
         ability_page: &AbilityPage<A>,
     ) -> Result<()> {
-        engine.on_scene_mut(|scene| {
-            let entity = scene.entity_mut(hero)?;
-            let mut multi_mut = entity.multi_mut();
+        let entity = world.entity_mut(hero)?;
+        let mut multi_mut = entity.multi_mut();
 
-            let inventory = multi_mut.get::<Inventory<A>>()?;
-            let abilitiy_slots = multi_mut.get::<AbilitySlots<A>>()?;
+        let inventory = multi_mut.get::<Inventory<A>>()?;
+        let abilitiy_slots = multi_mut.get::<AbilitySlots<A>>()?;
 
-            if let Some(old_book) = abilitiy_slots.insert_book(
-                inventory.remove_book(book_index),
-                ability_page.right_side.selected_ability(),
-            ) {
-                inventory.insert_book(old_book, book_index);
-            }
+        if let Some(old_book) = abilitiy_slots.insert_book(
+            inventory.remove_book(book_index),
+            ability_page.right_side.selected_ability(),
+        ) {
+            inventory.insert_book(old_book, book_index);
+        }
 
-            Ok(())
-        })
+        Ok(())
     }
 
     fn show_book_tooltip(
-        engine: &Arc<Engine>,
+        world: &mut World,
         hero: Entity,
         book_index: usize,
         reference: &Weak<CharacterWindow>,
         (x, y, w, _h): (i32, i32, u32, u32),
     ) -> Result<()> {
-        engine.on_scene(|scene| {
-            let entity = scene.entity(hero)?;
-            let inventory = entity.get_component::<Inventory<A>>()?;
-            let statistics = entity.get_component::<Statistics>()?;
+        let entity = unsafe { remove_life_time(world.entity(hero)?) };
+        let inventory = entity.get_component::<Inventory<A>>()?;
+        let statistics = entity.get_component::<Statistics>()?;
 
-            let target_x = x + w as i32;
-            let target_y = y;
+        let target_x = x + w as i32;
+        let target_y = y;
 
-            let book = inventory.book_at(book_index);
-            let gui =
-                book.create_tooltip(engine.gui_handler(), statistics, (target_x, target_y))?;
-            gui.enable()?;
+        let book = inventory.book_at(book_index);
+        let gui = book.create_tooltip(world, statistics, (target_x, target_y))?;
+        gui.enable(world)?;
 
-            let window = reference.upgrade().unwrap();
-            let abilities = entity.get_component::<AbilitySlots<A>>()?;
+        let window = reference.upgrade().unwrap();
+        let abilities = entity.get_component::<AbilitySlots<A>>()?;
 
-            match abilities.book(window.tabs().abilities::<A>().right_side.selected_ability()) {
-                Some(selected_book) => {
-                    let button_pos = gui.position_extent();
+        match abilities.book(window.tabs().abilities::<A>().right_side.selected_ability()) {
+            Some(selected_book) => {
+                let button_pos = gui.position_extent();
 
-                    let target_x = button_pos.0 + button_pos.2 as i32 + 2;
-                    let target_y = button_pos.1;
+                let target_x = button_pos.0 + button_pos.2 as i32 + 2;
+                let target_y = button_pos.1;
 
-                    let compare_gui = selected_book.create_tooltip(
-                        engine.gui_handler(),
-                        statistics,
-                        (target_x, target_y),
-                    )?;
-                    compare_gui.enable()?;
-                    gui.perform_double_check(&compare_gui, x, 2)?;
+                let compare_gui =
+                    selected_book.create_tooltip(world, statistics, (target_x, target_y))?;
+                compare_gui.enable(world)?;
+                gui.perform_double_check(
+                    &compare_gui,
+                    world.resources.get_mut::<GuiHandler>(),
+                    x,
+                    2,
+                )?;
 
-                    window.add_tooltip("active_book", compare_gui);
-                }
-                None => {
-                    gui.perform_single_check(x, y)?;
-                }
+                window.add_tooltip("active_book", compare_gui);
             }
+            None => {
+                gui.perform_single_check(world.resources.get_mut::<GuiHandler>(), x, y)?;
+            }
+        }
 
-            window.add_tooltip(format!("book_{book_index}"), gui);
+        window.add_tooltip(format!("book_{book_index}"), gui);
 
-            Ok(())
-        })
+        Ok(())
     }
 }
 
 impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityBook<A>> {
-    fn update(&mut self, engine: &Arc<Engine>, hero: Entity) -> Result<()> {
+    fn update(&mut self, world: &mut World, hero: Entity) -> Result<()> {
         let reference = self.reference.clone();
 
-        self.update_base(engine, |button, t, index| {
-            button.set_icon(&t.icon())?;
+        self.update_base(world, |world, button, t, index| {
+            button.set_icon(world.resources.get_mut::<GuiHandler>(), &t.icon())?;
 
             button.set_custom_callback({
-                let engine = engine.clone();
                 let reference = reference.clone();
 
-                move |controller_button| {
+                move |world, controller_button| {
                     if let ControllerButton::X = controller_button {
                         CharacterWindow::salvage_from_inventory::<A, _, _>(
-                            &engine,
+                            world,
                             hero,
                             |inventory| inventory.remove_book(index),
                         )?;
@@ -247,7 +236,7 @@ impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityBook<A>> {
                             let mut tabs = menu.tabs_mut();
                             let abilities = tabs.abilities::<A>();
 
-                            abilities.update_page()?;
+                            abilities.update_page(world)?;
                         }
 
                         return Ok(true);
@@ -258,17 +247,16 @@ impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityBook<A>> {
             });
 
             button.set_callback({
-                let engine = engine.clone();
                 let reference = reference.clone();
 
-                move || {
+                move |world| {
                     if let Some(menu) = reference.upgrade() {
                         let mut tabs = menu.tabs_mut();
                         let abilities = tabs.abilities();
 
-                        Self::equip_book(&engine, hero, index, abilities)?;
+                        Self::equip_book(world, hero, index, abilities)?;
 
-                        abilities.update_page()?;
+                        abilities.update_page(world)?;
                     }
 
                     Ok(())
@@ -277,14 +265,13 @@ impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityBook<A>> {
 
             button.set_select_callback({
                 let weak_button = Arc::downgrade(&button);
-                let engine = engine.clone();
                 let reference = reference.clone();
 
-                move |selected| {
+                move |world, selected| {
                     if selected {
                         let button_pos = weak_button.upgrade().unwrap().position_extent();
 
-                        Self::show_book_tooltip(&engine, hero, index, &reference, button_pos)?;
+                        Self::show_book_tooltip(world, hero, index, &reference, button_pos)?;
                     } else {
                         let window = reference.upgrade().unwrap();
 
@@ -300,7 +287,7 @@ impl<A: Ability + 'static> ContentUpdate for Content<A, AbilityBook<A>> {
         })
     }
 
-    fn select(&self) -> Result<()> {
-        self.select()
+    fn select(&self, world: &mut World) -> Result<()> {
+        self.select(world.resources.get_mut::<GuiHandler>())
     }
 }
diff --git a/character_window/src/abilities/mod.rs b/character_window/src/abilities/mod.rs
index ebcd10e..999e819 100644
--- a/character_window/src/abilities/mod.rs
+++ b/character_window/src/abilities/mod.rs
@@ -19,7 +19,6 @@ use crate::*;
 pub struct AbilityPage<A: Ability + 'static> {
     close: Weak<Button>,
 
-    engine: Arc<Engine>,
     hero: Entity,
 
     grid: Arc<Grid>,
@@ -41,14 +40,15 @@ impl<A: Ability + 'static> AbilityPage<A> {
         reference: Weak<CharacterWindow>,
         close: &Arc<Button>,
     ) -> Result<Self> {
-        let gui_handler = world.resources.get_mut::<GuiHandler>();
+        let gui_handler = world.resources.get_mut_unchecked::<GuiHandler>();
         let grid = Grid::new(gui_handler, 2, 1, false)?;
 
         let left_base = GuiSnippet::from_str(
-            gui_handler,
+            world,
             include_str!("../../resources/abilities/left_side.xml"),
         )?;
-        grid.attach(gui_handler, left_base.clone(), 0, 0, 1, 1)?;
+
+        grid.attach(world, left_base.clone(), 0, 0, 1, 1)?;
 
         Self::setup_content_switch(&left_base, reference.clone())?;
 
@@ -57,42 +57,52 @@ impl<A: Ability + 'static> AbilityPage<A> {
 
         // abilities
         let ability_mode = PageContent::new(
-            Content::new::<_, Self>(&engine, reference.clone(), {
-                let engine = engine.clone();
+            Content::new::<_, Self>(world, reference.clone(), {
                 let hero = hero.clone();
 
-                move || {
-                    let mut data = Vec::new();
+                move |world| {
+                    let hero_object = world.entity(hero)?;
+                    let inventory = hero_object.get_component::<Inventory<A>>()?;
 
-                    engine.on_scene(|scene| {
-                        let hero_object = scene.entity(hero)?;
-                        let inventory = hero_object.get_component::<Inventory<A>>()?;
-
-                        data = inventory.iter_books().cloned().collect();
-
-                        Ok(())
-                    })?;
+                    let data = inventory.iter_books().cloned().collect();
 
                     Ok(data)
                 }
             })?,
             {
                 let ui = GuiSnippet::from_str(
-                    engine.gui_handler(),
+                    world,
                     include_str!("../../resources/abilities/ability_tooltip.xml"),
                 )?;
 
+                let mut resources = world.resources.multi_mut();
+                let gui_handler = resources.get::<GuiHandler>();
+                let engine_settings = resources.get::<EngineSettings>();
+                let context = resources.get::<Context>();
+
                 let equip: Arc<Label> = ui.element("equip")?;
-                equip.set_info_icon(&engine.controller_icon(ControllerButton::A)?)?;
+                equip.set_info_icon(
+                    gui_handler,
+                    &engine_settings.controller_icon(context, ControllerButton::A)?,
+                )?;
 
                 let upgrade: Arc<Label> = ui.element("upgrade")?;
-                upgrade.set_info_icon(&engine.controller_icon(ControllerButton::Y)?)?;
+                upgrade.set_info_icon(
+                    gui_handler,
+                    &engine_settings.controller_icon(context, ControllerButton::Y)?,
+                )?;
 
                 let salvage: Arc<Label> = ui.element("salvage")?;
-                salvage.set_info_icon(&engine.controller_icon(ControllerButton::X)?)?;
+                salvage.set_info_icon(
+                    gui_handler,
+                    &engine_settings.controller_icon(context, ControllerButton::X)?,
+                )?;
 
                 let switch_mode: Arc<Label> = ui.element("switch_mode")?;
-                switch_mode.set_info_icon(&engine.controller_icon(ControllerButton::LeftStick)?)?;
+                switch_mode.set_info_icon(
+                    gui_handler,
+                    &engine_settings.controller_icon(context, ControllerButton::LeftStick)?,
+                )?;
 
                 ui
             },
@@ -101,51 +111,57 @@ impl<A: Ability + 'static> AbilityPage<A> {
 
         // addons
         let addons_mode = PageContent::<A, _>::new(
-            Content::new::<_, Self>(&engine, reference.clone(), {
-                let engine = engine.clone();
+            Content::new::<_, Self>(world, reference.clone(), {
                 let hero = hero.clone();
 
-                move || {
-                    let mut data = Vec::new();
+                move |world| {
+                    let hero_object = world.entity(hero)?;
+                    let inventory = hero_object.get_component::<Inventory<A>>()?;
 
-                    engine.on_scene(|scene| {
-                        let hero_object = scene.entity(hero)?;
-                        let inventory = hero_object.get_component::<Inventory<A>>()?;
-
-                        data = inventory.iter_addons().cloned().collect();
-
-                        Ok(())
-                    })?;
+                    let data = inventory.iter_addons().cloned().collect();
 
                     Ok(data)
                 }
             })?,
             {
                 let ui = GuiSnippet::from_str(
-                    engine.gui_handler(),
+                    world,
                     include_str!("../../resources/abilities/addon_tooltip.xml"),
                 )?;
 
+                let mut resources = world.resources.multi_mut();
+                let gui_handler = resources.get::<GuiHandler>();
+                let engine_settings = resources.get::<EngineSettings>();
+                let context = resources.get::<Context>();
+
                 let equip: Arc<Label> = ui.element("socket")?;
-                equip.set_info_icon(&engine.controller_icon(ControllerButton::A)?)?;
+                equip.set_info_icon(
+                    gui_handler,
+                    &engine_settings.controller_icon(context, ControllerButton::A)?,
+                )?;
 
                 let salvage: Arc<Label> = ui.element("salvage")?;
-                salvage.set_info_icon(&engine.controller_icon(ControllerButton::X)?)?;
+                salvage.set_info_icon(
+                    gui_handler,
+                    &engine_settings.controller_icon(context, ControllerButton::X)?,
+                )?;
 
                 let switch_mode: Arc<Label> = ui.element("switch_mode")?;
-                switch_mode.set_info_icon(&engine.controller_icon(ControllerButton::LeftStick)?)?;
+                switch_mode.set_info_icon(
+                    gui_handler,
+                    &engine_settings.controller_icon(context, ControllerButton::LeftStick)?,
+                )?;
 
                 ui
             },
             EmptyRightSide,
         );
 
-        let right_side = AbilityPageRightSide::new(&engine, &reference, hero)?;
+        let right_side = AbilityPageRightSide::new(world, hero, &reference)?;
 
         Ok(Self {
             close: Arc::downgrade(close),
 
-            engine: engine.clone(),
             hero,
 
             grid,
@@ -161,7 +177,7 @@ impl<A: Ability + 'static> AbilityPage<A> {
         })
     }
 
-    fn update_page(&mut self) -> Result<()> {
+    fn update_page(&mut self, world: &mut World) -> Result<()> {
         match self.current_mode {
             0 => println!("update ability view"),
             1 => println!("update addon view"),
@@ -170,15 +186,16 @@ impl<A: Ability + 'static> AbilityPage<A> {
         }
 
         let mode = &mut self.modes[self.current_mode];
-        mode.content_mut().update(&self.engine, self.hero)?;
+        mode.content_mut().update(world, self.hero)?;
 
-        self.tooltip.attach(mode.tooltip().clone(), 0, 0, 1, 1)?;
+        self.tooltip
+            .attach(world, mode.tooltip().clone(), 0, 0, 1, 1)?;
         self.content
-            .attach(mode.content_mut().base().clone(), 0, 0, 1, 1)?;
+            .attach(world, mode.content_mut().base().clone(), 0, 0, 1, 1)?;
 
-        self.right_side.refresh(&self.engine, self.hero)?;
+        self.right_side.refresh(world, self.hero)?;
         self.grid
-            .attach(self.right_side.base().clone(), 1, 0, 1, 1)?;
+            .attach(world, self.right_side.base().clone(), 1, 0, 1, 1)?;
 
         Ok(())
     }
@@ -190,14 +207,14 @@ impl<A: Ability + 'static> AbilityPage<A> {
         let switch = {
             let reference = reference.clone();
 
-            move |index| {
+            move |world: &mut World, index| {
                 if let Some(menu) = reference.upgrade() {
                     let mut tabs = menu.tabs_mut();
                     let me = tabs.abilities::<A>();
 
                     if me.current_mode != index {
                         me.current_mode = index;
-                        me.update_page()?;
+                        me.update_page(world)?;
                     }
                 }
 
@@ -208,13 +225,13 @@ impl<A: Ability + 'static> AbilityPage<A> {
         let switch_to_abilities = Box::new({
             let switch = switch.clone();
 
-            move || switch(0)
+            move |world: &mut World| switch(world, 0)
         });
 
         let switch_to_addons = Box::new({
             let switch = switch.clone();
 
-            move || switch(1)
+            move |world: &mut World| switch(world, 1)
         });
 
         left_base.set_click_callbacks(vec![
@@ -229,26 +246,26 @@ impl<A: Ability + 'static> Page for AbilityPage<A> {
         println!("enable AbilityPage");
 
         for mode in self.modes.iter_mut() {
-            mode.content_mut().refresh()?;
+            mode.content_mut().refresh(world)?;
         }
 
-        self.update_page()?;
+        self.update_page(world)?;
 
         Ok(self.grid.clone())
     }
 
-    fn disable(&mut self, world: &mut World) -> Result<()> {
+    fn disable(&mut self, _world: &mut World) -> Result<()> {
         Ok(())
     }
 
     fn select(&self, world: &mut World) -> Result<()> {
         let mode = &self.modes[self.current_mode];
 
-        mode.content().select()?;
+        mode.content().select(world)?;
 
         if mode.content().is_empty() {
             if let Some(close) = self.close.upgrade() {
-                close.select()?;
+                close.select(world.resources.get_mut::<GuiHandler>())?;
             }
         }
 
@@ -258,26 +275,26 @@ impl<A: Ability + 'static> Page for AbilityPage<A> {
     fn next_tab(&mut self, world: &mut World) -> Result<()> {
         self.modes[self.current_mode]
             .content_mut()
-            .next_tab(&self.engine, self.hero)
+            .next_tab(world, self.hero)
     }
 
     fn previous_tab(&mut self, world: &mut World) -> Result<()> {
         self.modes[self.current_mode]
             .content_mut()
-            .previous_tab(&self.engine, self.hero)
+            .previous_tab(world, self.hero)
     }
 
     fn event(&mut self, world: &mut World, button: ControllerButton) -> Result<bool> {
         Ok(match button {
             ControllerButton::LeftStick => {
                 self.current_mode = (self.current_mode + 1) % self.modes.len();
-                self.update_page()?;
-                self.select()?;
+                self.update_page(world)?;
+                self.select(world)?;
                 true
             }
 
             ControllerButton::RightStick => {
-                self.right_side.next_ability(&self.engine, self.hero)?;
+                self.right_side.next_ability(world, self.hero)?;
                 true
             }
 
diff --git a/character_window/src/character/mod.rs b/character_window/src/character/mod.rs
index 0c80bb9..fa1d58d 100644
--- a/character_window/src/character/mod.rs
+++ b/character_window/src/character/mod.rs
@@ -28,23 +28,23 @@ impl CharacterPage {
         hero_name: &str,
         reference: &Weak<CharacterWindow>,
     ) -> Result<Self> {
-        let gui_handler = world.resources.get_mut::<GuiHandler>();
         let snippet = GuiSnippet::from_str(
-            gui_handler,
+            world,
             include_str!("../../resources/character/statistics.xml"),
         )?;
 
         let grid: Arc<Grid> = snippet.element("statistic_tab")?;
-
         let name: Arc<Label> = snippet.element("character_name")?;
+
+        let gui_handler = world.resources.get_mut::<GuiHandler>();
         name.set_text(gui_handler, hero_name)?;
 
         let strength: Arc<Button> = snippet.element("strength_field")?;
         strength.set_callback({
-            let update_stats = Self::create_update_stats(hero, engine, reference);
+            let update_stats = Self::create_update_stats(hero, reference.clone());
 
-            move |_world| {
-                update_stats(|attributes| {
+            move |world| {
+                update_stats(world, |attributes: &mut Attributes| {
                     attributes.add_strength(Strength::from(1));
                 })
             }
@@ -52,10 +52,10 @@ impl CharacterPage {
 
         let agility: Arc<Button> = snippet.element("agility_field")?;
         agility.set_callback({
-            let update_stats = Self::create_update_stats(hero, engine, reference);
+            let update_stats = Self::create_update_stats(hero, reference.clone());
 
-            move |_world| {
-                update_stats(|attributes| {
+            move |world| {
+                update_stats(world, |attributes: &mut Attributes| {
                     attributes.add_agility(Agility::from(1));
                 })
             }
@@ -63,10 +63,10 @@ impl CharacterPage {
 
         let intelligence: Arc<Button> = snippet.element("intelligence_field")?;
         intelligence.set_callback({
-            let update_stats = Self::create_update_stats(hero, engine, reference);
+            let update_stats = Self::create_update_stats(hero, reference.clone());
 
-            move |_world| {
-                update_stats(|attributes| {
+            move |world| {
+                update_stats(world, |attributes: &mut Attributes| {
                     attributes.add_intelligence(Intelligence::from(1));
                 })
             }
@@ -106,10 +106,10 @@ impl CharacterPage {
         let mana: Arc<Label> = self.snippet.element("mana_info")?;
         let mana_regen: Arc<Label> = self.snippet.element("mana_regen_info")?;
 
-        let entity = world.entity(self.hero)?;
+        let (entity, resources) = world.entity_resources(self.hero)?;
         let statistics = entity.get_component::<Statistics>()?;
 
-        let gui_handler = world.resources.get_mut::<GuiHandler>();
+        let gui_handler = resources.get_mut::<GuiHandler>();
 
         air_def.set_text(gui_handler, &format!("{}", statistics.air_resistance.raw()))?;
         fire_def.set_text(
@@ -153,7 +153,7 @@ impl CharacterPage {
         Ok(())
     }
 
-    fn update_attributes(&self, world: &World) -> Result<()> {
+    fn update_attributes(&self, world: &mut World) -> Result<()> {
         let level_label: Arc<Label> = self.snippet.element("level")?;
         let level_progress: Arc<ProgressBar> = self.snippet.element("level_progress")?;
 
@@ -162,12 +162,13 @@ impl CharacterPage {
         let agility: Arc<Button> = self.snippet.element("agility_field")?;
         let intelligence: Arc<Button> = self.snippet.element("intelligence_field")?;
 
-        let entity = world.entity(self.hero)?;
+        let (entity, resources) = world.entity_resources(self.hero)?;
+        let mut resources = resources.multi_mut();
 
         let level = entity.get_component::<Level>()?;
         let attributes = entity.get_component::<Attributes>()?;
 
-        let gui_handler = world.resources.get_mut::<GuiHandler>();
+        let gui_handler = resources.get::<GuiHandler>();
 
         level_label.set_text(gui_handler, format!("Level: {}", level.level()))?;
         level_progress.set_text(
@@ -180,7 +181,7 @@ impl CharacterPage {
             format!(
                 "Attributes ({})",
                 Self::available_attribute_points(
-                    world.resources.get::<AttributeSettings>(),
+                    resources.get::<AttributeSettings>(),
                     attributes,
                     level
                 )
@@ -210,17 +211,15 @@ impl CharacterPage {
 
     fn create_update_stats<F>(
         hero: Entity,
-        reference: &Weak<CharacterWindow>,
+        reference: Weak<CharacterWindow>,
     ) -> impl Fn(&mut World, F) -> Result<()> + Clone
     where
         F: Fn(&mut Attributes),
     {
-        let reference = reference.clone();
-
         move |world, upgrade: F| {
             let mut upgraded = false;
 
-            let (resources, entity) = world.entity_resource(hero)?;
+            let (entity, resources) = world.entity_resources(hero)?;
             let mut multi_mut = entity.multi_mut();
 
             let attribute_settings = resources.get::<AttributeSettings>();
@@ -255,31 +254,31 @@ impl Page for CharacterPage {
     fn enable(&mut self, world: &mut World) -> Result<Arc<Grid>> {
         println!("enable CharacterPage");
 
-        self.refresh()?;
+        self.refresh(world)?;
 
         Ok(self.grid.clone())
     }
 
-    fn disable(&mut self, world: &mut World) -> Result<()> {
+    fn disable(&mut self, _world: &mut World) -> Result<()> {
         Ok(())
     }
 
     fn select(&self, world: &mut World) -> Result<()> {
         let strength: Arc<Button> = self.snippet.element("strength_field")?;
-        strength.select()?;
+        strength.select(world.resources.get_mut::<GuiHandler>())?;
 
         Ok(())
     }
 
-    fn next_tab(&mut self, world: &mut World) -> Result<()> {
+    fn next_tab(&mut self, _world: &mut World) -> Result<()> {
         Ok(())
     }
 
-    fn previous_tab(&mut self, world: &mut World) -> Result<()> {
+    fn previous_tab(&mut self, _world: &mut World) -> Result<()> {
         Ok(())
     }
 
-    fn event(&mut self, world: &mut World, _button: ControllerButton) -> Result<bool> {
+    fn event(&mut self, _world: &mut World, _button: ControllerButton) -> Result<bool> {
         Ok(false)
     }
 }
diff --git a/character_window/src/inventory/content.rs b/character_window/src/inventory/content.rs
index c49c57a..db70923 100644
--- a/character_window/src/inventory/content.rs
+++ b/character_window/src/inventory/content.rs
@@ -242,18 +242,15 @@ impl<A: Ability + 'static> Content<A, Jewel> {
         reference: &Weak<CharacterWindow>,
         (x, y, w, _h): (i32, i32, u32, u32),
     ) -> Result<()> {
-        let entity = world.entity(hero)?;
+        let entity = unsafe { remove_life_time(world.entity(hero)?) };
         let inventory = entity.get_component::<Inventory<A>>()?;
 
         let target_x = x + w as i32;
         let target_y = y;
 
+        let item_settings = world.resources.get_unchecked::<ItemSettings>();
         let jewel = inventory.jewel_at(item_index);
-        let gui = jewel.create_tooltip(
-            world,
-            world.resources.get::<ItemSettings>(),
-            (target_x, target_y),
-        )?;
+        let gui = jewel.create_tooltip(world, item_settings, (target_x, target_y))?;
         gui.enable(world)?;
 
         gui.perform_single_check(world.resources.get_mut::<GuiHandler>(), x, y)?;
diff --git a/character_window/src/inventory/jewel_right_side.rs b/character_window/src/inventory/jewel_right_side.rs
index 7263dca..2a946e9 100644
--- a/character_window/src/inventory/jewel_right_side.rs
+++ b/character_window/src/inventory/jewel_right_side.rs
@@ -93,20 +93,21 @@ impl JewelRightSide {
 
                     let (x, y, w, _h) = button.position_extent();
 
-                    let reference_info = world.resources.get::<Option<ReferenceObject>>();
+                    let reference_info = world.resources.get_unchecked::<Option<ReferenceObject>>();
 
                     if let Some(reference_info) = reference_info {
                         let tooltip = match reference_info {
-                            ReferenceObject::Item { item, .. } => item.create_tooltip(
-                                world,
-                                world.entity(hero)?.get_component::<Attributes>()?,
-                                (x + w as i32, y),
-                            )?,
-                            ReferenceObject::Jewel { jewel, .. } => jewel.create_tooltip(
-                                world,
-                                world.resources.get::<ItemSettings>(),
-                                (x + w as i32, y),
-                            )?,
+                            ReferenceObject::Item { item, .. } => {
+                                let attributes = unsafe { remove_life_time(world.entity(hero)?) }
+                                    .get_component::<Attributes>()?;
+
+                                item.create_tooltip(world, attributes, (x + w as i32, y))?
+                            }
+                            ReferenceObject::Jewel { jewel, .. } => {
+                                let item_settings = world.resources.get_unchecked::<ItemSettings>();
+
+                                jewel.create_tooltip(world, item_settings, (x + w as i32, y))?
+                            }
                         };
 
                         tooltip.enable(world)?;
@@ -141,12 +142,14 @@ impl JewelRightSide {
 
                         let (x, y, w, _h) = button.position_extent();
 
-                        let lower_info = world.resources.get::<LowerJewels>();
+                        let lower_info = world.resources.get_unchecked::<LowerJewels>();
 
                         if let Some((lower_jewel, _)) = &lower_info.jewels[index] {
+                            let item_settings = world.resources.get_unchecked::<ItemSettings>();
+
                             let tooltip = lower_jewel.create_tooltip(
                                 world,
-                                world.resources.get::<ItemSettings>(),
+                                item_settings,
                                 (x + w as i32, y),
                             )?;
 
diff --git a/character_window/src/lib.rs b/character_window/src/lib.rs
index 50a226c..e3fc7b8 100644
--- a/character_window/src/lib.rs
+++ b/character_window/src/lib.rs
@@ -165,8 +165,8 @@ impl CharacterWindow {
                 if let Some(me) = weak_me.upgrade() {
                     me.tab.store(index, SeqCst);
 
-                    me.tab_content_grid
-                        .attach(world, me.tab_mut().enable(world)?, 0, 0, 1, 1)?;
+                    let child = me.tab_mut().enable(world)?;
+                    me.tab_content_grid.attach(world, child, 0, 0, 1, 1)?;
                     me.tab().select(world)?;
                 }
 
@@ -279,8 +279,8 @@ impl TopLevelGui for CharacterWindow {
     fn enable(&self, world: &mut World) -> Result<()> {
         self.menu_gui.enable(world)?;
 
-        self.tab_content_grid
-            .attach(world, self.tab_mut().enable(world)?, 0, 0, 1, 1)?;
+        let child = self.tab_mut().enable(world)?;
+        self.tab_content_grid.attach(world, child, 0, 0, 1, 1)?;
         self.tab().select(world)?;
 
         let mut resources = world.resources.multi_mut();
@@ -345,8 +345,8 @@ impl TopGui for CharacterWindow {
                 self.tab.store((self.tab.load(SeqCst) + 1) % 3, SeqCst);
 
                 // update tab content
-                self.tab_content_grid
-                    .attach(world, self.tab_mut().enable(world)?, 0, 0, 1, 1)?;
+                let child = self.tab_mut().enable(world)?;
+                self.tab_content_grid.attach(world, child, 0, 0, 1, 1)?;
                 self.tab().select(world)?;
             }
             true => {
@@ -371,8 +371,8 @@ impl TopGui for CharacterWindow {
                 }
 
                 // update tab content
-                self.tab_content_grid
-                    .attach(world, self.tab_mut().enable(world)?, 0, 0, 1, 1)?;
+                let child = self.tab_mut().enable(world)?;
+                self.tab_content_grid.attach(world, child, 0, 0, 1, 1)?;
                 self.tab().select(world)?;
             }
             true => {