diff --git a/src/graphics/renderers/deferred/mod.rs b/src/graphics/renderers/deferred/mod.rs
index cbe7b9a67..dcc46f312 100644
--- a/src/graphics/renderers/deferred/mod.rs
+++ b/src/graphics/renderers/deferred/mod.rs
@@ -243,7 +243,7 @@ impl DeferredRenderer {
         }
     }
 
-    #[profile("recreate deferred pipeline")]
+    #[profile("re-create deferred pipeline")]
     pub fn recreate_pipeline(&mut self, viewport: Viewport, dimensions: [u32; 2], #[cfg(feature = "debug")] wireframe: bool) {
         let device = self.memory_allocator.device().clone();
         let geometry_subpass = Subpass::from(self.render_pass.clone(), 0).unwrap();
diff --git a/src/graphics/renderers/interface/mod.rs b/src/graphics/renderers/interface/mod.rs
index cb1e28d06..b75f0d369 100644
--- a/src/graphics/renderers/interface/mod.rs
+++ b/src/graphics/renderers/interface/mod.rs
@@ -106,7 +106,7 @@ impl InterfaceRenderer {
         self.font_loader.borrow().get_text_dimensions(text, font_size, available_width)
     }
 
-    #[profile("recreate interface pipeline")]
+    #[profile("re-create interface pipeline")]
     pub fn recreate_pipeline(&mut self, viewport: Viewport, dimensions: [u32; 2]) {
         let device = self.memory_allocator.device().clone();
         let subpass = self.render_pass.clone().first_subpass();
diff --git a/src/graphics/renderers/interface/rectangle/fragment_shader.glsl b/src/graphics/renderers/interface/rectangle/fragment_shader.glsl
index 5eba5480c..aca8fdc9d 100644
--- a/src/graphics/renderers/interface/rectangle/fragment_shader.glsl
+++ b/src/graphics/renderers/interface/rectangle/fragment_shader.glsl
@@ -10,11 +10,16 @@ layout(push_constant) uniform Constants {
     vec4 clip_size;
     vec4 corner_radius;
     vec4 color;
+    float aspect_ratio;
 } constants;
 
 void main() {
 
     vec2 coords = fragment_position * constants.screen_size;
+    vec2 screen_size = constants.screen_size;
+
+    coords.x /= constants.aspect_ratio;
+    screen_size.x /= constants.aspect_ratio;
 
     // top-left
     if (length(coords - constants.corner_radius.x) > constants.corner_radius.x && coords.x < constants.corner_radius.x &&
@@ -23,20 +28,20 @@ void main() {
     }
 
     // top-right
-    if (length(coords - vec2(constants.screen_size.x - constants.corner_radius.y, constants.corner_radius.y)) > constants.corner_radius.y &&
-        constants.screen_size.x - coords.x < constants.corner_radius.y && coords.y < constants.corner_radius.y) {
+    if (length(coords - vec2(screen_size.x - constants.corner_radius.y, constants.corner_radius.y)) > constants.corner_radius.y &&
+        screen_size.x - coords.x < constants.corner_radius.y && coords.y < constants.corner_radius.y) {
         discard;
     }
 
     // bottom-right
-    if (length(coords - constants.screen_size + constants.corner_radius.z) > constants.corner_radius.z &&
-        constants.screen_size.x - coords.x < constants.corner_radius.z && constants.screen_size.y - coords.y < constants.corner_radius.z) {
+    if (length(coords - screen_size + constants.corner_radius.z) > constants.corner_radius.z &&
+        screen_size.x - coords.x < constants.corner_radius.z && screen_size.y - coords.y < constants.corner_radius.z) {
         discard;
     }
 
     // bottom_left
-    if (length(coords - vec2(constants.corner_radius.w, constants.screen_size.y - constants.corner_radius.w)) > constants.corner_radius.w &&
-        coords.x < constants.corner_radius.w && constants.screen_size.y - coords.y < constants.corner_radius.w) {
+    if (length(coords - vec2(constants.corner_radius.w, screen_size.y - constants.corner_radius.w)) > constants.corner_radius.w &&
+        coords.x < constants.corner_radius.w && screen_size.y - coords.y < constants.corner_radius.w) {
         discard;
     }
 
diff --git a/src/graphics/renderers/interface/rectangle/mod.rs b/src/graphics/renderers/interface/rectangle/mod.rs
index 8263ef250..8309e616e 100644
--- a/src/graphics/renderers/interface/rectangle/mod.rs
+++ b/src/graphics/renderers/interface/rectangle/mod.rs
@@ -100,6 +100,7 @@ impl RectangleRenderer {
             clip_size: clip_size.into(),
             corner_radius: corner_radius.into(),
             color: [color.red_f32(), color.green_f32(), color.blue_f32(), color.alpha_f32()],
+            aspect_ratio: window_size.y as f32 / window_size.x as f32,
         };
 
         render_target
diff --git a/src/graphics/renderers/interface/rectangle/vertex_shader.glsl b/src/graphics/renderers/interface/rectangle/vertex_shader.glsl
index f02249803..3ab6e46c0 100644
--- a/src/graphics/renderers/interface/rectangle/vertex_shader.glsl
+++ b/src/graphics/renderers/interface/rectangle/vertex_shader.glsl
@@ -8,6 +8,7 @@ layout(push_constant) uniform Constants {
     vec4 clip_size;
     vec4 corner_radius;
     vec4 color;
+    float aspect_ratio;
 } constants;
 
 const vec2 data[6] = vec2[]
diff --git a/src/graphics/renderers/mod.rs b/src/graphics/renderers/mod.rs
index 203c669cc..4e79d99da 100644
--- a/src/graphics/renderers/mod.rs
+++ b/src/graphics/renderers/mod.rs
@@ -70,7 +70,7 @@ use self::picker::PickerSubrenderer;
 pub use self::picker::{PickerRenderer, PickerTarget};
 #[cfg(feature = "debug")]
 pub use self::settings::RenderSettings;
-pub use self::shadow::ShadowRenderer;
+pub use self::shadow::{ShadowDetail, ShadowRenderer};
 pub use self::swapchain::{PresentModeInfo, SwapchainHolder};
 use super::{Color, MemoryAllocator, ModelVertex};
 #[cfg(feature = "debug")]
diff --git a/src/graphics/renderers/shadow/mod.rs b/src/graphics/renderers/shadow/mod.rs
index 62eccdae5..fad2e4613 100644
--- a/src/graphics/renderers/shadow/mod.rs
+++ b/src/graphics/renderers/shadow/mod.rs
@@ -5,6 +5,7 @@ mod indicator;
 use std::sync::Arc;
 
 use cgmath::{Matrix4, Vector2, Vector3};
+use serde::{Deserialize, Serialize};
 use vulkano::device::{DeviceOwned, Queue};
 use vulkano::format::{ClearValue, Format};
 use vulkano::image::{ImageUsage, SampleCount};
@@ -20,6 +21,25 @@ use crate::graphics::{
 use crate::loaders::{GameFileLoader, TextureLoader};
 use crate::network::EntityId;
 
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+pub enum ShadowDetail {
+    Low,
+    Medium,
+    High,
+    Ultra,
+}
+
+impl ShadowDetail {
+    pub fn into_resolution(self) -> u32 {
+        match self {
+            ShadowDetail::Low => 512,
+            ShadowDetail::Medium => 1024,
+            ShadowDetail::High => 2048,
+            ShadowDetail::Ultra => 8192,
+        }
+    }
+}
+
 #[derive(PartialEq, Eq)]
 pub enum ShadowSubrenderer {
     Geometry,
diff --git a/src/graphics/settings.rs b/src/graphics/settings.rs
index ce78fa734..ed82d6e34 100644
--- a/src/graphics/settings.rs
+++ b/src/graphics/settings.rs
@@ -1,12 +1,60 @@
-use derive_new::new;
 use procedural::toggle;
+use ron::ser::PrettyConfig;
+use serde::{Deserialize, Serialize};
 
-#[derive(toggle, new)]
+use super::ShadowDetail;
+#[cfg(feature = "debug")]
+use crate::debug::*;
+
+#[derive(Serialize, Deserialize, toggle)]
 pub struct GraphicsSettings {
     #[toggle]
-    #[new(value = "true")]
     pub frame_limit: bool,
     #[toggle]
-    #[new(value = "true")]
     pub show_interface: bool,
+    pub shadow_detail: ShadowDetail,
+}
+
+impl Default for GraphicsSettings {
+    fn default() -> Self {
+        Self {
+            frame_limit: true,
+            show_interface: true,
+            shadow_detail: ShadowDetail::Medium,
+        }
+    }
+}
+
+impl GraphicsSettings {
+    pub fn new() -> Self {
+        Self::load().unwrap_or_else(|| {
+            #[cfg(feature = "debug")]
+            print_debug!("failed to load graphics settings from {}filename{}", MAGENTA, NONE);
+
+            Default::default()
+        })
+    }
+
+    pub fn load() -> Option<Self> {
+        #[cfg(feature = "debug")]
+        print_debug!("loading graphics settings from {}filename{}", MAGENTA, NONE);
+
+        std::fs::read_to_string("client/graphics_settings.ron")
+            .ok()
+            .and_then(|data| ron::from_str(&data).ok())
+    }
+
+    pub fn save(&self) {
+        #[cfg(feature = "debug")]
+        print_debug!("saving graphics settings to {}filename{}", MAGENTA, NONE);
+
+        let data = ron::ser::to_string_pretty(self, PrettyConfig::new()).unwrap();
+        std::fs::write("client/graphics_settings.ron", data).expect("unable to write file");
+    }
+}
+
+impl Drop for GraphicsSettings {
+    fn drop(&mut self) {
+        self.save();
+    }
 }
diff --git a/src/input/event.rs b/src/input/event.rs
index e6799b6d9..7bedf2056 100644
--- a/src/input/event.rs
+++ b/src/input/event.rs
@@ -1,21 +1,23 @@
 use cgmath::Vector2;
 
 use super::HotbarSlot;
-use crate::interface::{ItemMove, SkillMove};
-use crate::loaders::Service;
+use crate::interface::{ItemMove, SkillMove, ThemeKind};
+use crate::loaders::ServiceId;
 use crate::network::{AccountId, CharacterId, CharacterServerInformation, EntityId};
 #[cfg(feature = "debug")]
 use crate::world::MarkerIdentifier;
 
 #[derive(Clone, Debug)]
+// TODO: A lot of these are not user events, just a element events
 pub enum UserEvent {
-    SelectService(Service),
-    LogIn(Service, String, String),
+    LogIn {
+        service_id: ServiceId,
+        username: String,
+        password: String,
+    },
     SelectServer(CharacterServerInformation),
     LogOut,
     Exit,
-    ToggleRemeberUsername,
-    ToggleRemeberPassword,
     CameraZoom(f32),
     CameraRotate(f32),
     ToggleFrameLimit,
@@ -27,9 +29,16 @@ pub enum UserEvent {
     OpenGraphicsSettingsWindow,
     OpenAudioSettingsWindow,
     OpenFriendsWindow,
-    SetThemeFile(String),
-    SaveTheme,
-    ReloadTheme,
+    SetThemeFile {
+        theme_file: String,
+        theme_kind: ThemeKind,
+    },
+    SaveTheme {
+        theme_kind: ThemeKind,
+    },
+    ReloadTheme {
+        theme_kind: ThemeKind,
+    },
     SelectCharacter(usize),
     OpenCharacterCreationWindow(usize),
     CreateCharacter(usize, String),
diff --git a/src/input/mod.rs b/src/input/mod.rs
index 397ff9316..cf0e9699c 100644
--- a/src/input/mod.rs
+++ b/src/input/mod.rs
@@ -256,12 +256,12 @@ impl InputSystem {
             self.mouse_input_mode = MouseInputMode::ClickInterface;
 
             if let Some(hovered_element) = &hovered_element {
-                let action = match self.left_mouse_button.pressed() {
+                let actions = match self.left_mouse_button.pressed() {
                     true => interface.left_click_element(hovered_element, *window_index),
                     false => interface.right_click_element(hovered_element, *window_index),
                 };
 
-                if let Some(action) = action {
+                for action in actions {
                     match action {
                         ClickAction::ChangeEvent(..) => {}
 
@@ -302,6 +302,14 @@ impl InputSystem {
                         ClickAction::OpenWindow(prototype_window) => interface.open_window(focus_state, prototype_window.as_ref()),
 
                         ClickAction::CloseWindow => interface.close_window(focus_state, *window_index),
+
+                        ClickAction::OpenPopup {
+                            element,
+                            position_tracker,
+                            size_tracker,
+                        } => interface.open_popup(element, position_tracker, size_tracker, *window_index),
+
+                        ClickAction::ClosePopup => interface.close_popup(*window_index),
                     }
                 }
             }
@@ -414,9 +422,9 @@ impl InputSystem {
             }
 
             if self.get_key(VirtualKeyCode::Return).pressed() {
-                let action = interface.left_click_element(focused_element, *focused_window);
+                let actions = interface.left_click_element(focused_element, *focused_window);
 
-                if let Some(action) = action {
+                for action in actions {
                     // TODO: remove and replace with proper event
                     match action {
                         ClickAction::Event(event) => events.push(event),
@@ -442,7 +450,9 @@ impl InputSystem {
                     '\t' => {}
                     '\x1b' => {}
                     valid => {
-                        if let Some(action) = interface.input_character_element(focused_element, *focused_window, valid) {
+                        let actions = interface.input_character_element(focused_element, *focused_window, valid);
+
+                        for action in actions {
                             match action {
                                 // is handled in the interface
                                 ClickAction::ChangeEvent(..) => {}
@@ -469,6 +479,12 @@ impl InputSystem {
                                 ClickAction::MoveSkill(..) => {}
                                 ClickAction::OpenWindow(prototype_window) => interface.open_window(focus_state, prototype_window.as_ref()),
                                 ClickAction::CloseWindow => interface.close_window(focus_state, *focused_window),
+                                ClickAction::OpenPopup {
+                                    element,
+                                    position_tracker,
+                                    size_tracker,
+                                } => interface.open_popup(element, position_tracker, size_tracker, *focused_window),
+                                ClickAction::ClosePopup => interface.close_popup(*focused_window),
                             }
                         }
                     }
diff --git a/src/interface/elements/base.rs b/src/interface/elements/base.rs
index edb5a1fd3..6a1610c89 100644
--- a/src/interface/elements/base.rs
+++ b/src/interface/elements/base.rs
@@ -36,6 +36,10 @@ pub struct ElementRenderer<'a> {
 }
 
 impl<'a> ElementRenderer<'a> {
+    pub fn get_position(&self) -> Position {
+        self.position
+    }
+
     pub fn get_text_dimensions(&self, text: &str, font_size: f32, available_width: f32) -> Vector2<f32> {
         self.renderer
             .get_text_dimensions(text, font_size * *self.interface_settings.scaling, available_width)
@@ -117,7 +121,7 @@ impl<'a> ElementRenderer<'a> {
         element: &dyn Element,
         state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         hovered_element: Option<&dyn Element>,
         focused_element: Option<&dyn Element>,
         mouse_mode: &MouseInputMode,
@@ -142,7 +146,8 @@ impl<'a> ElementRenderer<'a> {
 pub struct ElementState {
     pub cached_size: Size,
     pub cached_position: Position,
-    pub parent_element: Option<Weak<RefCell<dyn Element>>>,
+    pub self_element: Option<WeakElementCell>,
+    pub parent_element: Option<WeakElementCell>,
     pub mouse_position: Cell<Position>,
 }
 
@@ -151,6 +156,7 @@ impl Default for ElementState {
         Self {
             cached_size: Size::zero(),
             cached_position: Position::zero(),
+            self_element: None,
             parent_element: None,
             mouse_position: Cell::new(Position::zero()),
         }
@@ -158,7 +164,8 @@ impl Default for ElementState {
 }
 
 impl ElementState {
-    pub fn link_back(&mut self, weak_parent: Option<Weak<RefCell<dyn Element>>>) {
+    pub fn link_back(&mut self, weak_self: WeakElementCell, weak_parent: Option<WeakElementCell>) {
+        self.self_element = Some(weak_self);
         self.parent_element = weak_parent;
     }
 
@@ -255,8 +262,8 @@ pub trait Element {
 
     fn get_state_mut(&mut self) -> &mut ElementState;
 
-    fn link_back(&mut self, _weak_self: Weak<RefCell<dyn Element>>, weak_parent: Option<Weak<RefCell<dyn Element>>>) {
-        self.get_state_mut().link_back(weak_parent);
+    fn link_back(&mut self, weak_self: WeakElementCell, weak_parent: Option<WeakElementCell>) {
+        self.get_state_mut().link_back(weak_self, weak_parent);
     }
 
     fn is_focusable(&self) -> bool {
@@ -284,7 +291,7 @@ pub trait Element {
         self.is_focusable().then_some(self_cell)
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &Theme);
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &InterfaceTheme);
 
     fn update(&mut self) -> Option<ChangeEvent> {
         None
@@ -298,20 +305,20 @@ pub trait Element {
         HoverInformation::Missed
     }
 
-    fn left_click(&mut self, _update: &mut bool) -> Option<ClickAction> {
-        None
+    fn left_click(&mut self, _update: &mut bool) -> Vec<ClickAction> {
+        Vec::new()
     }
 
-    fn right_click(&mut self, _update: &mut bool) -> Option<ClickAction> {
-        None
+    fn right_click(&mut self, _update: &mut bool) -> Vec<ClickAction> {
+        Vec::new()
     }
 
     fn drag(&mut self, _mouse_delta: Position) -> Option<ChangeEvent> {
         None
     }
 
-    fn input_character(&mut self, _character: char) -> Option<ClickAction> {
-        None
+    fn input_character(&mut self, _character: char) -> Vec<ClickAction> {
+        Vec::new()
     }
 
     fn drop_item(&mut self, _item_source: ItemSource, _item: Item) -> Option<ItemMove> {
@@ -338,7 +345,7 @@ pub trait Element {
         render: &InterfaceRenderer,
         state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/buttons/close.rs b/src/interface/elements/buttons/close.rs
index b73425fa9..7f2180e76 100644
--- a/src/interface/elements/buttons/close.rs
+++ b/src/interface/elements/buttons/close.rs
@@ -16,7 +16,7 @@ impl Element for CloseButton {
         &mut self.state
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         let (size, position) = placement_resolver.allocate_right(&theme.close_button.size_constraint);
         self.state.cached_size = size.finalize();
         self.state.cached_position = position;
@@ -33,8 +33,8 @@ impl Element for CloseButton {
         }
     }
 
-    fn left_click(&mut self, _force_update: &mut bool) -> Option<ClickAction> {
-        Some(ClickAction::CloseWindow)
+    fn left_click(&mut self, _force_update: &mut bool) -> Vec<ClickAction> {
+        vec![ClickAction::CloseWindow]
     }
 
     fn render(
@@ -43,7 +43,7 @@ impl Element for CloseButton {
         renderer: &InterfaceRenderer,
         _state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/buttons/default.rs b/src/interface/elements/buttons/default.rs
index f9741bcb2..3272ed174 100644
--- a/src/interface/elements/buttons/default.rs
+++ b/src/interface/elements/buttons/default.rs
@@ -58,12 +58,12 @@ where
         self
     }
 
-    pub fn with_foreground_color(mut self, foreground_color: impl Fn(&Theme) -> Color + 'static) -> Self {
+    pub fn with_foreground_color(mut self, foreground_color: impl Fn(&InterfaceTheme) -> Color + 'static) -> Self {
         self.foreground_color = Some(Box::new(foreground_color));
         self
     }
 
-    pub fn with_background_color(mut self, background_color: impl Fn(&Theme) -> Color + 'static) -> Self {
+    pub fn with_background_color(mut self, background_color: impl Fn(&InterfaceTheme) -> Color + 'static) -> Self {
         self.background_color = Some(Box::new(background_color));
         self
     }
@@ -91,7 +91,7 @@ impl<T: AsRef<str> + 'static, E: ElementEvent> Element for Button<T, E> {
         !self.is_disabled()
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         let size_constraint = self
             .width_constraint
             .as_ref()
@@ -108,12 +108,12 @@ impl<T: AsRef<str> + 'static, E: ElementEvent> Element for Button<T, E> {
         }
     }
 
-    fn left_click(&mut self, _force_update: &mut bool) -> Option<ClickAction> {
+    fn left_click(&mut self, _force_update: &mut bool) -> Vec<ClickAction> {
         if self.is_disabled() {
-            return None;
+            return Vec::new();
         }
 
-        self.event.as_mut().and_then(ElementEvent::trigger)
+        self.event.as_mut().map(|event| event.trigger()).unwrap_or_default()
     }
 
     fn render(
@@ -122,7 +122,7 @@ impl<T: AsRef<str> + 'static, E: ElementEvent> Element for Button<T, E> {
         renderer: &InterfaceRenderer,
         _state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/buttons/drag.rs b/src/interface/elements/buttons/drag.rs
index 1d7fbf34f..6ac02aba7 100644
--- a/src/interface/elements/buttons/drag.rs
+++ b/src/interface/elements/buttons/drag.rs
@@ -21,7 +21,7 @@ impl Element for DragButton {
         &mut self.state
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         let size_constraint = self.width_constraint.add_height(theme.window.title_height);
 
         self.state.resolve(placement_resolver, &size_constraint);
@@ -39,8 +39,8 @@ impl Element for DragButton {
         }
     }
 
-    fn left_click(&mut self, _force_update: &mut bool) -> Option<ClickAction> {
-        Some(ClickAction::MoveInterface)
+    fn left_click(&mut self, _force_update: &mut bool) -> Vec<ClickAction> {
+        vec![ClickAction::MoveInterface]
     }
 
     fn render(
@@ -49,7 +49,7 @@ impl Element for DragButton {
         renderer: &InterfaceRenderer,
         _state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/buttons/state.rs b/src/interface/elements/buttons/state.rs
index e878a68e6..3509f9e73 100644
--- a/src/interface/elements/buttons/state.rs
+++ b/src/interface/elements/buttons/state.rs
@@ -4,6 +4,7 @@ use crate::graphics::{InterfaceRenderer, Renderer};
 use crate::input::MouseInputMode;
 use crate::interface::{Element, *};
 
+// FIX: State button won't redraw just because the state changes
 pub struct StateButton<T, E>
 where
     T: AsRef<str> + 'static,
@@ -80,7 +81,7 @@ where
         &mut self.state
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         let size_constraint = self
             .width_constraint
             .as_ref()
@@ -97,8 +98,8 @@ where
         }
     }
 
-    fn left_click(&mut self, _force_update: &mut bool) -> Option<ClickAction> {
-        self.event.as_mut().and_then(ElementEvent::trigger)
+    fn left_click(&mut self, _force_update: &mut bool) -> Vec<ClickAction> {
+        self.event.as_mut().map(|event| event.trigger()).unwrap_or_default()
     }
 
     fn render(
@@ -107,7 +108,7 @@ where
         renderer: &InterfaceRenderer,
         state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/containers/character.rs b/src/interface/elements/containers/character.rs
index 428046716..c181e7397 100644
--- a/src/interface/elements/containers/character.rs
+++ b/src/interface/elements/containers/character.rs
@@ -105,7 +105,7 @@ impl Element for CharacterPreview {
         self.state.focus_next::<true>(self_cell, caller_cell, focus)
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         let size_constraint = &constraint!(20%, 150);
         self.state.resolve(
             placement_resolver,
@@ -121,11 +121,8 @@ impl Element for CharacterPreview {
         let move_request_changed = self.move_request.consume_changed();
 
         if characters_changed || move_request_changed {
+            let weak_self = self.state.state.self_element.take().unwrap();
             let weak_parent = self.state.state.parent_element.clone();
-            // Since the character container will always have at least one linked child
-            // element, we can get a reference to self there instead of storing
-            // it in self.
-            let weak_self = self.state.elements[0].borrow().get_state().parent_element.clone().unwrap();
 
             *self = Self::new(self.characters.clone(), self.move_request.clone(), self.slot);
 
@@ -139,14 +136,14 @@ impl Element for CharacterPreview {
         None
     }
 
-    fn left_click(&mut self, _update: &mut bool) -> Option<ClickAction> {
+    fn left_click(&mut self, _update: &mut bool) -> Vec<ClickAction> {
         if let Some(origin_slot) = *self.move_request.borrow() {
             let event = match origin_slot == self.slot {
                 true => UserEvent::CancelSwitchCharacterSlot,
                 false => UserEvent::SwitchCharacterSlot(self.slot),
             };
 
-            return Some(ClickAction::Event(event));
+            return vec![ClickAction::Event(event)];
         }
 
         let event = match self.has_character() {
@@ -154,7 +151,7 @@ impl Element for CharacterPreview {
             false => UserEvent::OpenCharacterCreationWindow(self.slot),
         };
 
-        Some(ClickAction::Event(event))
+        vec![ClickAction::Event(event)]
     }
 
     fn hovered_element(&self, mouse_position: Position, mouse_mode: &MouseInputMode) -> HoverInformation {
@@ -170,7 +167,7 @@ impl Element for CharacterPreview {
         renderer: &InterfaceRenderer,
         state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/containers/default.rs b/src/interface/elements/containers/default.rs
index 91c8f5c78..9aafe5955 100644
--- a/src/interface/elements/containers/default.rs
+++ b/src/interface/elements/containers/default.rs
@@ -54,7 +54,7 @@ impl Element for Container {
         self.state.restore_focus(self_cell)
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         let size_constraint = self.size_constraint.as_ref().unwrap_or(&constraint!(100%, ?));
         let border = self.border_size.unwrap_or_else(Vector2::zero);
 
@@ -76,7 +76,7 @@ impl Element for Container {
         renderer: &InterfaceRenderer,
         state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/containers/dialog.rs b/src/interface/elements/containers/dialog.rs
index 75c4df1e6..19b82ed93 100644
--- a/src/interface/elements/containers/dialog.rs
+++ b/src/interface/elements/containers/dialog.rs
@@ -70,7 +70,7 @@ impl Element for DialogContainer {
 
     // TODO: focus related things
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         let size_constraint = &constraint!(100%, ?);
         self.state.resolve(
             placement_resolver,
@@ -103,7 +103,7 @@ impl Element for DialogContainer {
         renderer: &InterfaceRenderer,
         state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/containers/equipment.rs b/src/interface/elements/containers/equipment.rs
index 4576dbbdd..2be6c88e2 100644
--- a/src/interface/elements/containers/equipment.rs
+++ b/src/interface/elements/containers/equipment.rs
@@ -86,7 +86,7 @@ impl Element for EquipmentContainer {
         self.state.restore_focus(self_cell)
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         let size_constraint = &constraint!(100%, ?);
         self.state.resolve(
             placement_resolver,
@@ -126,7 +126,7 @@ impl Element for EquipmentContainer {
         renderer: &InterfaceRenderer,
         state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/containers/expandable.rs b/src/interface/elements/containers/expandable.rs
index 712690516..804dbd6da 100644
--- a/src/interface/elements/containers/expandable.rs
+++ b/src/interface/elements/containers/expandable.rs
@@ -57,7 +57,7 @@ impl Element for Expandable {
         self.state.restore_focus(self_cell)
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         let closed_size = self
             .closed_size_constraint
             .resolve_partial(
@@ -141,10 +141,10 @@ impl Element for Expandable {
         HoverInformation::Missed
     }
 
-    fn left_click(&mut self, force_update: &mut bool) -> Option<ClickAction> {
+    fn left_click(&mut self, force_update: &mut bool) -> Vec<ClickAction> {
         self.expanded = !self.expanded;
         *force_update = true;
-        None
+        Vec::new()
     }
 
     fn render(
@@ -153,7 +153,7 @@ impl Element for Expandable {
         renderer: &InterfaceRenderer,
         state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/containers/friends.rs b/src/interface/elements/containers/friends.rs
index b4010ddd8..377068536 100644
--- a/src/interface/elements/containers/friends.rs
+++ b/src/interface/elements/containers/friends.rs
@@ -11,13 +11,11 @@ use crate::network::Friend;
 
 pub struct FriendView {
     friends: Remote<Vec<(Friend, UnsafeCell<Option<WeakElementCell>>)>>,
-    weak_self: Option<WeakElementCell>,
     state: ContainerState,
 }
 
 impl FriendView {
     pub fn new(friends: Remote<Vec<(Friend, UnsafeCell<Option<WeakElementCell>>)>>) -> Self {
-        let weak_self = None;
         let elements = {
             let friends = friends.borrow();
 
@@ -33,7 +31,6 @@ impl FriendView {
 
         Self {
             friends,
-            weak_self,
             state: ContainerState::new(elements),
         }
     }
@@ -63,7 +60,6 @@ impl Element for FriendView {
     }
 
     fn link_back(&mut self, weak_self: Weak<RefCell<dyn Element>>, weak_parent: Option<Weak<RefCell<dyn Element>>>) {
-        self.weak_self = Some(weak_self.clone());
         self.state.link_back(weak_self, weak_parent);
     }
 
@@ -79,7 +75,7 @@ impl Element for FriendView {
         self.state.restore_focus(self_cell)
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         self.state.resolve(
             placement_resolver,
             interface_settings,
@@ -107,7 +103,9 @@ impl Element for FriendView {
                     } else {
                         let element = Self::friend_to_element(friend);
                         unsafe { *linked_element.get() = Some(Rc::downgrade(&element)) };
-                        element.borrow_mut().link_back(Rc::downgrade(&element), self.weak_self.clone());
+                        let weak_self = self.state.state.self_element.clone();
+
+                        element.borrow_mut().link_back(Rc::downgrade(&element), weak_self);
 
                         self.state.elements.insert(index, element);
                         resolve = true;
@@ -141,7 +139,7 @@ impl Element for FriendView {
         renderer: &InterfaceRenderer,
         state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/containers/hotbar.rs b/src/interface/elements/containers/hotbar.rs
index b6d0d99a8..8515e84a7 100644
--- a/src/interface/elements/containers/hotbar.rs
+++ b/src/interface/elements/containers/hotbar.rs
@@ -8,7 +8,6 @@ use crate::inventory::Skill;
 
 pub struct HotbarContainer {
     skills: Remote<[Option<Skill>; 10]>,
-    weak_self: Option<WeakElementCell>,
     state: ContainerState,
 }
 
@@ -34,10 +33,9 @@ impl HotbarContainer {
                 .collect()
         };
 
-        let weak_self = None;
         let state = ContainerState::new(elements);
 
-        Self { skills, weak_self, state }
+        Self { skills, state }
     }
 }
 
@@ -51,7 +49,6 @@ impl Element for HotbarContainer {
     }
 
     fn link_back(&mut self, weak_self: WeakElementCell, weak_parent: Option<WeakElementCell>) {
-        self.weak_self = Some(weak_self.clone());
         self.state.link_back(weak_self, weak_parent);
     }
 
@@ -67,7 +64,7 @@ impl Element for HotbarContainer {
         self.state.restore_focus(self_cell)
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         let size_constraint = &constraint!(100%, ?);
         self.state.resolve(
             placement_resolver,
@@ -80,8 +77,8 @@ impl Element for HotbarContainer {
 
     fn update(&mut self) -> Option<ChangeEvent> {
         if self.skills.consume_changed() {
+            let weak_self = self.state.state.self_element.take().unwrap();
             let weak_parent = self.state.state.parent_element.take();
-            let weak_self = self.weak_self.take().unwrap();
 
             *self = Self::new(self.skills.clone());
             // important: link back after creating elements, otherwise focus navigation and
@@ -107,7 +104,7 @@ impl Element for HotbarContainer {
         renderer: &InterfaceRenderer,
         state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/containers/inventory.rs b/src/interface/elements/containers/inventory.rs
index 613103127..4f4670eb5 100644
--- a/src/interface/elements/containers/inventory.rs
+++ b/src/interface/elements/containers/inventory.rs
@@ -57,7 +57,7 @@ impl Element for InventoryContainer {
         self.state.restore_focus(self_cell)
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         let size_constraint = &constraint!(100%, ?);
         self.state.resolve(
             placement_resolver,
@@ -106,7 +106,7 @@ impl Element for InventoryContainer {
         renderer: &InterfaceRenderer,
         state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/containers/mod.rs b/src/interface/elements/containers/mod.rs
index 40b25ce29..1de3035b9 100644
--- a/src/interface/elements/containers/mod.rs
+++ b/src/interface/elements/containers/mod.rs
@@ -44,18 +44,18 @@ pub struct ContainerState {
 
 impl ContainerState {
     pub fn link_back(&mut self, weak_self: Weak<RefCell<dyn Element>>, weak_parent: Option<Weak<RefCell<dyn Element>>>) {
-        self.state.link_back(weak_parent);
         self.elements.iter().for_each(|element| {
             let weak_element = Rc::downgrade(element);
             element.borrow_mut().link_back(weak_element, Some(weak_self.clone()));
         });
+        self.state.link_back(weak_self, weak_parent);
     }
 
     pub fn resolve(
         &mut self,
         placement_resolver: &mut PlacementResolver,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         size_constraint: &SizeConstraint,
         border: Vector2<f32>,
     ) {
@@ -299,7 +299,7 @@ impl ContainerState {
         renderer: &mut ElementRenderer,
         state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         hovered_element: Option<&dyn Element>,
         focused_element: Option<&dyn Element>,
         mouse_mode: &MouseInputMode,
diff --git a/src/interface/elements/containers/packet.rs b/src/interface/elements/containers/packet.rs
index eeceebf71..728046ad9 100644
--- a/src/interface/elements/containers/packet.rs
+++ b/src/interface/elements/containers/packet.rs
@@ -20,7 +20,7 @@ impl Element for HiddenElement {
         unimplemented!()
     }
 
-    fn resolve(&mut self, _placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, _theme: &Theme) {
+    fn resolve(&mut self, _placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, _theme: &InterfaceTheme) {
         unimplemented!()
     }
 
@@ -30,7 +30,7 @@ impl Element for HiddenElement {
         _render: &InterfaceRenderer,
         _state_provider: &StateProvider,
         _interface_settings: &InterfaceSettings,
-        _theme: &Theme,
+        _theme: &InterfaceTheme,
         _parent_position: Position,
         _clip_size: ClipSize,
         _hovered_element: Option<&dyn Element>,
@@ -94,14 +94,12 @@ impl PacketEntry {
 pub struct PacketView<const N: usize> {
     packets: Remote<RingBuffer<(PacketEntry, UnsafeCell<Option<WeakElementCell>>), N>>,
     show_pings: Remote<bool>,
-    weak_self: Option<WeakElementCell>,
     hidden_element: ElementCell,
     state: ContainerState,
 }
 
 impl<const N: usize> PacketView<N> {
     pub fn new(packets: Remote<RingBuffer<(PacketEntry, UnsafeCell<Option<WeakElementCell>>), N>>, show_pings: Remote<bool>) -> Self {
-        let weak_self = None;
         let hidden_element = HiddenElement.wrap();
         let elements = {
             let packets = packets.borrow();
@@ -130,7 +128,6 @@ impl<const N: usize> PacketView<N> {
         Self {
             packets,
             show_pings,
-            weak_self,
             hidden_element,
             state: ContainerState::new(elements),
         }
@@ -147,7 +144,6 @@ impl<const N: usize> Element for PacketView<N> {
     }
 
     fn link_back(&mut self, weak_self: Weak<RefCell<dyn Element>>, weak_parent: Option<Weak<RefCell<dyn Element>>>) {
-        self.weak_self = Some(weak_self.clone());
         self.state.link_back(weak_self, weak_parent);
     }
 
@@ -163,7 +159,7 @@ impl<const N: usize> Element for PacketView<N> {
         self.state.restore_focus(self_cell)
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         self.state.resolve(
             placement_resolver,
             interface_settings,
@@ -223,7 +219,9 @@ impl<const N: usize> Element for PacketView<N> {
                     if show_packet && was_hidden {
                         let element = PacketEntry::to_element(packet);
                         *linked_element = Rc::downgrade(&element);
-                        element.borrow_mut().link_back(Rc::downgrade(&element), self.weak_self.clone());
+                        element
+                            .borrow_mut()
+                            .link_back(Rc::downgrade(&element), self.state.state.self_element.clone());
 
                         self.state.elements.insert(index, element);
                         resolve = true;
@@ -242,7 +240,9 @@ impl<const N: usize> Element for PacketView<N> {
                         true => {
                             let element = PacketEntry::to_element(packet);
                             unsafe { *linked_element.get() = Some(Rc::downgrade(&element)) };
-                            element.borrow_mut().link_back(Rc::downgrade(&element), self.weak_self.clone());
+                            element
+                                .borrow_mut()
+                                .link_back(Rc::downgrade(&element), self.state.state.self_element.clone());
 
                             self.state.elements.push(element);
                             resolve = true;
@@ -278,7 +278,7 @@ impl<const N: usize> Element for PacketView<N> {
         renderer: &InterfaceRenderer,
         state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/containers/scroll.rs b/src/interface/elements/containers/scroll.rs
index 354ee46cc..e894c3cec 100644
--- a/src/interface/elements/containers/scroll.rs
+++ b/src/interface/elements/containers/scroll.rs
@@ -12,19 +12,27 @@ pub struct ScrollView {
     scroll: f32,
     state: ContainerState,
     size_constraint: SizeConstraint,
+    background_color: Option<ColorSelector>,
 }
 
 impl ScrollView {
     pub fn new(elements: Vec<ElementCell>, size_constraint: SizeConstraint) -> Self {
         let scroll = 0.0;
         let state = ContainerState::new(elements);
+        let background_color = None;
 
         Self {
             scroll,
             state,
             size_constraint,
+            background_color,
         }
     }
+
+    pub fn with_background_color(mut self, background_color: impl Fn(&InterfaceTheme) -> Color + 'static) -> Self {
+        self.background_color = Some(Box::new(background_color));
+        self
+    }
 }
 
 impl Element for ScrollView {
@@ -52,7 +60,7 @@ impl Element for ScrollView {
         self.state.restore_focus(self_cell)
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         self.state.resolve(
             placement_resolver,
             interface_settings,
@@ -86,7 +94,7 @@ impl Element for ScrollView {
         renderer: &InterfaceRenderer,
         state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         hovered_element: Option<&dyn Element>,
@@ -99,6 +107,10 @@ impl Element for ScrollView {
             .state
             .element_renderer(render_target, renderer, interface_settings, parent_position, clip_size);
 
+        if let Some(color_selector) = &self.background_color {
+            renderer.render_background((*theme.button.corner_radius).into(), color_selector(theme));
+        }
+
         renderer.set_scroll(self.scroll);
 
         self.state.render(
diff --git a/src/interface/elements/containers/skill_tree.rs b/src/interface/elements/containers/skill_tree.rs
index 4a670d8ca..d0f451b2a 100644
--- a/src/interface/elements/containers/skill_tree.rs
+++ b/src/interface/elements/containers/skill_tree.rs
@@ -57,7 +57,7 @@ impl Element for SkillTreeContainer {
         self.state.restore_focus(self_cell)
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         let size_constraint = &constraint!(100%, ?);
         self.state.resolve(
             placement_resolver,
@@ -106,7 +106,7 @@ impl Element for SkillTreeContainer {
         renderer: &InterfaceRenderer,
         state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/miscellanious/chat.rs b/src/interface/elements/miscellanious/chat.rs
index 2fae6e2ce..7cec8850c 100644
--- a/src/interface/elements/miscellanious/chat.rs
+++ b/src/interface/elements/miscellanious/chat.rs
@@ -44,7 +44,7 @@ impl Element for Chat {
         false
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         let mut size_constraint = constraint!(100%, 0);
         // Not sure why but 0.0 cuts off the lower part of the text, so add some
         // padding.
@@ -83,7 +83,7 @@ impl Element for Chat {
         renderer: &InterfaceRenderer,
         _state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         _hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/miscellanious/headline.rs b/src/interface/elements/miscellanious/headline.rs
index bd93cec24..617235750 100644
--- a/src/interface/elements/miscellanious/headline.rs
+++ b/src/interface/elements/miscellanious/headline.rs
@@ -29,7 +29,7 @@ impl Element for Headline {
         false
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, _theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, _theme: &InterfaceTheme) {
         self.state.resolve(placement_resolver, &self.size_constraint);
     }
 
@@ -39,7 +39,7 @@ impl Element for Headline {
         renderer: &InterfaceRenderer,
         _state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         _hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/miscellanious/input.rs b/src/interface/elements/miscellanious/input.rs
index 97739d56c..2599217c8 100644
--- a/src/interface/elements/miscellanious/input.rs
+++ b/src/interface/elements/miscellanious/input.rs
@@ -12,33 +12,33 @@ use crate::interface::{Element, *};
 pub struct InputField<const LENGTH: usize, const HIDDEN: bool = false> {
     display: Rc<RefCell<String>>,
     ghost_text: &'static str,
-    action: Box<dyn Fn() -> Option<ClickAction>>,
+    action: Box<dyn Fn() -> Vec<ClickAction>>,
     width_constraint: DimensionConstraint,
     #[new(default)]
     state: ElementState,
 }
 
 impl<const LENGTH: usize, const HIDDEN: bool> InputField<LENGTH, HIDDEN> {
-    fn remove_character(&mut self) -> Option<ClickAction> {
+    fn remove_character(&mut self) -> Vec<ClickAction> {
         let mut display = self.display.borrow_mut();
 
         if display.is_empty() {
-            return None;
+            return Vec::new();
         }
 
         display.pop();
-        Some(ClickAction::ChangeEvent(ChangeEvent::RENDER_WINDOW))
+        vec![ClickAction::ChangeEvent(ChangeEvent::RENDER_WINDOW)]
     }
 
-    fn add_character(&mut self, character: char) -> Option<ClickAction> {
+    fn add_character(&mut self, character: char) -> Vec<ClickAction> {
         let mut display = self.display.borrow_mut();
 
         if display.len() >= LENGTH {
-            return None;
+            return Vec::new();
         }
 
         display.push(character);
-        Some(ClickAction::ChangeEvent(ChangeEvent::RENDER_WINDOW))
+        vec![ClickAction::ChangeEvent(ChangeEvent::RENDER_WINDOW)]
     }
 }
 
@@ -51,7 +51,7 @@ impl<const LENGTH: usize, const HIDDEN: bool> Element for InputField<LENGTH, HID
         &mut self.state
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         let size_constraint = self.width_constraint.add_height(theme.input.height_constraint);
         self.state.resolve(placement_resolver, &size_constraint);
     }
@@ -63,11 +63,11 @@ impl<const LENGTH: usize, const HIDDEN: bool> Element for InputField<LENGTH, HID
         }
     }
 
-    fn left_click(&mut self, _update: &mut bool) -> Option<ClickAction> {
-        Some(ClickAction::FocusElement)
+    fn left_click(&mut self, _update: &mut bool) -> Vec<ClickAction> {
+        vec![ClickAction::FocusElement]
     }
 
-    fn input_character(&mut self, character: char) -> Option<ClickAction> {
+    fn input_character(&mut self, character: char) -> Vec<ClickAction> {
         match character {
             '\u{8}' | '\u{7f}' => self.remove_character(),
             '\r' => (self.action)(),
@@ -81,7 +81,7 @@ impl<const LENGTH: usize, const HIDDEN: bool> Element for InputField<LENGTH, HID
         renderer: &InterfaceRenderer,
         _state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         hovered_element: Option<&dyn Element>,
@@ -123,10 +123,10 @@ impl<const LENGTH: usize, const HIDDEN: bool> Element for InputField<LENGTH, HID
         };
 
         renderer.render_background(*theme.input.border_radius, background_color);
-        renderer.render_text(&text, Vector2::new(text_offset, 0.0), text_color, *theme.input.font_size);
+        renderer.render_text(&text, text_offset, text_color, *theme.input.font_size);
 
         if is_focused {
-            let cursor_offset = text_offset
+            let cursor_offset = text_offset.x
                 + *theme.input.cursor_offset * *interface_settings.scaling
                 + renderer.get_text_dimensions(&text, *theme.input.font_size, f32::MAX).x;
 
diff --git a/src/interface/elements/miscellanious/item.rs b/src/interface/elements/miscellanious/item.rs
index b55267ecd..47c71b8ba 100644
--- a/src/interface/elements/miscellanious/item.rs
+++ b/src/interface/elements/miscellanious/item.rs
@@ -29,7 +29,7 @@ impl Element for ItemBox {
         self.item.is_some()
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, _theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, _theme: &InterfaceTheme) {
         self.state.resolve(placement_resolver, &constraint!(30, 30));
     }
 
@@ -40,12 +40,12 @@ impl Element for ItemBox {
         }
     }
 
-    fn left_click(&mut self, _force_update: &mut bool) -> Option<ClickAction> {
+    fn left_click(&mut self, _force_update: &mut bool) -> Vec<ClickAction> {
         if let Some(item) = &self.item {
-            return Some(ClickAction::MoveItem(self.source, item.clone()));
+            return vec![ClickAction::MoveItem(self.source, item.clone())];
         }
 
-        None
+        Vec::new()
     }
 
     fn drop_item(&mut self, item_source: ItemSource, item: Item) -> Option<ItemMove> {
@@ -62,7 +62,7 @@ impl Element for ItemBox {
         renderer: &InterfaceRenderer,
         _state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/miscellanious/mod.rs b/src/interface/elements/miscellanious/mod.rs
index feed3d8e4..f4ef2644a 100644
--- a/src/interface/elements/miscellanious/mod.rs
+++ b/src/interface/elements/miscellanious/mod.rs
@@ -2,6 +2,7 @@ mod chat;
 mod headline;
 mod input;
 mod item;
+mod picklist;
 mod skill;
 mod slider;
 mod static_label;
@@ -11,6 +12,7 @@ pub use self::chat::Chat;
 pub use self::headline::Headline;
 pub use self::input::InputField;
 pub use self::item::ItemBox;
+pub use self::picklist::PickList;
 pub use self::skill::SkillBox;
 pub use self::slider::Slider;
 pub use self::static_label::StaticLabel;
diff --git a/src/interface/elements/miscellanious/picklist.rs b/src/interface/elements/miscellanious/picklist.rs
new file mode 100644
index 000000000..8b9c358b1
--- /dev/null
+++ b/src/interface/elements/miscellanious/picklist.rs
@@ -0,0 +1,195 @@
+use procedural::{constraint, dimension};
+
+use crate::graphics::{InterfaceRenderer, Renderer};
+use crate::input::MouseInputMode;
+use crate::interface::{Element, *};
+
+pub struct PickList<K, T, E>
+where
+    K: Clone + AsRef<str> + 'static,
+    E: Clone + ElementEvent + 'static,
+    T: Clone + PartialEq + 'static,
+{
+    options: Vec<(K, T)>,
+    selected: Option<TrackedState<T>>,
+    event: Option<E>,
+    width_constraint: Option<DimensionConstraint>,
+    state: ElementState,
+    latest_position: Rc<RefCell<Position>>,
+    latest_size: Rc<RefCell<Size>>,
+}
+
+// HACK: Workaround for Rust incorrect trait bounds when deriving Option<T>
+// where T: !Default.
+impl<K, T, E> Default for PickList<K, T, E>
+where
+    K: Clone + AsRef<str> + 'static,
+    E: Clone + ElementEvent + 'static,
+    T: Clone + PartialEq + 'static,
+{
+    fn default() -> Self {
+        Self {
+            options: Default::default(),
+            selected: Default::default(),
+            event: Default::default(),
+            width_constraint: Default::default(),
+            state: Default::default(),
+            latest_position: Rc::new(RefCell::new(Position::new(0.0, 0.0))),
+            latest_size: Rc::new(RefCell::new(Size::new(0.0, 0.0))),
+        }
+    }
+}
+
+impl<K, T, E> PickList<K, T, E>
+where
+    K: Clone + AsRef<str> + 'static,
+    E: Clone + ElementEvent + 'static,
+    T: Clone + PartialEq + 'static,
+{
+    pub fn with_options(mut self, options: Vec<(K, T)>) -> Self {
+        self.options = options;
+        self
+    }
+
+    pub fn with_selected(mut self, selected: TrackedState<T>) -> Self {
+        self.selected = Some(selected);
+        self
+    }
+
+    pub fn with_event(mut self, event: E) -> Self {
+        self.event = Some(event);
+        self
+    }
+
+    pub fn with_width(mut self, width_constraint: DimensionConstraint) -> Self {
+        self.width_constraint = Some(width_constraint);
+        self
+    }
+}
+
+impl<K, T, E> Element for PickList<K, T, E>
+where
+    K: Clone + AsRef<str> + 'static,
+    E: Clone + ElementEvent + 'static,
+    T: Clone + PartialEq + 'static,
+{
+    fn get_state(&self) -> &ElementState {
+        &self.state
+    }
+
+    fn get_state_mut(&mut self) -> &mut ElementState {
+        &mut self.state
+    }
+
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
+        let size_constraint = self
+            .width_constraint
+            .as_ref()
+            .unwrap_or(&dimension!(100%))
+            .add_height(theme.button.height_constraint);
+
+        self.state.resolve(placement_resolver, &size_constraint);
+
+        *self.latest_size.borrow_mut() = self.state.cached_size;
+    }
+
+    fn hovered_element(&self, mouse_position: Position, mouse_mode: &MouseInputMode) -> HoverInformation {
+        match mouse_mode {
+            MouseInputMode::None => self.state.hovered_element(mouse_position),
+            _ => HoverInformation::Missed,
+        }
+    }
+
+    fn left_click(&mut self, _force_update: &mut bool) -> Vec<ClickAction> {
+        let position_tracker = {
+            let latest_position = Rc::downgrade(&self.latest_position);
+            move || latest_position.upgrade().map(|position| *position.borrow())
+        };
+
+        let size_tracker = {
+            let latest_size = Rc::downgrade(&self.latest_size);
+            move || latest_size.upgrade().map(|size| *size.borrow())
+        };
+
+        let options = self
+            .options
+            .iter()
+            .cloned()
+            .map(|(text, option)| {
+                // FIX: What is the behavior here when slected is none?
+                let mut selected = self.selected.clone().unwrap();
+                let mut event = self.event.clone();
+
+                Button::default()
+                    .with_text(text)
+                    .with_event(Box::new(move || {
+                        selected.set(option.clone());
+                        let mut actions = vec![ClickAction::ClosePopup];
+
+                        if let Some(event) = &mut event {
+                            actions.extend(event.trigger());
+                        };
+
+                        actions
+                    }))
+                    .wrap()
+            })
+            .collect();
+
+        let element = ScrollView::new(options, constraint!(100%, ? < 500))
+            .with_background_color(|theme| *theme.button.background_color)
+            .wrap();
+
+        vec![ClickAction::OpenPopup {
+            element,
+            position_tracker: Box::new(position_tracker),
+            size_tracker: Box::new(size_tracker),
+        }]
+    }
+
+    fn render(
+        &self,
+        render_target: &mut <InterfaceRenderer as Renderer>::Target,
+        renderer: &InterfaceRenderer,
+        _state_provider: &StateProvider,
+        interface_settings: &InterfaceSettings,
+        theme: &InterfaceTheme,
+        parent_position: Position,
+        clip_size: ClipSize,
+        hovered_element: Option<&dyn Element>,
+        focused_element: Option<&dyn Element>,
+        _mouse_mode: &MouseInputMode,
+        _second_theme: bool,
+    ) {
+        let mut renderer = self
+            .state
+            .element_renderer(render_target, renderer, interface_settings, parent_position, clip_size);
+
+        let highlighted = self.is_element_self(hovered_element) || self.is_element_self(focused_element);
+        let background_color = match highlighted {
+            true => *theme.button.hovered_background_color,
+            false => *theme.button.background_color,
+        };
+
+        renderer.render_background(*theme.button.border_radius, background_color);
+
+        *self.latest_position.borrow_mut() = renderer.get_position();
+
+        let foreground_color = match highlighted {
+            true => *theme.button.hovered_foreground_color,
+            false => *theme.button.foreground_color,
+        };
+
+        // FIX: Don't unwrap. Fix logic
+        let current_state = self.selected.as_ref().map(|state| state.get()).unwrap();
+
+        if let Some((text, _)) = self.options.iter().find(|(_, value)| *value == current_state) {
+            renderer.render_text(
+                text.as_ref(),
+                *theme.button.text_offset,
+                foreground_color,
+                *theme.button.font_size,
+            );
+        }
+    }
+}
diff --git a/src/interface/elements/miscellanious/skill.rs b/src/interface/elements/miscellanious/skill.rs
index 2dd3c7431..e21c5ebd4 100644
--- a/src/interface/elements/miscellanious/skill.rs
+++ b/src/interface/elements/miscellanious/skill.rs
@@ -29,7 +29,7 @@ impl Element for SkillBox {
         self.skill.is_some()
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, _theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, _theme: &InterfaceTheme) {
         self.state.resolve(placement_resolver, &constraint!(30, 30));
     }
 
@@ -40,12 +40,12 @@ impl Element for SkillBox {
         }
     }
 
-    fn left_click(&mut self, _force_update: &mut bool) -> Option<ClickAction> {
+    fn left_click(&mut self, _force_update: &mut bool) -> Vec<ClickAction> {
         if let Some(skill) = &self.skill {
-            return Some(ClickAction::MoveSkill(self.source, skill.clone()));
+            return vec![ClickAction::MoveSkill(self.source, skill.clone())];
         }
 
-        None
+        Vec::new()
     }
 
     fn drop_skill(&mut self, skill_source: SkillSource, skill: Skill) -> Option<SkillMove> {
@@ -62,7 +62,7 @@ impl Element for SkillBox {
         renderer: &InterfaceRenderer,
         _state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/miscellanious/slider.rs b/src/interface/elements/miscellanious/slider.rs
index 0f7ad19ec..335f29a0b 100644
--- a/src/interface/elements/miscellanious/slider.rs
+++ b/src/interface/elements/miscellanious/slider.rs
@@ -30,7 +30,7 @@ impl<T: Zero + NumOps + NumCast + Copy + PartialOrd> Element for Slider<T> {
         &mut self.state
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         self.state.resolve(placement_resolver, &theme.slider.size_constraint);
     }
 
@@ -53,8 +53,8 @@ impl<T: Zero + NumOps + NumCast + Copy + PartialOrd> Element for Slider<T> {
         }
     }
 
-    fn left_click(&mut self, _force_update: &mut bool) -> Option<ClickAction> {
-        Some(ClickAction::DragElement)
+    fn left_click(&mut self, _force_update: &mut bool) -> Vec<ClickAction> {
+        vec![ClickAction::DragElement]
     }
 
     fn drag(&mut self, mouse_delta: Position) -> Option<ChangeEvent> {
@@ -78,7 +78,7 @@ impl<T: Zero + NumOps + NumCast + Copy + PartialOrd> Element for Slider<T> {
         renderer: &InterfaceRenderer,
         _state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/miscellanious/static_label.rs b/src/interface/elements/miscellanious/static_label.rs
index 001668ec2..7576d31e2 100644
--- a/src/interface/elements/miscellanious/static_label.rs
+++ b/src/interface/elements/miscellanious/static_label.rs
@@ -19,7 +19,7 @@ impl Element for StaticLabel {
         &mut self.state
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         let mut size_constraint = theme.label.size_constraint;
 
         let size = placement_resolver.get_text_dimensions(
@@ -41,7 +41,7 @@ impl Element for StaticLabel {
         renderer: &InterfaceRenderer,
         _state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         _hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/miscellanious/text.rs b/src/interface/elements/miscellanious/text.rs
index 13b06323a..58ed71f43 100644
--- a/src/interface/elements/miscellanious/text.rs
+++ b/src/interface/elements/miscellanious/text.rs
@@ -19,12 +19,12 @@ impl<T: AsRef<str> + 'static> Text<T> {
         self
     }
 
-    pub fn with_foreground_color(mut self, foreground_color: impl Fn(&Theme) -> Color + 'static) -> Self {
+    pub fn with_foreground_color(mut self, foreground_color: impl Fn(&InterfaceTheme) -> Color + 'static) -> Self {
         self.foreground_color = Some(Box::new(foreground_color));
         self
     }
 
-    pub fn with_font_size(mut self, font_size: impl Fn(&Theme) -> f32 + 'static) -> Self {
+    pub fn with_font_size(mut self, font_size: impl Fn(&InterfaceTheme) -> f32 + 'static) -> Self {
         self.font_size = Some(Box::new(font_size));
         self
     }
@@ -34,7 +34,7 @@ impl<T: AsRef<str> + 'static> Text<T> {
         self
     }
 
-    fn get_font_size(&self, theme: &Theme) -> f32 {
+    fn get_font_size(&self, theme: &InterfaceTheme) -> f32 {
         self.font_size
             .as_ref()
             .map(|closure| closure(theme))
@@ -51,7 +51,7 @@ impl<T: AsRef<str> + 'static> Element for Text<T> {
         &mut self.state
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         let height_constraint = DimensionConstraint {
             size: Dimension::Absolute(self.get_font_size(theme)),
             minimum_size: None,
@@ -77,7 +77,7 @@ impl<T: AsRef<str> + 'static> Element for Text<T> {
         renderer: &InterfaceRenderer,
         _state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         _hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/profiler/frame.rs b/src/interface/elements/profiler/frame.rs
index b6e3575ba..aeb43a645 100644
--- a/src/interface/elements/profiler/frame.rs
+++ b/src/interface/elements/profiler/frame.rs
@@ -36,7 +36,7 @@ impl Element for FrameView {
         false
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, _theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, _theme: &InterfaceTheme) {
         let size_constraint = &constraint!(100%, 300);
         self.state.resolve(placement_resolver, size_constraint);
     }
@@ -59,7 +59,7 @@ impl Element for FrameView {
         }
     }
 
-    fn left_click(&mut self, _update: &mut bool) -> Option<ClickAction> {
+    fn left_click(&mut self, _update: &mut bool) -> Vec<ClickAction> {
         let visible_thread = *self.visible_thread.borrow();
         let mouse_position = self.state.mouse_position.get();
         let number_of_frames = get_number_of_saved_frames(visible_thread);
@@ -68,7 +68,7 @@ impl Element for FrameView {
         let clicked_frame = (mouse_position.x / bar_width) as usize;
 
         let measurement = get_frame_by_index(visible_thread, clicked_frame);
-        Some(ClickAction::OpenWindow(Box::new(FrameInspectorWindow::new(measurement))))
+        vec![ClickAction::OpenWindow(Box::new(FrameInspectorWindow::new(measurement)))]
     }
 
     fn render(
@@ -77,7 +77,7 @@ impl Element for FrameView {
         renderer: &InterfaceRenderer,
         _state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        _theme: &Theme,
+        _theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         _hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/profiler/inspector.rs b/src/interface/elements/profiler/inspector.rs
index 690db2e62..cfcaf9eb4 100644
--- a/src/interface/elements/profiler/inspector.rs
+++ b/src/interface/elements/profiler/inspector.rs
@@ -40,7 +40,7 @@ impl FrameInspectorView {
 
     fn render_lines(
         renderer: &mut ElementRenderer<'_>,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         text: &str,
         text_width: f32,
         mut x_position: f32,
@@ -82,7 +82,7 @@ impl FrameInspectorView {
     fn render_measurement(
         renderer: &mut ElementRenderer<'_>,
         color_lookup: &mut super::ColorLookup,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         measurement: &Measurement,
         start_time: Instant,
         total_width: f32,
@@ -168,7 +168,7 @@ impl Element for FrameInspectorView {
         false
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, _theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, _theme: &InterfaceTheme) {
         let size_constraint = &constraint!(100%, 300);
         self.state.resolve(placement_resolver, size_constraint);
     }
@@ -204,7 +204,7 @@ impl Element for FrameInspectorView {
         renderer: &InterfaceRenderer,
         _state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         _hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/values/color.rs b/src/interface/elements/values/color.rs
index e1bd835eb..ab424f846 100644
--- a/src/interface/elements/values/color.rs
+++ b/src/interface/elements/values/color.rs
@@ -25,7 +25,7 @@ impl Element for ColorValue {
         &mut self.state
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         self.state.resolve(placement_resolver, &theme.value.size_constraint);
     }
 
@@ -35,7 +35,7 @@ impl Element for ColorValue {
         renderer: &InterfaceRenderer,
         _state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         _hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/values/mutable/color.rs b/src/interface/elements/values/mutable/color.rs
index b8cad00e0..c04f323ca 100644
--- a/src/interface/elements/values/mutable/color.rs
+++ b/src/interface/elements/values/mutable/color.rs
@@ -40,7 +40,7 @@ impl Element for MutableColorValue {
         &mut self.state
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         self.state.resolve(placement_resolver, &theme.value.size_constraint);
     }
 
@@ -66,12 +66,12 @@ impl Element for MutableColorValue {
         }
     }
 
-    fn left_click(&mut self, _force_update: &mut bool) -> Option<ClickAction> {
-        Some(ClickAction::OpenWindow(Box::new(ColorWindow::new(
+    fn left_click(&mut self, _force_update: &mut bool) -> Vec<ClickAction> {
+        vec![ClickAction::OpenWindow(Box::new(ColorWindow::new(
             self.name.clone(),
             self.color_pointer,
             self.change_event,
-        ))))
+        )))]
     }
 
     fn render(
@@ -80,7 +80,7 @@ impl Element for MutableColorValue {
         renderer: &InterfaceRenderer,
         _state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/values/mutable/number.rs b/src/interface/elements/values/mutable/number.rs
index 1f7201948..f17c6005a 100644
--- a/src/interface/elements/values/mutable/number.rs
+++ b/src/interface/elements/values/mutable/number.rs
@@ -47,7 +47,7 @@ impl<T: Zero + NumOps + NumCast + Copy + PartialOrd + Display + 'static> Element
         &mut self.state
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         self.state.resolve(placement_resolver, &theme.value.size_constraint);
     }
 
@@ -70,14 +70,14 @@ impl<T: Zero + NumOps + NumCast + Copy + PartialOrd + Display + 'static> Element
         }
     }
 
-    fn left_click(&mut self, _force_update: &mut bool) -> Option<ClickAction> {
-        Some(ClickAction::OpenWindow(Box::new(NumberWindow::new(
+    fn left_click(&mut self, _force_update: &mut bool) -> Vec<ClickAction> {
+        vec![ClickAction::OpenWindow(Box::new(NumberWindow::new(
             self.name.clone(),
             self.inner_pointer,
             self.minimum_value,
             self.maximum_value,
             self.change_event,
-        ))))
+        )))]
     }
 
     fn render(
@@ -86,7 +86,7 @@ impl<T: Zero + NumOps + NumCast + Copy + PartialOrd + Display + 'static> Element
         renderer: &InterfaceRenderer,
         _state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/values/mutable/vector.rs b/src/interface/elements/values/mutable/vector.rs
index 970d9323c..c56ea7f4a 100644
--- a/src/interface/elements/values/mutable/vector.rs
+++ b/src/interface/elements/values/mutable/vector.rs
@@ -60,7 +60,7 @@ where
         &mut self.state
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         self.state.resolve(placement_resolver, &theme.value.size_constraint);
     }
 
@@ -83,7 +83,7 @@ where
         }
     }
 
-    fn left_click(&mut self, _force_update: &mut bool) -> Option<ClickAction> {
+    fn left_click(&mut self, _force_update: &mut bool) -> Vec<ClickAction> {
         let prototype_window = VectorWindow::new(
             self.name.clone(),
             self.inner_pointer,
@@ -92,7 +92,7 @@ where
             self.change_event,
         );
 
-        Some(ClickAction::OpenWindow(Box::new(prototype_window)))
+        vec![ClickAction::OpenWindow(Box::new(prototype_window))]
     }
 
     fn render(
@@ -101,7 +101,7 @@ where
         renderer: &InterfaceRenderer,
         _state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         hovered_element: Option<&dyn Element>,
diff --git a/src/interface/elements/values/string.rs b/src/interface/elements/values/string.rs
index ccd0d57c5..021f74b35 100644
--- a/src/interface/elements/values/string.rs
+++ b/src/interface/elements/values/string.rs
@@ -19,7 +19,7 @@ impl Element for StringValue {
         &mut self.state
     }
 
-    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &Theme) {
+    fn resolve(&mut self, placement_resolver: &mut PlacementResolver, _interface_settings: &InterfaceSettings, theme: &InterfaceTheme) {
         self.state.resolve(placement_resolver, &theme.value.size_constraint);
     }
 
@@ -29,7 +29,7 @@ impl Element for StringValue {
         renderer: &InterfaceRenderer,
         _state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         parent_position: Position,
         clip_size: ClipSize,
         _hovered_element: Option<&dyn Element>,
diff --git a/src/interface/event/action.rs b/src/interface/event/action.rs
index 704cddb2c..8f7d15269 100644
--- a/src/interface/event/action.rs
+++ b/src/interface/event/action.rs
@@ -1,6 +1,6 @@
 use super::{ItemSource, SkillSource};
 use crate::input::UserEvent;
-use crate::interface::{ChangeEvent, FocusMode, PrototypeWindow};
+use crate::interface::{ChangeEvent, ElementCell, FocusMode, Position, PrototypeWindow, Size, Tracker};
 use crate::inventory::{Item, Skill};
 
 pub enum ClickAction {
@@ -14,4 +14,10 @@ pub enum ClickAction {
     MoveInterface,
     OpenWindow(Box<dyn PrototypeWindow>),
     CloseWindow,
+    OpenPopup {
+        element: ElementCell,
+        position_tracker: Tracker<Position>,
+        size_tracker: Tracker<Size>,
+    },
+    ClosePopup,
 }
diff --git a/src/interface/layout/resolver.rs b/src/interface/layout/resolver.rs
index 01cf51878..8a4b33bdc 100644
--- a/src/interface/layout/resolver.rs
+++ b/src/interface/layout/resolver.rs
@@ -22,18 +22,11 @@ pub struct PlacementResolver {
 }
 
 impl PlacementResolver {
-    pub fn new(
-        font_loader: Rc<RefCell<FontLoader>>,
-        mut available_space: PartialSize,
-        base_position: Position,
-        border: Size,
-        gaps: Size,
-        scaling: f32,
-    ) -> Self {
+    pub fn new(font_loader: Rc<RefCell<FontLoader>>, mut available_space: PartialSize, border: Size, gaps: Size, scaling: f32) -> Self {
         available_space.x -= border.x * scaling * 2.0;
         available_space.y = available_space.y.map(|height| height - border.y * scaling * 2.0);
 
-        let base_position = base_position * scaling + border * scaling;
+        let base_position = border * scaling;
         let horizontal_accumulator = 0.0;
         let vertical_offset = 0.0;
         let total_height = 0.0;
diff --git a/src/interface/mod.rs b/src/interface/mod.rs
index e5167758d..b984ef163 100644
--- a/src/interface/mod.rs
+++ b/src/interface/mod.rs
@@ -10,7 +10,7 @@ mod cursor;
 mod windows;
 
 use std::cell::RefCell;
-use std::marker::PhantomData;
+use std::marker::{ConstParamTy, PhantomData};
 use std::rc::Rc;
 
 use cgmath::Vector2;
@@ -25,7 +25,8 @@ pub use self::layout::*;
 pub use self::provider::StateProvider;
 pub use self::settings::InterfaceSettings;
 pub use self::state::{Remote, TrackedState};
-pub use self::theme::Theme;
+pub use self::theme::{GameTheme, InterfaceTheme};
+use self::theme::{Main, Menu, ThemeSelector, Themes};
 pub use self::windows::*;
 #[cfg(feature = "debug")]
 use crate::debug::*;
@@ -36,25 +37,25 @@ use crate::network::{ClientTick, EntityId};
 
 // TODO: move this
 pub type Selector = Box<dyn Fn() -> bool>;
-pub type ColorSelector = Box<dyn Fn(&Theme) -> Color>;
-pub type FontSizeSelector = Box<dyn Fn(&Theme) -> f32>;
+pub type ColorSelector = Box<dyn Fn(&InterfaceTheme) -> Color>;
+pub type FontSizeSelector = Box<dyn Fn(&InterfaceTheme) -> f32>;
 
 pub trait ElementEvent {
-    fn trigger(&mut self) -> Option<ClickAction>;
+    fn trigger(&mut self) -> Vec<ClickAction>;
 }
 
 impl<F> ElementEvent for Box<F>
 where
-    F: FnMut() -> Option<ClickAction> + 'static,
+    F: FnMut() -> Vec<ClickAction> + 'static,
 {
-    fn trigger(&mut self) -> Option<ClickAction> {
+    fn trigger(&mut self) -> Vec<ClickAction> {
         self()
     }
 }
 
 impl ElementEvent for UserEvent {
-    fn trigger(&mut self) -> Option<ClickAction> {
-        Some(ClickAction::Event(self.clone()))
+    fn trigger(&mut self) -> Vec<ClickAction> {
+        vec![ClickAction::Event(self.clone())]
     }
 }
 
@@ -122,12 +123,24 @@ impl<T> PostUpdate<T> {
     }
 }
 
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub enum ThemeKind {
+    Menu,
+    #[default]
+    Main,
+    Game,
+}
+
+impl ConstParamTy for ThemeKind {}
+
+pub type Tracker<T> = Box<dyn Fn() -> Option<T>>;
+
 pub struct Interface {
     windows: Vec<(Window, PostUpdate<PerWindow>)>,
     window_cache: WindowCache,
     interface_settings: InterfaceSettings,
     available_space: Size,
-    theme: Theme,
+    themes: Themes,
     dialog_handle: Option<DialogHandle>,
     mouse_cursor: MouseCursor,
     mouse_cursor_hidden: bool,
@@ -143,7 +156,12 @@ impl Interface {
     ) -> Self {
         let window_cache = WindowCache::new();
         let interface_settings = InterfaceSettings::new();
-        let theme = Theme::new(&interface_settings.theme_file);
+        let themes = Themes {
+            theme_selector: ThemeSelector,
+            menu: InterfaceTheme::new::<Menu>(interface_settings.menu_theme.get_file()),
+            main: InterfaceTheme::new::<Main>(interface_settings.main_theme.get_file()),
+            game: GameTheme::new(interface_settings.game_theme.get_file()),
+        };
         let dialog_handle = None;
         let mouse_cursor = MouseCursor::new(game_file_loader, sprite_loader, action_loader);
         let mouse_cursor_hidden = false;
@@ -155,7 +173,7 @@ impl Interface {
             window_cache,
             interface_settings,
             available_space,
-            theme,
+            themes,
             dialog_handle,
             mouse_cursor,
             mouse_cursor_hidden,
@@ -163,24 +181,38 @@ impl Interface {
         }
     }
 
-    pub fn set_theme_file(&mut self, theme_file: String) {
-        self.interface_settings.theme_file = theme_file;
+    pub fn set_theme_file(&mut self, theme_file: String, theme_kind: ThemeKind) {
+        match theme_kind {
+            ThemeKind::Menu => self.interface_settings.menu_theme.set_file(theme_file),
+            ThemeKind::Main => self.interface_settings.main_theme.set_file(theme_file),
+            ThemeKind::Game => self.interface_settings.game_theme.set_file(theme_file),
+        }
     }
 
-    #[profile]
-    pub fn save_theme(&self) {
-        self.theme.save(&self.interface_settings.theme_file);
+    pub fn get_game_theme(&self) -> &GameTheme {
+        &self.themes.game
     }
 
     #[profile]
-    pub fn reload_theme(&mut self) {
-        if self.theme.reload(&self.interface_settings.theme_file) {
-            self.post_update.resolve();
+    pub fn save_theme(&self, kind: ThemeKind) {
+        match kind {
+            ThemeKind::Menu => self.themes.menu.save(self.interface_settings.menu_theme.get_file()),
+            ThemeKind::Main => self.themes.main.save(self.interface_settings.main_theme.get_file()),
+            ThemeKind::Game => self.themes.game.save(self.interface_settings.game_theme.get_file()),
         }
     }
 
-    pub fn get_theme(&self) -> &Theme {
-        &self.theme
+    #[profile]
+    pub fn reload_theme(&mut self, kind: ThemeKind) {
+        let success = match kind {
+            ThemeKind::Menu => self.themes.menu.reload(self.interface_settings.menu_theme.get_file()),
+            ThemeKind::Main => self.themes.main.reload(self.interface_settings.main_theme.get_file()),
+            ThemeKind::Game => self.themes.game.reload(self.interface_settings.game_theme.get_file()),
+        };
+
+        if success {
+            self.post_update.resolve();
+        }
     }
 
     pub fn schedule_render(&mut self) {
@@ -243,8 +275,14 @@ impl Interface {
                 profile_block!("resolve window");
 
                 let (_position, previous_size) = window.get_area();
+                let theme = match window.get_theme_kind() {
+                    ThemeKind::Menu => &self.themes.menu,
+                    ThemeKind::Main => &self.themes.main,
+                    _ => panic!(),
+                };
+
                 let (window_class, new_position, new_size) =
-                    window.resolve(font_loader.clone(), &self.interface_settings, &self.theme, self.available_space);
+                    window.resolve(font_loader.clone(), &self.interface_settings, theme, self.available_space);
 
                 // should only ever be the last window
                 if let Some(focused_index) = focus_state.focused_window()
@@ -318,7 +356,7 @@ impl Interface {
     }
 
     #[profile]
-    pub fn left_click_element(&mut self, hovered_element: &ElementCell, window_index: usize) -> Option<ClickAction> {
+    pub fn left_click_element(&mut self, hovered_element: &ElementCell, window_index: usize) -> Vec<ClickAction> {
         let (_, post_update) = &mut self.windows[window_index];
         let mut resolve = false;
 
@@ -332,7 +370,7 @@ impl Interface {
     }
 
     #[profile]
-    pub fn right_click_element(&mut self, hovered_element: &ElementCell, window_index: usize) -> Option<ClickAction> {
+    pub fn right_click_element(&mut self, hovered_element: &ElementCell, window_index: usize) -> Vec<ClickAction> {
         let (_, post_update) = &mut self.windows[window_index];
         let mut resolve = false;
 
@@ -365,17 +403,18 @@ impl Interface {
     }
 
     #[profile]
-    pub fn input_character_element(&mut self, element: &ElementCell, window_index: usize, character: char) -> Option<ClickAction> {
+    pub fn input_character_element(&mut self, element: &ElementCell, window_index: usize, character: char) -> Vec<ClickAction> {
         let (_, post_update) = &mut self.windows[window_index];
+        let mut propagated_actions = Vec::new();
 
-        if let Some(click_event) = element.borrow_mut().input_character(character) {
-            match click_event {
+        for action in element.borrow_mut().input_character(character) {
+            match action {
                 ClickAction::ChangeEvent(change_event) => Self::handle_change_event(&mut self.post_update, post_update, change_event),
-                other => return Some(other),
+                other => propagated_actions.push(other),
             }
         }
 
-        None
+        propagated_actions
     }
 
     #[profile]
@@ -391,8 +430,14 @@ impl Interface {
     pub fn resize_window(&mut self, window_index: usize, growth: Size) {
         let (window, post_update) = &mut self.windows[window_index];
 
+        let theme = match window.get_theme_kind() {
+            ThemeKind::Menu => &self.themes.menu,
+            ThemeKind::Main => &self.themes.main,
+            _ => panic!(),
+        };
         let (_position, previous_size) = window.get_area();
-        let (window_class, new_size) = window.resize(&self.interface_settings, &self.theme, self.available_space, growth);
+
+        let (window_class, new_size) = window.resize(&self.interface_settings, theme, self.available_space, growth);
 
         if previous_size != new_size {
             if let Some(window_class) = window_class {
@@ -420,7 +465,7 @@ impl Interface {
                 let (position, scale) = {
                     let (window, post_update) = &mut self.windows[window_index];
 
-                    if window.has_transparency(&self.theme) {
+                    if window.has_transparency(&self.themes.main) {
                         self.post_update.render();
                         return;
                     }
@@ -448,16 +493,22 @@ impl Interface {
         let focused_element = focused_element.map(|element| unsafe { &*element.as_ptr() });
 
         for (window, post_update) in &mut self.windows {
-            if self.post_update.needs_render() || post_update.take_render() {
+            if post_update.take_render() || self.post_update.needs_render() {
                 #[cfg(feature = "debug")]
                 profile_block!("render window");
 
+                let theme = match window.get_theme_kind() {
+                    ThemeKind::Menu => &self.themes.menu,
+                    ThemeKind::Main => &self.themes.main,
+                    _ => panic!(),
+                };
+
                 window.render(
                     render_target,
                     renderer,
                     state_provider,
                     &self.interface_settings,
-                    &self.theme,
+                    theme,
                     hovered_element,
                     focused_element,
                     mouse_mode,
@@ -498,9 +549,9 @@ impl Interface {
         renderer.render_text(
             render_target,
             &frames_per_second.to_string(),
-            *self.theme.overlay.text_offset * *self.interface_settings.scaling,
-            *self.theme.overlay.foreground_color,
-            *self.theme.overlay.font_size * *self.interface_settings.scaling,
+            *self.themes.game.overlay.text_offset * *self.interface_settings.scaling,
+            *self.themes.game.overlay.foreground_color,
+            *self.themes.game.overlay.font_size * *self.interface_settings.scaling,
         );
     }
 
@@ -521,7 +572,7 @@ impl Interface {
                 renderer,
                 mouse_position,
                 grabbed,
-                *self.theme.cursor.color,
+                *self.themes.game.cursor.color,
                 &self.interface_settings,
             );
         }
@@ -553,6 +604,26 @@ impl Interface {
         }
     }
 
+    #[profile]
+    pub fn open_popup(
+        &mut self,
+        element: ElementCell,
+        position_tracker: Tracker<Position>,
+        size_tracker: Tracker<Size>,
+        window_index: usize,
+    ) {
+        let entry = &mut self.windows[window_index];
+        entry.0.open_popup(element, position_tracker, size_tracker);
+        entry.1.resolve();
+    }
+
+    #[profile]
+    pub fn close_popup(&mut self, window_index: usize) {
+        let entry = &mut self.windows[window_index];
+        entry.0.close_popup();
+        entry.1.render();
+    }
+
     #[profile]
     pub fn open_dialog_window(&mut self, focus_state: &mut FocusState, text: String, npc_id: EntityId) {
         if let Some(dialog_handle) = &mut self.dialog_handle {
@@ -616,9 +687,9 @@ impl Interface {
     #[profile]
     #[cfg(feature = "debug")]
     pub fn open_theme_viewer_window(&mut self, focus_state: &mut FocusState) {
-        if !self.window_exists(self.theme.window_class()) {
+        if !self.window_exists(self.themes.window_class()) {
             let window = self
-                .theme
+                .themes
                 .to_window(&self.window_cache, &self.interface_settings, self.available_space);
 
             self.open_new_window(focus_state, window);
@@ -663,9 +734,16 @@ impl Interface {
     }
 
     #[profile]
-    pub fn close_all_windows(&mut self, focus_state: &mut FocusState) {
+    pub fn close_all_windows_except(&mut self, focus_state: &mut FocusState) {
         for index in (0..self.windows.len()).rev() {
-            self.close_window(focus_state, index);
+            if self.windows[index]
+                .0
+                .get_window_class()
+                .map(|class| class != "theme_viewer" && class != "profiler" && class != "network") // HACK: don't hardcode
+                .unwrap_or(true)
+            {
+                self.close_window(focus_state, index);
+            }
         }
     }
 
diff --git a/src/interface/provider.rs b/src/interface/provider.rs
index bbd2f79f5..76bef7918 100644
--- a/src/interface/provider.rs
+++ b/src/interface/provider.rs
@@ -3,12 +3,10 @@ use derive_new::new;
 use crate::graphics::GraphicsSettings;
 #[cfg(feature = "debug")]
 use crate::graphics::RenderSettings;
-use crate::network::LoginSettings;
 
 #[derive(new)]
 pub struct StateProvider<'t> {
     pub graphics_settings: &'t GraphicsSettings,
     #[cfg(feature = "debug")]
     pub render_settings: &'t RenderSettings,
-    pub login_settings: &'t LoginSettings,
 }
diff --git a/src/interface/settings.rs b/src/interface/settings.rs
index b87bd5706..a6d46da9f 100644
--- a/src/interface/settings.rs
+++ b/src/interface/settings.rs
@@ -1,24 +1,85 @@
 use procedural::*;
 use ron::ser::PrettyConfig;
 use serde::{Deserialize, Serialize};
+use walkdir::WalkDir;
 
 #[cfg(feature = "debug")]
 use crate::debug::*;
 use crate::interface::*;
 
+#[derive(Serialize, Deserialize)]
+#[serde(transparent)]
+pub struct ThemeSelector<const KIND: ThemeKind>(pub String);
+
+impl<const KIND: ThemeKind> ThemeSelector<KIND> {
+    pub fn get_file(&self) -> &str {
+        &self.0
+    }
+
+    pub fn set_file(&mut self, file: String) {
+        self.0 = file;
+    }
+}
+
+impl<const KIND: ThemeKind> PrototypeElement for ThemeSelector<KIND> {
+    fn to_element(&self, display: String) -> ElementCell {
+        let state = TrackedState::new(self.0.clone());
+
+        let themes = WalkDir::new("client/themes/")
+            .into_iter()
+            .filter_map(|entry| entry.ok())
+            .filter(|entry| entry.file_type().is_file())
+            .filter_map(|path| {
+                let name = path.path().file_name()?.to_str()?.strip_suffix(".ron")?.to_owned();
+                let file_path = format!("client/themes/{}.ron", name);
+                Some((name, file_path))
+            })
+            .collect();
+
+        let elements = vec![
+            Text::default().with_text(display).with_width(dimension!(50%)).wrap(),
+            PickList::default()
+                .with_options(themes)
+                .with_selected(state.clone())
+                .with_event(Box::new(move || {
+                    vec![ClickAction::Event(UserEvent::SetThemeFile {
+                        theme_file: state.get(),
+                        theme_kind: KIND,
+                    })]
+                }))
+                .with_width(dimension!(!))
+                .wrap(),
+        ];
+
+        Container::new(elements).wrap()
+    }
+}
+
 #[derive(Serialize, Deserialize, PrototypeElement)]
 pub struct InterfaceSettings {
     #[name("Scaling")]
     pub scaling: MutableRange<f32, Resolve>,
-    #[hidden_element]
-    pub theme_file: String,
+    #[name("Main theme")]
+    pub main_theme: ThemeSelector<{ ThemeKind::Main }>,
+    #[name("Menu theme")]
+    pub menu_theme: ThemeSelector<{ ThemeKind::Menu }>,
+    #[name("Game theme")]
+    pub game_theme: ThemeSelector<{ ThemeKind::Game }>,
 }
 
 impl Default for InterfaceSettings {
     fn default() -> Self {
         let scaling = MutableRange::new(1.0, 0.7, 1.7);
-        let theme_file = "client/themes/theme.ron".to_string();
-        Self { scaling, theme_file }
+        let main_theme = ThemeSelector("client/themes/main.ron".to_string());
+        let menu_theme = ThemeSelector("client/themes/menu.ron".to_string());
+        let game_theme = ThemeSelector("client/themes/game.ron".to_string());
+
+        Self {
+            scaling,
+            main_theme,
+            menu_theme,
+            game_theme,
+        }
     }
 }
 
diff --git a/src/interface/state.rs b/src/interface/state.rs
index ebbbc37d6..f78601829 100644
--- a/src/interface/state.rs
+++ b/src/interface/state.rs
@@ -49,6 +49,15 @@ impl<T> TrackedState<T> {
     }
 }
 
+impl<T> TrackedState<T>
+where
+    T: Clone,
+{
+    pub fn get(&self) -> T {
+        self.0.borrow().0.clone()
+    }
+}
+
 impl<T> TrackedState<Vec<T>> {
     pub fn clear(&mut self) {
         let mut inner = self.0.borrow_mut();
@@ -103,11 +112,11 @@ where
         inner.1 = inner.1.wrapping_add(1);
     }
 
-    pub fn toggle_action(&self) -> Box<impl FnMut() -> Option<ClickAction>> {
+    pub fn toggle_action(&self) -> Box<impl FnMut() -> Vec<ClickAction>> {
         let mut cloned = self.clone();
         Box::new(move || {
             cloned.toggle();
-            None
+            Vec::new()
         })
     }
 }
@@ -115,7 +124,7 @@ where
 impl TrackedState<bool> {
     pub fn selector(&self) -> impl Fn(&StateProvider) -> bool {
         let cloned = self.clone();
-        move |_: &StateProvider| *cloned.borrow()
+        move |_: &StateProvider| cloned.get()
     }
 }
 
@@ -131,6 +140,14 @@ pub struct Remote<T> {
 }
 
 impl<T> Remote<T> {
+    pub fn new(value: T) -> Remote<T> {
+        TrackedState::new(value).new_remote()
+    }
+
+    pub fn clone_state(&self) -> TrackedState<T> {
+        self.tracked_state.clone()
+    }
+
     pub fn borrow(&self) -> Ref<'_, T> {
         self.tracked_state.borrow()
     }
@@ -144,6 +161,15 @@ impl<T> Remote<T> {
     }
 }
 
+impl<T> Remote<T>
+where
+    T: Clone,
+{
+    pub fn get(&self) -> T {
+        self.tracked_state.get()
+    }
+}
+
 impl<T> Clone for Remote<T> {
     fn clone(&self) -> Self {
         let tracked_state = self.tracked_state.clone();
diff --git a/src/interface/theme.rs b/src/interface/theme.rs
index 6e3521ba6..351d060c8 100644
--- a/src/interface/theme.rs
+++ b/src/interface/theme.rs
@@ -8,6 +8,18 @@ use crate::debug::*;
 use crate::graphics::Color;
 use crate::interface::*;
 
+pub struct Menu;
+pub struct Main;
+
+pub trait ThemeType {}
+
+impl ThemeType for Menu {}
+impl ThemeType for Main {}
+
+pub trait ThemeDefault<T: ThemeType> {
+    fn default() -> Self;
+}
+
 #[derive(Serialize, Deserialize, PrototypeElement)]
 pub struct ButtonTheme {
     pub background_color: Mutable<Color, Render>,
@@ -26,7 +38,28 @@ pub struct ButtonTheme {
     pub height_constraint: DimensionConstraint,
 }
 
-impl Default for ButtonTheme {
+impl ThemeDefault<Menu> for ButtonTheme {
+    fn default() -> Self {
+        Self {
+            background_color: Mutable::new(Color::rgb(150, 70, 255)),
+            hovered_background_color: Mutable::new(Color::rgb(200, 70, 255)),
+            disabled_background_color: Mutable::new(Color::monochrome(70)),
+            foreground_color: Mutable::new(Color::monochrome(200)),
+            hovered_foreground_color: Mutable::new(Color::rgb(220, 170, 215)),
+            disabled_foreground_color: Mutable::new(Color::monochrome(140)),
+            debug_foreground_color: Mutable::new(Color::rgb(230, 140, 230)),
+            border_radius: MutableRange::new(Vector4::from_value(26.0), Vector4::from_value(0.0), Vector4::from_value(30.0)),
+            icon_offset: MutableRange::new(Vector2::new(7.0, 2.5), Vector2::zero(), Vector2::new(20.0, 20.0)),
+            icon_size: MutableRange::new(Vector2::new(16.0, 16.0), Vector2::zero(), Vector2::new(20.0, 20.0)),
+            icon_text_offset: MutableRange::new(Vector2::new(40.0, 4.0), Vector2::zero(), Vector2::new(100.0, 20.0)),
+            text_offset: MutableRange::new(Vector2::new(15.0, 6.0), Vector2::zero(), Vector2::new(100.0, 20.0)),
+            font_size: MutableRange::new(14.0, 6.0, 30.0),
+            height_constraint: dimension!(26),
+        }
+    }
+}
+
+impl ThemeDefault<Main> for ButtonTheme {
     fn default() -> Self {
         Self {
             background_color: Mutable::new(Color::monochrome(100)),
@@ -61,11 +94,28 @@ pub struct WindowTheme {
     pub title_height: DimensionConstraint,
 }
 
-impl Default for WindowTheme {
+impl ThemeDefault<Menu> for WindowTheme {
+    fn default() -> Self {
+        Self {
+            background_color: Mutable::new(Color::monochrome(30)),
+            title_background_color: Mutable::new(Color::rgba(70, 60, 70, 0)),
+            foreground_color: Mutable::new(Color::rgb(150, 70, 255)),
+            border_radius: MutableRange::new(Vector4::from_value(30.0), Vector4::from_value(0.0), Vector4::from_value(30.0)),
+            title_border_radius: MutableRange::new(Vector4::from_value(6.0), Vector4::from_value(0.0), Vector4::from_value(30.0)),
+            border_size: MutableRange::new(Vector2::new(30.0, 30.0), Vector2::zero(), Vector2::new(30.0, 30.0)),
+            text_offset: MutableRange::new(Vector2::new(5.0, -1.0), Vector2::zero(), Vector2::new(50.0, 30.0)),
+            gaps: MutableRange::new(Vector2::new(9.0, 19.0), Vector2::zero(), Vector2::new(20.0, 20.0)),
+            font_size: MutableRange::new(20.0, 6.0, 30.0),
+            title_height: dimension!(30),
+        }
+    }
+}
+
+impl ThemeDefault<Main> for WindowTheme {
     fn default() -> Self {
         Self {
             background_color: Mutable::new(Color::monochrome(40)),
-            title_background_color: Mutable::new(Color::rgb(70, 60, 70)),
+            title_background_color: Mutable::new(Color::rgb(170, 60, 70)),
             foreground_color: Mutable::new(Color::monochrome(160)),
             border_radius: MutableRange::new(Vector4::from_value(4.0), Vector4::from_value(0.0), Vector4::from_value(30.0)),
             title_border_radius: MutableRange::new(Vector4::from_value(6.0), Vector4::from_value(0.0), Vector4::from_value(30.0)),
@@ -94,7 +144,26 @@ pub struct ExpandableTheme {
     pub font_size: MutableRange<f32, Render>,
 }
 
-impl Default for ExpandableTheme {
+impl ThemeDefault<Menu> for ExpandableTheme {
+    fn default() -> Self {
+        Self {
+            background_color: Mutable::new(Color::monochrome(60)),
+            second_background_color: Mutable::new(Color::monochrome(45)),
+            foreground_color: Mutable::new(Color::monochrome(170)),
+            hovered_foreground_color: Mutable::new(Color::rgb(190, 145, 185)),
+            border_radius: MutableRange::new(Vector4::from_value(6.0), Vector4::from_value(0.0), Vector4::from_value(30.0)),
+            border_size: MutableRange::new(Vector2::new(5.0, 5.0), Vector2::zero(), Vector2::new(20.0, 20.0)),
+            element_offset: MutableRange::new(Vector2::new(7.0, -2.0), Vector2::new(-10.0, -10.0), Vector2::new(30.0, 30.0)),
+            icon_offset: MutableRange::new(Vector2::new(6.0, 5.0), Vector2::zero(), Vector2::new(30.0, 50.0)),
+            icon_size: MutableRange::new(Vector2::new(6.0, 6.0), Vector2::zero(), Vector2::new(20.0, 20.0)),
+            text_offset: MutableRange::new(Vector2::new(14.0, 1.5), Vector2::zero(), Vector2::new(50.0, 20.0)),
+            gaps: MutableRange::new(Vector2::new(6.0, 6.0), Vector2::zero(), Vector2::new(20.0, 20.0)),
+            font_size: MutableRange::new(14.0, 6.0, 30.0),
+        }
+    }
+}
+
+impl ThemeDefault<Main> for ExpandableTheme {
     fn default() -> Self {
         Self {
             background_color: Mutable::new(Color::monochrome(60)),
@@ -123,7 +192,20 @@ pub struct LabelTheme {
     pub size_constraint: SizeConstraint,
 }
 
-impl Default for LabelTheme {
+impl ThemeDefault<Menu> for LabelTheme {
+    fn default() -> Self {
+        Self {
+            background_color: Mutable::new(Color::monochrome(130)),
+            foreground_color: Mutable::new(Color::monochrome(255)),
+            border_radius: MutableRange::new(Vector4::from_value(6.0), Vector4::from_value(0.0), Vector4::from_value(30.0)),
+            text_offset: MutableRange::new(Vector2::new(5.0, 0.0), Vector2::from_value(-10.0), Vector2::from_value(20.0)),
+            font_size: MutableRange::new(14.0, 6.0, 30.0),
+            size_constraint: constraint!(120 > 50% < 300, 0),
+        }
+    }
+}
+
+impl ThemeDefault<Main> for LabelTheme {
     fn default() -> Self {
         Self {
             background_color: Mutable::new(Color::monochrome(130)),
@@ -147,7 +229,21 @@ pub struct ValueTheme {
     pub size_constraint: SizeConstraint,
 }
 
-impl Default for ValueTheme {
+impl ThemeDefault<Menu> for ValueTheme {
+    fn default() -> Self {
+        Self {
+            background_color: Mutable::new(Color::rgb(100, 100, 100)),
+            hovered_background_color: Mutable::new(Color::rgb(130, 100, 120)),
+            foreground_color: Mutable::new(Color::rgb(220, 220, 220)),
+            border_radius: MutableRange::new(Vector4::from_value(6.0), Vector4::from_value(0.0), Vector4::from_value(30.0)),
+            text_offset: MutableRange::new(Vector2::new(5.0, 0.0), Vector2::from_value(-10.0), Vector2::from_value(20.0)),
+            font_size: MutableRange::new(14.0, 6.0, 30.0),
+            size_constraint: constraint!(60 > !, 14),
+        }
+    }
+}
+
+impl ThemeDefault<Main> for ValueTheme {
     fn default() -> Self {
         Self {
             background_color: Mutable::new(Color::rgb(100, 100, 100)),
@@ -172,7 +268,21 @@ pub struct CloseButtonTheme {
     pub size_constraint: SizeConstraint,
 }
 
-impl Default for CloseButtonTheme {
+impl ThemeDefault<Menu> for CloseButtonTheme {
+    fn default() -> Self {
+        Self {
+            background_color: Mutable::new(Color::rgb(200, 100, 100)),
+            hovered_background_color: Mutable::new(Color::rgb(200, 140, 100)),
+            foreground_color: Mutable::new(Color::rgb(220, 220, 220)),
+            border_radius: MutableRange::new(Vector4::from_value(26.0), Vector4::from_value(0.0), Vector4::from_value(30.0)),
+            text_offset: MutableRange::new(Vector2::new(8.35, 2.55), Vector2::from_value(-10.0), Vector2::from_value(20.0)),
+            font_size: MutableRange::new(20.0, 6.0, 30.0),
+            size_constraint: constraint!(26, 26),
+        }
+    }
+}
+
+impl ThemeDefault<Main> for CloseButtonTheme {
     fn default() -> Self {
         Self {
             background_color: Mutable::new(Color::rgb(200, 100, 100)),
@@ -211,7 +321,18 @@ pub struct SliderTheme {
     pub size_constraint: SizeConstraint,
 }
 
-impl Default for SliderTheme {
+impl ThemeDefault<Menu> for SliderTheme {
+    fn default() -> Self {
+        Self {
+            background_color: Mutable::new(Color::rgb(140, 80, 100)),
+            rail_color: Mutable::new(Color::rgb(150, 130, 150)),
+            knob_color: Mutable::new(Color::rgb(100, 180, 180)),
+            size_constraint: constraint!(100%, 18),
+        }
+    }
+}
+
+impl ThemeDefault<Main> for SliderTheme {
     fn default() -> Self {
         Self {
             background_color: Mutable::new(Color::rgb(140, 80, 100)),
@@ -232,13 +353,32 @@ pub struct InputTheme {
     pub focused_text_color: Mutable<Color, Render>,
     pub border_radius: MutableRange<Vector4<f32>, Render>,
     pub font_size: MutableRange<f32, Render>,
-    pub text_offset: MutableRange<f32, Render>,
+    pub text_offset: MutableRange<Vector2<f32>, Render>,
     pub cursor_offset: MutableRange<f32, Render>,
     pub cursor_width: MutableRange<f32, Render>,
     pub height_constraint: DimensionConstraint,
 }
 
-impl Default for InputTheme {
+impl ThemeDefault<Menu> for InputTheme {
+    fn default() -> Self {
+        Self {
+            background_color: Mutable::new(Color::monochrome(45)),
+            hovered_background_color: Mutable::new(Color::rgb(70, 60, 80)),
+            focused_background_color: Mutable::new(Color::monochrome(100)),
+            text_color: Mutable::new(Color::monochrome(200)),
+            ghost_text_color: Mutable::new(Color::monochrome(100)),
+            focused_text_color: Mutable::new(Color::monochrome(200)),
+            border_radius: MutableRange::new(Vector4::from_value(26.0), Vector4::from_value(0.0), Vector4::from_value(30.0)),
+            font_size: MutableRange::new(15.0, 6.0, 50.0),
+            text_offset: MutableRange::new(Vector2::new(15.0, 6.0), Vector2::from_value(0.0), Vector2::from_value(50.0)),
+            cursor_offset: MutableRange::new(2.0, 0.0, 10.0),
+            cursor_width: MutableRange::new(3.0, 2.0, 30.0),
+            height_constraint: dimension!(26),
+        }
+    }
+}
+
+impl ThemeDefault<Main> for InputTheme {
     fn default() -> Self {
         Self {
             background_color: Mutable::new(Color::monochrome(60)),
@@ -249,7 +389,7 @@ impl Default for InputTheme {
             focused_text_color: Mutable::new(Color::monochrome(200)),
             border_radius: MutableRange::new(Vector4::from_value(6.0), Vector4::from_value(0.0), Vector4::from_value(30.0)),
             font_size: MutableRange::new(14.0, 6.0, 50.0),
-            text_offset: MutableRange::new(4.0, 2.0, 10.0),
+            text_offset: MutableRange::new(Vector2::new(4.0, 0.0), Vector2::from_value(0.0), Vector2::from_value(50.0)),
             cursor_offset: MutableRange::new(2.0, 0.0, 10.0),
             cursor_width: MutableRange::new(3.0, 2.0, 30.0),
             height_constraint: dimension!(15),
@@ -263,7 +403,16 @@ pub struct ChatTheme {
     pub font_size: MutableRange<f32, Render>,
 }
 
-impl Default for ChatTheme {
+impl ThemeDefault<Menu> for ChatTheme {
+    fn default() -> Self {
+        Self {
+            background_color: Mutable::new(Color::rgba(0, 0, 0, 170)),
+            font_size: MutableRange::new(14.0, 6.0, 50.0),
+        }
+    }
+}
+
+impl ThemeDefault<Main> for ChatTheme {
     fn default() -> Self {
         Self {
             background_color: Mutable::new(Color::rgba(0, 0, 0, 170)),
@@ -301,7 +450,26 @@ pub struct ProfilerTheme {
     pub distance_text_offset: MutableRange<f32, Render>,
 }
 
-impl Default for ProfilerTheme {
+impl ThemeDefault<Menu> for ProfilerTheme {
+    fn default() -> Self {
+        Self {
+            background_color: Mutable::new(Color::monochrome(55)),
+            border_radius: MutableRange::new(Vector4::from_value(2.0), Vector4::from_value(0.0), Vector4::from_value(30.0)),
+            line_color: Mutable::new(Color::rgb(80, 90, 80)),
+            line_width: MutableRange::new(2.0, 0.5, 4.0),
+            bar_height: MutableRange::new(15.0, 5.0, 30.0),
+            bar_gap: MutableRange::new(Vector2::new(1.0, 5.0), Vector2::from_value(0.0), Vector2::new(10.0, 20.0)),
+            bar_border_radius: MutableRange::new(Vector4::from_value(0.0), Vector4::from_value(0.0), Vector4::from_value(15.0)),
+            bar_text_color: Mutable::new(Color::monochrome(0)),
+            bar_text_size: MutableRange::new(14.0, 6.0, 50.0),
+            bar_text_offset: MutableRange::new(Vector2::new(7.0, 0.0), Vector2::new(0.0, -10.0), Vector2::new(40.0, 10.0)),
+            distance_text_size: MutableRange::new(12.0, 6.0, 50.0),
+            distance_text_offset: MutableRange::new(20.0, 0.0, 200.0),
+        }
+    }
+}
+
+impl ThemeDefault<Main> for ProfilerTheme {
     fn default() -> Self {
         Self {
             background_color: Mutable::new(Color::monochrome(55)),
@@ -376,10 +544,12 @@ pub struct ThemeSelector;
 impl PrototypeElement for ThemeSelector {
     fn to_element(&self, display: String) -> ElementCell {
         let theme_name = Rc::new(RefCell::new("".to_owned()));
-        let name_action = Box::new(move || Some(ClickAction::FocusNext(FocusMode::FocusNext)));
+        let name_action = Box::new(move || vec![ClickAction::FocusNext(FocusMode::FocusNext)]);
+        let theme_kind = TrackedState::new(ThemeKind::Main);
 
         let load_action = {
             let theme_name = theme_name.clone();
+            let theme_kind = theme_kind.clone();
 
             Box::new(move || {
                 let mut taken_name = String::new();
@@ -388,11 +558,44 @@ impl PrototypeElement for ThemeSelector {
 
                 let file_name = format!("client/themes/{}.ron", taken_name);
 
-                Some(ClickAction::Event(UserEvent::SetThemeFile(file_name)))
+                vec![ClickAction::Event(UserEvent::SetThemeFile {
+                    theme_file: file_name,
+                    theme_kind: theme_kind.get(),
+                })]
+            })
+        };
+
+        let save_action = {
+            let theme_kind = theme_kind.clone();
+
+            Box::new(move || {
+                vec![ClickAction::Event(UserEvent::SaveTheme {
+                    theme_kind: theme_kind.get(),
+                })]
+            })
+        };
+
+        let reload_action = {
+            let theme_kind = theme_kind.clone();
+
+            Box::new(move || {
+                vec![ClickAction::Event(UserEvent::ReloadTheme {
+                    theme_kind: theme_kind.get(),
+                })]
             })
         };
 
         let elements = vec![
+            PickList::default()
+                .with_options(vec![
+                    ("Menu", ThemeKind::Menu),
+                    ("Main", ThemeKind::Main),
+                    ("Game", ThemeKind::Game),
+                ])
+                .with_selected(theme_kind)
+                .with_event(Box::new(Vec::new))
+                .with_width(dimension!(!))
+                .wrap(),
             InputField::<40>::new(theme_name, "Theme name", name_action, dimension!(75%)).wrap(),
             Button::default()
                 .with_text("Load")
@@ -401,12 +604,12 @@ impl PrototypeElement for ThemeSelector {
                 .wrap(),
             Button::default()
                 .with_text("Save theme")
-                .with_event(UserEvent::SaveTheme)
+                .with_event(save_action)
                 .with_width(dimension!(50%))
                 .wrap(),
             Button::default()
                 .with_text("Reload theme")
-                .with_event(UserEvent::ReloadTheme)
+                .with_event(reload_action)
                 .with_width(dimension!(!))
                 .wrap(),
         ];
@@ -415,29 +618,113 @@ impl PrototypeElement for ThemeSelector {
     }
 }
 
-#[derive(Serialize, Deserialize, Default, PrototypeWindow)]
-#[window_title("Theme Viewer")]
-#[window_class("theme_viewer")]
-pub struct Theme {
-    #[serde(skip)]
-    pub theme_selector: ThemeSelector,
+#[derive(Serialize, Deserialize, PrototypeElement)]
+pub struct InterfaceTheme {
     pub button: ButtonTheme,
     pub window: WindowTheme,
     pub expandable: ExpandableTheme,
     pub label: LabelTheme,
     pub value: ValueTheme,
     pub close_button: CloseButtonTheme,
-    pub overlay: OverlayTheme,
     pub slider: SliderTheme,
     pub input: InputTheme,
-    pub chat: ChatTheme,
-    pub cursor: CursorTheme,
     pub profiler: ProfilerTheme,
+    pub chat: ChatTheme,
+}
+
+impl<T: ThemeType> ThemeDefault<T> for InterfaceTheme
+where
+    ButtonTheme: ThemeDefault<T>,
+    WindowTheme: ThemeDefault<T>,
+    ExpandableTheme: ThemeDefault<T>,
+    LabelTheme: ThemeDefault<T>,
+    ValueTheme: ThemeDefault<T>,
+    CloseButtonTheme: ThemeDefault<T>,
+    SliderTheme: ThemeDefault<T>,
+    InputTheme: ThemeDefault<T>,
+    ProfilerTheme: ThemeDefault<T>,
+    ChatTheme: ThemeDefault<T>,
+{
+    fn default() -> Self {
+        Self {
+            button: ThemeDefault::<T>::default(),
+            window: ThemeDefault::<T>::default(),
+            expandable: ThemeDefault::<T>::default(),
+            label: ThemeDefault::<T>::default(),
+            value: ThemeDefault::<T>::default(),
+            close_button: ThemeDefault::<T>::default(),
+            slider: ThemeDefault::<T>::default(),
+            input: ThemeDefault::<T>::default(),
+            profiler: ThemeDefault::<T>::default(),
+            chat: ThemeDefault::<T>::default(),
+        }
+    }
+}
+
+#[derive(Default, Serialize, Deserialize, PrototypeElement)]
+pub struct GameTheme {
+    pub overlay: OverlayTheme,
     pub status_bar: StatusBarTheme,
     pub indicator: IndicatorTheme,
+    pub cursor: CursorTheme,
+}
+
+#[derive(PrototypeWindow)]
+#[window_title("Theme Viewer")]
+#[window_class("theme_viewer")]
+pub struct Themes {
+    #[name("Theme selector")]
+    pub theme_selector: ThemeSelector,
+    #[name("Menu")]
+    pub menu: InterfaceTheme,
+    #[name("Main")]
+    pub main: InterfaceTheme,
+    #[name("Game")]
+    pub game: GameTheme,
+}
+
+impl InterfaceTheme {
+    pub fn new<T: ThemeType>(theme_file: &str) -> Self
+    where
+        Self: ThemeDefault<T>,
+    {
+        Self::load(theme_file).unwrap_or_else(|| {
+            #[cfg(feature = "debug")]
+            print_debug!("failed to load theme from file {}{}{}", MAGENTA, theme_file, NONE);
+
+            ThemeDefault::<T>::default()
+        })
+    }
+
+    fn load(theme_file: &str) -> Option<Self> {
+        #[cfg(feature = "debug")]
+        print_debug!("loading theme from {}{}{}", MAGENTA, theme_file, NONE);
+
+        std::fs::read_to_string(theme_file).ok().and_then(|data| ron::from_str(&data).ok())
+    }
+
+    pub fn reload(&mut self, theme_file: &str) -> bool {
+        let Some(theme) = Self::load(theme_file) else {
+            #[cfg(feature = "debug")]
+            print_debug!("failed to load theme from file {}{}{}", MAGENTA, theme_file, NONE);
+
+            return false;
+        };
+
+        *self = theme;
+        true
+    }
+
+    pub fn save(&self, theme_file: &str) {
+        #[cfg(feature = "debug")]
+        print_debug!("saving theme to {}{}{}", MAGENTA, theme_file, NONE);
+
+        let data = ron::ser::to_string_pretty(self, PrettyConfig::new()).unwrap();
+        std::fs::write(theme_file, data).expect("unable to write file");
+    }
 }
 
-impl Theme {
+impl GameTheme {
     pub fn new(theme_file: &str) -> Self {
         Self::load(theme_file).unwrap_or_else(|| {
             #[cfg(feature = "debug")]
diff --git a/src/interface/windows/account/login.rs b/src/interface/windows/account/login.rs
index 6cec55e11..990b3de07 100644
--- a/src/interface/windows/account/login.rs
+++ b/src/interface/windows/account/login.rs
@@ -7,27 +7,53 @@ use procedural::*;
 
 use crate::input::UserEvent;
 use crate::interface::*;
-use crate::loaders::Service;
+use crate::loaders::ClientInfo;
 use crate::network::LoginSettings;
 
 #[derive(new)]
-pub struct LoginWindow {
-    service: Service,
-    login_settings: LoginSettings,
+pub struct LoginWindow<'a> {
+    client_info: &'a ClientInfo,
 }
 
-impl LoginWindow {
+impl<'a> LoginWindow<'a> {
     pub const WINDOW_CLASS: &'static str = "login";
 }
 
-impl PrototypeWindow for LoginWindow {
+impl<'a> PrototypeWindow for LoginWindow<'a> {
     fn window_class(&self) -> Option<&str> {
         Self::WINDOW_CLASS.into()
     }
 
     fn to_window(&self, window_cache: &WindowCache, interface_settings: &InterfaceSettings, available_space: Size) -> Window {
-        let username = Rc::new(RefCell::new(self.login_settings.username.clone()));
-        let password = Rc::new(RefCell::new(self.login_settings.password.clone()));
+        let mut login_settings = LoginSettings::new();
+
+        let options = self
+            .client_info
+            .services
+            .iter()
+            .map(|service| (service.display_name.clone().unwrap(), service.service_id()))
+            .collect();
+
+        // FIX: This will panic when no services are present. What is the correct
+        // behavior?
+        let selected_service = login_settings
+            .recent_service_id
+            // Only use the recent server if it is still in the client info
+            .filter(|&recent_service_id| {
+                self.client_info
+                    .services
+                    .iter()
+                    .any(|service| service.service_id() == recent_service_id)
+            })
+            .unwrap_or_else(|| self.client_info.services[0].service_id());
+
+        let saved_settings = login_settings.service_settings.entry(selected_service).or_default();
+
+        let username = Rc::new(RefCell::new(saved_settings.username.clone()));
+        let password = Rc::new(RefCell::new(saved_settings.password.clone()));
+
+        let selected_service = TrackedState::new(selected_service);
+        let login_settings = Rc::new(RefCell::new(login_settings));
 
         let selector = {
             let username = username.clone();
@@ -35,17 +61,47 @@ impl PrototypeWindow for LoginWindow {
             move || !username.borrow().is_empty() && !password.borrow().is_empty()
         };
 
-        let action = {
+        let service_changed = {
             let username = username.clone();
             let password = password.clone();
-            let service = self.service.clone();
+            let login_settings = login_settings.clone();
+            let selected_service = selected_service.clone();
+
+            Box::new(move || {
+                let service_id = selected_service.get();
+                let login_settings = login_settings.borrow_mut();
+
+                if let Some(saved_settings) = login_settings.service_settings.get(&service_id) {
+                    *username.borrow_mut() = saved_settings.username.clone();
+                    *password.borrow_mut() = saved_settings.password.clone();
+                }
+
+                Vec::new()
+            })
+        };
+
+        let login_action = {
+            let username = username.clone();
+            let password = password.clone();
+            let login_settings = login_settings.clone();
+            let selected_service = selected_service.clone();
 
             move || {
-                Some(ClickAction::Event(UserEvent::LogIn(
-                    service.clone(),
-                    username.borrow().clone(),
-                    password.borrow().clone(),
-                )))
+                // TODO: Deduplicate code
+                let service_id = selected_service.get();
+
+                let mut login_settings = login_settings.borrow_mut();
+                login_settings.recent_service_id = Some(service_id);
+
+                let saved_settings = login_settings.service_settings.entry(service_id).or_default();
+                saved_settings.username = username.borrow().clone();
+                saved_settings.password = password.borrow().clone();
+
+                vec![ClickAction::Event(UserEvent::LogIn {
+                    service_id: selected_service.get(),
+                    username: username.borrow().clone(),
+                    password: password.borrow().clone(),
+                })]
             }
         };
 
@@ -56,45 +112,127 @@ impl PrototypeWindow for LoginWindow {
                     .borrow()
                     .is_empty()
                     .not()
-                    .then_some(ClickAction::FocusNext(FocusMode::FocusNext))
+                    .then_some(vec![ClickAction::FocusNext(FocusMode::FocusNext)])
+                    .unwrap_or_default()
             })
         };
 
         let password_action = {
             let username = username.clone();
             let password = password.clone();
-            let service = self.service.clone();
+            let login_settings = login_settings.clone();
+            let selected_service = selected_service.clone();
 
             Box::new(move || match password.borrow().is_empty() {
-                _ if username.borrow().is_empty() => Some(ClickAction::FocusNext(FocusMode::FocusPrevious)),
-                true => None,
-                false => Some(ClickAction::Event(UserEvent::LogIn(
-                    service.clone(),
-                    username.borrow().clone(),
-                    password.borrow().clone(),
-                ))),
+                _ if username.borrow().is_empty() => vec![ClickAction::FocusNext(FocusMode::FocusPrevious)],
+                true => Vec::new(),
+                false => {
+                    // TODO: Deduplicate code
+                    let service_id = selected_service.get();
+
+                    let mut login_settings = login_settings.borrow_mut();
+                    login_settings.recent_service_id = Some(service_id);
+
+                    let saved_settings = login_settings.service_settings.entry(service_id).or_default();
+                    saved_settings.username = username.borrow().clone();
+                    saved_settings.password = password.borrow().clone();
+
+                    vec![ClickAction::Event(UserEvent::LogIn {
+                        service_id: selected_service.get(),
+                        username: username.borrow().clone(),
+                        password: password.borrow().clone(),
+                    })]
+                }
+            })
+        };
+
+        let remember_username_selector = {
+            let login_settings = login_settings.clone();
+            let selected_service = selected_service.clone();
+
+            move |_: &StateProvider| {
+                let service_id = selected_service.get();
+                let mut login_settings = login_settings.borrow_mut();
+                let saved_settings = login_settings.service_settings.entry(service_id).or_default();
+
+                saved_settings.remember_username
+            }
+        };
+
+        let remember_password_selector = {
+            let login_settings = login_settings.clone();
+            let selected_service = selected_service.clone();
+
+            move |_: &StateProvider| {
+                let service_id = selected_service.get();
+                let mut login_settings = login_settings.borrow_mut();
+                let saved_settings = login_settings.service_settings.entry(service_id).or_default();
+
+                saved_settings.remember_password
+            }
+        };
+
+        let remember_username_action = {
+            let login_settings = login_settings.clone();
+            let selected_service = selected_service.clone();
+
+            Box::new(move || {
+                let service_id = selected_service.get();
+                let mut login_settings = login_settings.borrow_mut();
+                let saved_settings = login_settings.service_settings.entry(service_id).or_default();
+
+                saved_settings.remember_username = !saved_settings.remember_username;
+
+                Vec::new()
+            })
+        };
+
+        let remember_password_action = {
+            let login_settings = login_settings.clone();
+            let selected_service = selected_service.clone();
+
+            Box::new(move || {
+                let service_id = selected_service.get();
+                let mut login_settings = login_settings.borrow_mut();
+                let saved_settings = login_settings.service_settings.entry(service_id).or_default();
+
+                saved_settings.remember_password = !saved_settings.remember_password;
+
+                Vec::new()
             })
         };
 
         let elements = vec![
+            Text::default().with_text("Select service").wrap(),
+            PickList::default()
+                .with_options(options)
+                .with_selected(selected_service)
+                .with_event(service_changed)
+                .wrap(),
+            Text::default().with_text("Account data").wrap(),
             InputField::<24>::new(username, "Username", username_action, dimension!(100%)).wrap(),
             InputField::<24, true>::new(password, "Password", password_action, dimension!(100%)).wrap(),
-            StateButton::default()
-                .with_text("Remember username")
-                .with_selector(|state_provider| state_provider.login_settings.remember_username)
-                .with_event(UserEvent::ToggleRemeberUsername)
-                .with_transparent_background()
-                .wrap(),
-            StateButton::default()
-                .with_text("Remember password")
-                .with_selector(|state_provider| state_provider.login_settings.remember_password)
-                .with_event(UserEvent::ToggleRemeberPassword)
-                .with_transparent_background()
-                .wrap(),
+            Container::new({
+                vec![
+                    StateButton::default()
+                        .with_text("Remember username")
+                        .with_selector(remember_username_selector)
+                        .with_event(remember_username_action)
+                        .with_transparent_background()
+                        .wrap(),
+                    StateButton::default()
+                        .with_text("Remember password")
+                        .with_selector(remember_password_selector)
+                        .with_event(remember_password_action)
+                        .with_transparent_background()
+                        .wrap(),
+                ]
+            })
+            .wrap(),
             Button::default()
                 .with_text("Log in")
                 .with_disabled_selector(selector)
-                .with_event(Box::new(action))
+                .with_event(Box::new(login_action))
                 .wrap(),
         ];
 
@@ -103,6 +241,7 @@ impl PrototypeWindow for LoginWindow {
             .with_class(Self::WINDOW_CLASS.to_string())
             .with_size(constraint!(200 > 250 < 300, ? < 80%))
             .with_elements(elements)
+            .with_theme_kind(ThemeKind::Menu)
             .build(window_cache, interface_settings, available_space)
     }
 }
diff --git a/src/interface/windows/account/mod.rs b/src/interface/windows/account/mod.rs
index 55f164921..311a65d48 100644
--- a/src/interface/windows/account/mod.rs
+++ b/src/interface/windows/account/mod.rs
@@ -1,7 +1,5 @@
 mod login;
 mod select_server;
-mod select_service;
 
 pub use self::login::LoginWindow;
 pub use self::select_server::SelectServerWindow;
-pub use self::select_service::SelectServiceWindow;
diff --git a/src/interface/windows/account/select_server.rs b/src/interface/windows/account/select_server.rs
index 72eeda879..9d43f9374 100644
--- a/src/interface/windows/account/select_server.rs
+++ b/src/interface/windows/account/select_server.rs
@@ -36,6 +36,7 @@ impl PrototypeWindow for SelectServerWindow {
             .with_class(Self::WINDOW_CLASS.to_string())
             .with_size(constraint!(200 > 250 < 300, ? < 80%))
             .with_elements(elements)
+            .with_theme_kind(ThemeKind::Menu)
             .build(window_cache, interface_settings, available_space)
     }
 }
diff --git a/src/interface/windows/account/select_service.rs b/src/interface/windows/account/select_service.rs
deleted file mode 100644
index 1b464a0fb..000000000
--- a/src/interface/windows/account/select_service.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-use derive_new::new;
-use procedural::*;
-
-use crate::input::UserEvent;
-use crate::interface::*;
-use crate::loaders::Service;
-
-#[derive(new)]
-pub struct SelectServiceWindow {
-    services: Vec<Service>,
-}
-
-impl SelectServiceWindow {
-    pub const WINDOW_CLASS: &'static str = "service_select";
-}
-
-impl PrototypeWindow for SelectServiceWindow {
-    fn window_class(&self) -> Option<&str> {
-        Self::WINDOW_CLASS.into()
-    }
-
-    fn to_window(&self, window_cache: &WindowCache, interface_settings: &InterfaceSettings, available_space: Size) -> Window {
-        let elements = self
-            .services
-            .iter()
-            .map(|service| {
-                Button::default()
-                    .with_text(service.display_name.clone().unwrap())
-                    .with_event(UserEvent::SelectService(service.clone()))
-                    .wrap()
-            })
-            .collect();
-
-        WindowBuilder::default()
-            .with_title("Select Service".to_string())
-            .with_class(Self::WINDOW_CLASS.to_string())
-            .with_size(constraint!(200 > 250 < 300, ? < 80%))
-            .with_elements(elements)
-            .build(window_cache, interface_settings, available_space)
-    }
-}
diff --git a/src/interface/windows/builder.rs b/src/interface/windows/builder.rs
index b6beb9e50..013103389 100644
--- a/src/interface/windows/builder.rs
+++ b/src/interface/windows/builder.rs
@@ -10,6 +10,7 @@ pub struct WindowBuilder {
     elements: Vec<ElementCell>,
     closable: bool,
     background_color: Option<ColorSelector>,
+    theme_kind: ThemeKind,
 }
 
 impl WindowBuilder {
@@ -41,6 +42,11 @@ impl WindowBuilder {
         self
     }
 
+    pub fn with_theme_kind(mut self, theme_kind: ThemeKind) -> Self {
+        self.theme_kind = theme_kind;
+        self
+    }
+
     pub fn closable(mut self) -> Self {
         self.closable = true;
         self
@@ -54,6 +60,7 @@ impl WindowBuilder {
             mut elements,
             closable,
             background_color,
+            theme_kind,
         } = self;
 
         if closable {
@@ -104,8 +111,10 @@ impl WindowBuilder {
             size_constraint,
             size,
             elements,
+            popup_element: None,
             closable,
             background_color,
+            theme_kind,
         }
     }
 }
diff --git a/src/interface/windows/character/creation.rs b/src/interface/windows/character/creation.rs
index 8638d2b19..e43ee0d07 100644
--- a/src/interface/windows/character/creation.rs
+++ b/src/interface/windows/character/creation.rs
@@ -36,10 +36,10 @@ impl PrototypeWindow for CharacterCreationWindow {
             let slot = self.slot;
             let name = name.clone();
 
-            move || Some(ClickAction::Event(UserEvent::CreateCharacter(slot, name.borrow().clone())))
+            move || vec![ClickAction::Event(UserEvent::CreateCharacter(slot, name.borrow().clone()))]
         };
 
-        let input_action = Box::new(move || Some(ClickAction::FocusNext(FocusMode::FocusNext)));
+        let input_action = Box::new(move || vec![ClickAction::FocusNext(FocusMode::FocusNext)]);
 
         let elements = vec![
             InputField::<MAXIMUM_NAME_LENGTH>::new(name, "character name", input_action, dimension!(100%)).wrap(),
@@ -57,6 +57,7 @@ impl PrototypeWindow for CharacterCreationWindow {
             .with_size(constraint!(200 > 250 < 300, ? < 80%))
             .with_elements(elements)
             .closable()
+            .with_theme_kind(ThemeKind::Menu)
             .build(window_cache, interface_settings, available_space)
     }
 }
diff --git a/src/interface/windows/character/selection.rs b/src/interface/windows/character/selection.rs
index b575700ad..a29da3650 100644
--- a/src/interface/windows/character/selection.rs
+++ b/src/interface/windows/character/selection.rs
@@ -30,6 +30,7 @@ impl PrototypeWindow for CharacterSelectionWindow {
             .with_class(Self::WINDOW_CLASS.to_string())
             .with_size(constraint!(600, ?))
             .with_elements(elements)
+            .with_theme_kind(ThemeKind::Menu)
             .build(window_cache, interface_settings, available_space)
     }
 }
diff --git a/src/interface/windows/debug/commands.rs b/src/interface/windows/debug/commands.rs
index b11f437e4..4b398b41d 100644
--- a/src/interface/windows/debug/commands.rs
+++ b/src/interface/windows/debug/commands.rs
@@ -26,13 +26,13 @@ impl PrototypeWindow for CommandsWindow {
                 let mut text = input_text.borrow_mut();
 
                 if text.is_empty() {
-                    return None;
+                    return Vec::new();
                 }
 
                 let message = format!("@jobchange {text}");
                 text.clear();
 
-                Some(ClickAction::Event(UserEvent::SendMessage(message)))
+                vec![ClickAction::Event(UserEvent::SendMessage(message))]
             })
         };
 
@@ -43,7 +43,7 @@ impl PrototypeWindow for CommandsWindow {
                 let mut text = input_text.borrow_mut();
                 let message = format!("@jobchange {text}");
                 text.clear();
-                Some(ClickAction::Event(UserEvent::SendMessage(message)))
+                vec![ClickAction::Event(UserEvent::SendMessage(message))]
             }
         };
 
diff --git a/src/interface/windows/debug/packet.rs b/src/interface/windows/debug/packet.rs
index d78e34215..94a89c8d2 100644
--- a/src/interface/windows/debug/packet.rs
+++ b/src/interface/windows/debug/packet.rs
@@ -37,7 +37,7 @@ impl<const N: usize> PrototypeWindow for PacketWindow<N> {
             move || !packets.borrow().is_empty()
         };
 
-        let clear_action = { move || Some(ClickAction::Event(UserEvent::ClearPacketHistory)) };
+        let clear_action = { move || vec![ClickAction::Event(UserEvent::ClearPacketHistory)] };
 
         let elements = vec![
             Button::default()
diff --git a/src/interface/windows/debug/profiler.rs b/src/interface/windows/debug/profiler.rs
index 2fad39089..da5a2637d 100644
--- a/src/interface/windows/debug/profiler.rs
+++ b/src/interface/windows/debug/profiler.rs
@@ -27,93 +27,32 @@ impl PrototypeWindow for ProfilerWindow {
         let toggle_halting = || {
             let is_profiler_halted = is_profiler_halted();
             set_profiler_halted(!is_profiler_halted);
-            None
-        };
-
-        let main_selector = {
-            let visible_thread = self.visible_thread.clone();
-            move |_: &StateProvider| *visible_thread.borrow() == ProfilerThread::Main
-        };
-        let show_main_thread = {
-            let mut visible_thread = self.visible_thread.clone();
-            move || {
-                visible_thread.set(ProfilerThread::Main);
-                None
-            }
-        };
-
-        let picker_selector = {
-            let visible_thread = self.visible_thread.clone();
-            move |_: &StateProvider| *visible_thread.borrow() == ProfilerThread::Picker
-        };
-        let show_picker_thread = {
-            let mut visible_thread = self.visible_thread.clone();
-            move || {
-                visible_thread.set(ProfilerThread::Picker);
-                None
-            }
-        };
-
-        let shadow_selector = {
-            let visible_thread = self.visible_thread.clone();
-            move |_: &StateProvider| *visible_thread.borrow() == ProfilerThread::Shadow
-        };
-        let show_shadow_thread = {
-            let mut visible_thread = self.visible_thread.clone();
-            move || {
-                visible_thread.set(ProfilerThread::Shadow);
-                None
-            }
-        };
-
-        let deferred_selector = {
-            let visible_thread = self.visible_thread.clone();
-            move |_: &StateProvider| *visible_thread.borrow() == ProfilerThread::Deferred
-        };
-        let show_deferred_thread = {
-            let mut visible_thread = self.visible_thread.clone();
-            move || {
-                visible_thread.set(ProfilerThread::Deferred);
-                None
-            }
+            Vec::new()
         };
 
         let elements = vec![
-            StateButton::default()
-                .with_text("Halt")
-                .with_selector(|_: &StateProvider| is_profiler_halted())
-                .with_event(Box::new(toggle_halting))
-                .with_width(dimension!(16.6%))
+            PickList::default()
+                .with_options(vec![
+                    ("Main thread", ProfilerThread::Main),
+                    ("Picker thread", ProfilerThread::Picker),
+                    ("Shadow thread", ProfilerThread::Shadow),
+                    ("Deferred thread", ProfilerThread::Deferred),
+                ])
+                .with_selected(self.visible_thread.clone())
+                .with_width(dimension!(150))
+                .with_event(Box::new(Vec::new))
                 .wrap(),
             StateButton::default()
                 .with_text("Always update")
                 .with_selector(self.always_update.selector())
                 .with_event(self.always_update.toggle_action())
-                .with_width(dimension!(16.6%))
-                .wrap(),
-            StateButton::default()
-                .with_text("Main thread")
-                .with_selector(main_selector)
-                .with_event(Box::new(show_main_thread))
-                .with_width(dimension!(16.6%))
-                .wrap(),
-            StateButton::default()
-                .with_text("Picker thread")
-                .with_selector(picker_selector)
-                .with_event(Box::new(show_picker_thread))
-                .with_width(dimension!(16.6%))
-                .wrap(),
-            StateButton::default()
-                .with_text("Shadow thread")
-                .with_selector(shadow_selector)
-                .with_event(Box::new(show_shadow_thread))
-                .with_width(dimension!(16.6%))
+                .with_width(dimension!(150))
                 .wrap(),
             StateButton::default()
-                .with_text("Deferred thread")
-                .with_selector(deferred_selector)
-                .with_event(Box::new(show_deferred_thread))
-                .with_width(dimension!(!))
+                .with_text("Halt")
+                .with_selector(|_: &StateProvider| is_profiler_halted())
+                .with_event(Box::new(toggle_halting))
+                .with_width(dimension!(150))
                 .wrap(),
             ElementWrap::wrap(FrameView::new(
                 self.always_update.new_remote(),
diff --git a/src/interface/windows/friends/list.rs b/src/interface/windows/friends/list.rs
index b3a36869d..4c1b7516c 100644
--- a/src/interface/windows/friends/list.rs
+++ b/src/interface/windows/friends/list.rs
@@ -30,7 +30,9 @@ impl PrototypeWindow for FriendsWindow {
                 let mut taken_string = String::new();
                 std::mem::swap(friend_name, &mut taken_string);
 
-                (!taken_string.is_empty()).then_some(ClickAction::Event(UserEvent::AddFriend(taken_string)))
+                (!taken_string.is_empty())
+                    .then_some(vec![ClickAction::Event(UserEvent::AddFriend(taken_string))])
+                    .unwrap_or_default()
             })
         };
 
diff --git a/src/interface/windows/generic/chat.rs b/src/interface/windows/generic/chat.rs
index 96edf3e2e..3afd4edaa 100644
--- a/src/interface/windows/generic/chat.rs
+++ b/src/interface/windows/generic/chat.rs
@@ -1,5 +1,4 @@
 use std::cell::RefCell;
-use std::ops::Not;
 use std::rc::Rc;
 
 use derive_new::new;
@@ -39,7 +38,7 @@ impl PrototypeWindow for ChatWindow {
 
             move || {
                 let message: String = input_text.borrow_mut().drain(..).collect();
-                Some(ClickAction::Event(UserEvent::SendMessage(message)))
+                vec![ClickAction::Event(UserEvent::SendMessage(message))]
             }
         };
 
@@ -47,10 +46,9 @@ impl PrototypeWindow for ChatWindow {
             let input_text = input_text.clone();
             Box::new(move || {
                 let message: String = input_text.borrow_mut().drain(..).collect();
-                message
-                    .is_empty()
-                    .not()
-                    .then_some(ClickAction::Event(UserEvent::SendMessage(message)))
+                (!message.is_empty())
+                    .then_some(vec![ClickAction::Event(UserEvent::SendMessage(message))])
+                    .unwrap_or_default()
             })
         };
 
diff --git a/src/interface/windows/generic/error.rs b/src/interface/windows/generic/error.rs
index 6902ebe0c..715183bae 100644
--- a/src/interface/windows/generic/error.rs
+++ b/src/interface/windows/generic/error.rs
@@ -23,6 +23,7 @@ impl PrototypeWindow for ErrorWindow {
             .with_size(constraint!(300 > 400 < 500, ?))
             .with_elements(elements)
             .closable()
+            .with_theme_kind(ThemeKind::Menu)
             .build(window_cache, interface_settings, available_space)
     }
 }
diff --git a/src/interface/windows/mod.rs b/src/interface/windows/mod.rs
index f4fedf652..354684bbe 100644
--- a/src/interface/windows/mod.rs
+++ b/src/interface/windows/mod.rs
@@ -34,8 +34,10 @@ pub struct Window {
     size_constraint: SizeConstraint,
     size: Vector2<f32>,
     elements: Vec<ElementCell>,
+    popup_element: Option<(ElementCell, Tracker<Position>, Tracker<Size>)>,
     closable: bool,
     background_color: Option<ColorSelector>,
+    theme_kind: ThemeKind,
 }
 
 impl Window {
@@ -43,14 +45,14 @@ impl Window {
         self.window_class.as_deref()
     }
 
-    fn get_background_color(&self, theme: &Theme) -> Color {
+    fn get_background_color(&self, theme: &InterfaceTheme) -> Color {
         self.background_color
             .as_ref()
             .map(|closure| closure(theme))
             .unwrap_or(*theme.window.background_color)
     }
 
-    pub fn has_transparency(&self, theme: &Theme) -> bool {
+    pub fn has_transparency(&self, theme: &InterfaceTheme) -> bool {
         self.get_background_color(theme).alpha != 255
     }
 
@@ -58,11 +60,15 @@ impl Window {
         self.closable
     }
 
+    pub fn get_theme_kind(&self) -> ThemeKind {
+        self.theme_kind
+    }
+
     pub fn resolve(
         &mut self,
         font_loader: Rc<RefCell<FontLoader>>,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         available_space: Size,
     ) -> (Option<&str>, Vector2<f32>, Size) {
         let height = match self.size_constraint.height.is_flexible() {
@@ -71,9 +77,8 @@ impl Window {
         };
 
         let mut placement_resolver = PlacementResolver::new(
-            font_loader,
+            font_loader.clone(),
             PartialSize::new(self.size.x, height),
-            Vector2::new(0.0, 0.0),
             *theme.window.border_size,
             *theme.window.gaps,
             *interface_settings.scaling,
@@ -97,6 +102,20 @@ impl Window {
 
         self.validate_position(available_space);
 
+        if let Some((popup, _, size_tracker)) = &self.popup_element {
+            let size = size_tracker().unwrap(); // FIX: Don't unwrap obviously
+
+            let mut placement_resolver = PlacementResolver::new(
+                font_loader,
+                PartialSize::new(size.x, Some(200.0)),
+                Vector2::new(0.0, 0.0), //*theme.window.border_size, // TODO: Popup
+                Vector2::new(0.0, 0.0), //*theme.window.gaps, // TODO: Popup
+                *interface_settings.scaling,
+            );
+
+            popup.borrow_mut().resolve(&mut placement_resolver, interface_settings, theme);
+        };
+
         (self.window_class.as_deref(), self.position, self.size)
     }
 
@@ -121,6 +140,16 @@ impl Window {
     pub fn hovered_element(&self, mouse_position: Vector2<f32>, mouse_mode: &MouseInputMode) -> HoverInformation {
         let absolute_position = mouse_position - self.position;
 
+        if let Some((popup, position_tracker, _)) = &self.popup_element {
+            let position = position_tracker().unwrap(); // FIX: Don't unwrap obviously
+
+            match popup.borrow().hovered_element(mouse_position - position, mouse_mode) {
+                HoverInformation::Hovered => return HoverInformation::Element(popup.clone()),
+                HoverInformation::Missed => {}
+                hover_information => return hover_information,
+            }
+        }
+
         if absolute_position.x >= 0.0
             && absolute_position.y >= 0.0
             && absolute_position.x <= self.size.x
@@ -169,7 +198,7 @@ impl Window {
     pub fn resize(
         &mut self,
         interface_settings: &InterfaceSettings,
-        _theme: &Theme,
+        _theme: &InterfaceTheme,
         available_space: Size,
         growth: Size,
     ) -> (Option<&str>, Size) {
@@ -184,13 +213,25 @@ impl Window {
             .validated_size(self.size, available_space, *interface_settings.scaling);
     }
 
+    pub fn open_popup(&mut self, element: ElementCell, position_tracker: Tracker<Position>, size_tracker: Tracker<Size>) {
+        // NOTE: Very important to link back
+        let weak_element = Rc::downgrade(&element);
+        element.borrow_mut().link_back(weak_element, None);
+
+        self.popup_element = Some((element, position_tracker, size_tracker));
+    }
+
+    pub fn close_popup(&mut self) {
+        self.popup_element = None;
+    }
+
     pub fn render(
         &self,
         render_target: &mut <InterfaceRenderer as Renderer>::Target,
         renderer: &InterfaceRenderer,
         state_provider: &StateProvider,
         interface_settings: &InterfaceSettings,
-        theme: &Theme,
+        theme: &InterfaceTheme,
         hovered_element: Option<&dyn Element>,
         focused_element: Option<&dyn Element>,
         mouse_mode: &MouseInputMode,
@@ -226,6 +267,24 @@ impl Window {
                 false,
             )
         });
+
+        if let Some((popup, position_tracker, _)) = &self.popup_element {
+            let position = position_tracker().unwrap(); // FIX: Don't unwrap obviously
+
+            popup.borrow().render(
+                render_target,
+                renderer,
+                state_provider,
+                interface_settings,
+                theme,
+                position,
+                clip_size,
+                hovered_element,
+                focused_element,
+                mouse_mode,
+                false,
+            );
+        };
     }
 }
 
diff --git a/src/interface/windows/settings/graphics.rs b/src/interface/windows/settings/graphics.rs
index cb6da9728..8220d76c7 100644
--- a/src/interface/windows/settings/graphics.rs
+++ b/src/interface/windows/settings/graphics.rs
@@ -1,12 +1,13 @@
 use procedural::*;
 
-use crate::graphics::PresentModeInfo;
+use crate::graphics::{PresentModeInfo, ShadowDetail};
 use crate::input::UserEvent;
 use crate::interface::*;
 
 #[derive(new)]
 pub struct GraphicsSettingsWindow {
     present_mode_info: PresentModeInfo,
+    shadow_detail: TrackedState<ShadowDetail>,
 }
 
 impl GraphicsSettingsWindow {
@@ -19,7 +20,21 @@ impl PrototypeWindow for GraphicsSettingsWindow {
     }
 
     fn to_window(&self, window_cache: &WindowCache, interface_settings: &InterfaceSettings, available_space: Size) -> Window {
-        let mut elements = vec![interface_settings.to_element("Interface settings".to_string())];
+        let mut elements = vec![
+            Text::default().with_text("Shadow detail").with_width(dimension!(50%)).wrap(),
+            PickList::default()
+                .with_options(vec![
+                    ("Low", ShadowDetail::Low),
+                    ("Medium", ShadowDetail::Medium),
+                    ("High", ShadowDetail::High),
+                    ("Ultra", ShadowDetail::Ultra),
+                ])
+                .with_selected(self.shadow_detail.clone())
+                .with_event(Box::new(|| Vec::new()))
+                .with_width(dimension!(!))
+                .wrap(),
+            interface_settings.to_element("Interface settings".to_string()),
+        ];
 
         // TODO: Instead of not showing this option, disable the checkbox and add a
         // tooltip
diff --git a/src/loaders/mod.rs b/src/loaders/mod.rs
index 101978bc2..f5f8bab5d 100644
--- a/src/loaders/mod.rs
+++ b/src/loaders/mod.rs
@@ -25,7 +25,7 @@ pub use self::map::MapData;
 pub use self::map::{LightSettings, MapLoader, WaterSettings};
 pub use self::model::*;
 pub use self::script::ScriptLoader;
-pub use self::server::{load_client_info, Service};
+pub use self::server::{load_client_info, ClientInfo, ServiceId};
 pub use self::sprite::*;
 pub use self::stream::ByteStream;
 pub use self::texture::TextureLoader;
diff --git a/src/loaders/server/client_info.rs b/src/loaders/server/client_info.rs
index 4fded7c0c..8016ea3da 100644
--- a/src/loaders/server/client_info.rs
+++ b/src/loaders/server/client_info.rs
@@ -1,6 +1,10 @@
+use std::hash::{DefaultHasher, Hash, Hasher};
+
 use serde::de::Error;
 use serde::{Deserialize, Deserializer};
 
+use super::ServiceId;
+
 /// The ClientInfo structure.
 ///
 /// It is a file that configures your client to connect to RO Servers.
@@ -111,6 +115,21 @@ pub struct Service {
     pub loading_images: Option<Vec<LoadingImage>>,
 }
 
+impl Service {
+    pub fn service_id(&self) -> ServiceId {
+        let mut hasher = DefaultHasher::new();
+
+        if let Some(display_name) = &self.display_name {
+            display_name.hash(&mut hasher);
+        }
+
+        self.address.hash(&mut hasher);
+        self.port.hash(&mut hasher);
+
+        ServiceId(hasher.finish() as usize)
+    }
+}
+
 /// The ClientInfo Service's Account ID structure
 #[derive(Debug, Clone, Default, Deserialize)]
 pub struct GameMasterAccount {
diff --git a/src/loaders/server/mod.rs b/src/loaders/server/mod.rs
index 2150cca3b..09c28f11e 100644
--- a/src/loaders/server/mod.rs
+++ b/src/loaders/server/mod.rs
@@ -1,14 +1,17 @@
 mod client_info;
 
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use serde_xml_rs::de::Deserializer;
 use xml::reader::{EventReader, ParserConfig};
 
-pub use self::client_info::{ClientInfo, Service};
+pub use self::client_info::ClientInfo;
 use super::GameFileLoader;
 #[cfg(feature = "debug")]
 use crate::debug::*;
 
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
+pub struct ServiceId(pub usize);
+
 pub fn load_client_info(game_file_loader: &mut GameFileLoader) -> ClientInfo {
     #[cfg(feature = "debug")]
     let timer = Timer::new("read clientinfo");
diff --git a/src/main.rs b/src/main.rs
index ddad9d67d..ff1da6269 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -269,6 +269,19 @@ fn main() {
     #[cfg(feature = "debug")]
     timer.stop();
 
+    #[cfg(feature = "debug")]
+    let timer = Timer::new("load settings");
+
+    let mut input_system = InputSystem::new();
+    let mut graphics_settings = GraphicsSettings::new();
+    #[cfg(feature = "debug")]
+    let mut render_settings = RenderSettings::new();
+
+    #[cfg(feature = "debug")]
+    timer.stop();
+
+    let mut shadow_detail = Remote::new(graphics_settings.shadow_detail);
+
     #[cfg(feature = "debug")]
     let timer = Timer::new("create render targets");
 
@@ -289,7 +302,7 @@ fn main() {
     let mut directional_shadow_targets = swapchain_holder
         .get_swapchain_images()
         .into_iter()
-        .map(|_| shadow_renderer.create_render_target(8192))
+        .map(|_| shadow_renderer.create_render_target(shadow_detail.get().into_resolution()))
         .collect::<Vec<<ShadowRenderer as Renderer>::Target>>();
 
     #[cfg(feature = "debug")]
@@ -305,10 +318,6 @@ fn main() {
         swapchain_holder.window_size_f32(),
     );
     let mut focus_state = FocusState::default();
-    let mut input_system = InputSystem::new();
-    let mut graphics_settings = GraphicsSettings::new();
-    #[cfg(feature = "debug")]
-    let mut render_settings = RenderSettings::new();
 
     #[cfg(feature = "debug")]
     timer.stop();
@@ -342,7 +351,7 @@ fn main() {
     let client_info = load_client_info(&mut game_file_loader);
     let mut networking_system = NetworkingSystem::new();
 
-    interface.open_window(&mut focus_state, &SelectServiceWindow::new(client_info.services.clone()));
+    interface.open_window(&mut focus_state, &LoginWindow::new(&client_info));
 
     #[cfg(feature = "debug")]
     timer.stop();
@@ -633,7 +642,7 @@ fn main() {
                                 )
                                 .expect("failed to load initial map");
 
-                            interface.close_all_windows(&mut focus_state);
+                            interface.close_all_windows_except(&mut focus_state);
 
                             let character_selection_window = networking_system.character_selection_window();
                             interface.open_window(&mut focus_state, &character_selection_window);
@@ -716,16 +725,12 @@ fn main() {
 
                 for event in user_events {
                     match event {
-                        UserEvent::SelectService(service) => {
-                            interface.close_window_with_class(&mut focus_state, SelectServiceWindow::WINDOW_CLASS);
-
-                            interface.open_window(
-                                &mut focus_state,
-                                &LoginWindow::new(service, networking_system.get_login_settings().clone()),
-                            );
-                        }
-                        UserEvent::LogIn(service, username, password) => {
-                            match networking_system.log_in(service, username, password) {
+                        UserEvent::LogIn {
+                            service_id,
+                            username,
+                            password,
+                        } => {
+                            match networking_system.log_in(&client_info, service_id, username, password) {
                                 Ok(servers) => {
                                     // TODO: this will do one unnecessary restore_focus. check if
                                     // that will be problematic
@@ -751,8 +756,6 @@ fn main() {
                         }
                         UserEvent::LogOut => networking_system.log_out().unwrap(),
                         UserEvent::Exit => *control_flow = ControlFlow::Exit,
-                        UserEvent::ToggleRemeberUsername => networking_system.toggle_remember_username(),
-                        UserEvent::ToggleRemeberPassword => networking_system.toggle_remember_password(),
                         UserEvent::CameraZoom(factor) => player_camera.soft_zoom(factor),
                         UserEvent::CameraRotate(factor) => player_camera.soft_rotate(factor),
                         UserEvent::ToggleFrameLimit => {
@@ -784,17 +787,18 @@ fn main() {
                                 interface.open_window(&mut focus_state, &SkillTreeWindow::new(player_skill_tree.get_skills()))
                             }
                         }
-                        UserEvent::OpenGraphicsSettingsWindow => {
-                            interface.open_window(&mut focus_state, &GraphicsSettingsWindow::new(present_mode_info))
-                        }
+                        UserEvent::OpenGraphicsSettingsWindow => interface.open_window(
+                            &mut focus_state,
+                            &GraphicsSettingsWindow::new(present_mode_info, shadow_detail.clone_state()),
+                        ),
                         UserEvent::OpenAudioSettingsWindow => interface.open_window(&mut focus_state, &AudioSettingsWindow::default()),
                         UserEvent::OpenFriendsWindow => interface.open_window(&mut focus_state, &networking_system.friends_window()),
-                        UserEvent::SetThemeFile(theme_file) => {
-                            interface.set_theme_file(theme_file);
-                            interface.reload_theme();
+                        UserEvent::SetThemeFile { theme_file, theme_kind } => {
+                            interface.set_theme_file(theme_file, theme_kind);
+                            interface.reload_theme(theme_kind);
                         }
-                        UserEvent::SaveTheme => interface.save_theme(),
-                        UserEvent::ReloadTheme => interface.reload_theme(),
+                        UserEvent::SaveTheme { theme_kind } => interface.save_theme(theme_kind),
+                        UserEvent::ReloadTheme { theme_kind } => interface.reload_theme(theme_kind),
                         UserEvent::SelectCharacter(character_slot) => {
                             match networking_system.select_character(character_slot) {
                                 Ok((account_id, character_information, map_name)) => {
@@ -1123,7 +1127,7 @@ fn main() {
 
                 if swapchain_holder.is_swapchain_invalid() {
                     #[cfg(feature = "debug")]
-                    profile_block!("recreate buffers");
+                    profile_block!("re-create buffers");
 
                     let viewport = swapchain_holder.recreate_swapchain();
 
@@ -1156,6 +1160,23 @@ fn main() {
                     return;
                 }
 
+                if shadow_detail.consume_changed() {
+                    #[cfg(feature = "debug")]
+                    print_debug!("re-creating {}directional shadow targets{}", MAGENTA, NONE);
+
+                    #[cfg(feature = "debug")]
+                    profile_block!("re-create shadow maps");
+
+                    let new_shadow_detail = shadow_detail.get();
+                    graphics_settings.shadow_detail = new_shadow_detail;
+
+                    directional_shadow_targets = swapchain_holder
+                        .get_swapchain_images()
+                        .into_iter()
+                        .map(|_| shadow_renderer.create_render_target(new_shadow_detail.into_resolution()))
+                        .collect::<Vec<<ShadowRenderer as Renderer>::Target>>();
+                }
+
                 #[cfg(feature = "debug")]
                 let matrices_measuremen = start_measurement("generate view and projection matrices");
 
@@ -1215,7 +1236,7 @@ fn main() {
                 #[cfg(feature = "debug")]
                 let prepare_frame_measuremen = start_measurement("prepare frame");
 
-                let walk_indicator_color = *interface.get_theme().indicator.walking;
+                let walk_indicator_color = *interface.get_game_theme().indicator.walking;
                 let image_number = swapchain_holder.get_image_number();
                 let directional_shadow_image = directional_shadow_targets[image_number].image.clone();
                 let screen_target = &mut screen_targets[image_number];
@@ -1419,7 +1440,6 @@ fn main() {
                             &graphics_settings,
                             #[cfg(feature = "debug")]
                             &render_settings,
-                            networking_system.get_login_settings(),
                         );
 
                         interface.render(
@@ -1464,7 +1484,7 @@ fn main() {
                             screen_target,
                             &deferred_renderer,
                             current_camera,
-                            interface.get_theme(),
+                            interface.get_game_theme(),
                             window_size,
                         );
 
@@ -1483,7 +1503,7 @@ fn main() {
                         screen_target,
                         &deferred_renderer,
                         current_camera,
-                        interface.get_theme(),
+                        interface.get_game_theme(),
                         window_size,
                     );
                 }
diff --git a/src/network/login.rs b/src/network/login.rs
index 27c70a953..c8efed4e3 100644
--- a/src/network/login.rs
+++ b/src/network/login.rs
@@ -1,17 +1,50 @@
+use std::collections::HashMap;
+
 use ron::ser::PrettyConfig;
-use serde::{Deserialize, Serialize};
+use serde::ser::SerializeStruct;
+use serde::{Deserialize, Serialize, Serializer};
 
 #[cfg(feature = "debug")]
 use crate::debug::*;
+use crate::loaders::ServiceId;
 
 #[derive(Clone, Default, Serialize, Deserialize)]
 pub struct LoginSettings {
+    pub service: String,
+    pub service_settings: HashMap<ServiceId, ServiceSettings>,
+    pub recent_service_id: Option<ServiceId>,
+}
+
+#[derive(Clone, Default, Deserialize)]
+pub struct ServiceSettings {
     pub username: String,
     pub password: String,
     pub remember_username: bool,
     pub remember_password: bool,
 }
 
+impl Serialize for ServiceSettings {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut serde_state = Serializer::serialize_struct(serializer, "ServiceSettings", 4)?;
+        SerializeStruct::serialize_field(
+            &mut serde_state,
+            "username",
+            self.remember_username.then_some(self.username.as_str()).unwrap_or_default(),
+        )?;
+        SerializeStruct::serialize_field(
+            &mut serde_state,
+            "password",
+            self.remember_password.then_some(self.password.as_str()).unwrap_or_default(),
+        )?;
+        SerializeStruct::serialize_field(&mut serde_state, "remember_username", &self.remember_username)?;
+        SerializeStruct::serialize_field(&mut serde_state, "remember_password", &self.remember_password)?;
+        SerializeStruct::end(serde_state)
+    }
+}
+
 impl LoginSettings {
     pub fn new() -> Self {
         Self::load().unwrap_or_else(|| {
diff --git a/src/network/mod.rs b/src/network/mod.rs
index fb9151fd9..7c06cd39e 100644
--- a/src/network/mod.rs
+++ b/src/network/mod.rs
@@ -22,7 +22,7 @@ use crate::interface::PacketWindow;
 use crate::interface::{
     CharacterSelectionWindow, ElementCell, ElementWrap, Expandable, FriendsWindow, PrototypeElement, TrackedState, WeakElementCell,
 };
-use crate::loaders::{conversion_result, ByteStream, ConversionError, FromBytes, Named, Service, ToBytes};
+use crate::loaders::{conversion_result, ByteStream, ClientInfo, ConversionError, FromBytes, Named, ServiceId, ToBytes};
 
 #[derive(Clone, Copy, Debug, Named, ByteConvertable, FixedByteSize, PrototypeElement)]
 pub struct ClientTick(pub u32);
@@ -2688,21 +2688,37 @@ struct LoginData {
     pub sex: Sex,
 }
 
+// TODO: Use struct like this
+// enum GameState {
+//     LoggingIn {},
+//     SelectingCharacter {
+//         login_data: LoginData,
+//         characters: TrackedState<Vec<CharacterInformation>>,
+//         move_request: TrackedState<Option<usize>>,
+//         slot_count: usize,
+//     },
+//     Playing {
+//         friend_list: TrackedState<Vec<(Friend,
+// UnsafeCell<Option<WeakElementCell>>)>>,         player_name: String,
+//     },
+// }
+
 pub struct NetworkingSystem {
-    login_settings: LoginSettings,
     login_stream: Option<TcpStream>,
     character_stream: Option<TcpStream>,
     map_stream: Option<TcpStream>,
     // TODO: Make this a heapless Vec or something
     map_stream_buffer: Vec<u8>,
+    login_keep_alive_timer: NetworkTimer,
+    character_keep_alive_timer: NetworkTimer,
+    map_keep_alive_timer: NetworkTimer,
+
+    // TODO: Move to GameState
     login_data: Option<LoginData>,
     characters: TrackedState<Vec<CharacterInformation>>,
     move_request: TrackedState<Option<usize>>,
     friend_list: TrackedState<Vec<(Friend, UnsafeCell<Option<WeakElementCell>>)>>,
     slot_count: usize,
-    login_keep_alive_timer: NetworkTimer,
-    character_keep_alive_timer: NetworkTimer,
-    map_keep_alive_timer: NetworkTimer,
     player_name: String,
     #[cfg(feature = "debug")]
     update_packets: TrackedState<bool>,
@@ -2712,8 +2728,6 @@ pub struct NetworkingSystem {
 
 impl NetworkingSystem {
     pub fn new() -> Self {
-        let login_settings = LoginSettings::new();
-
         let login_stream = None;
         let character_stream = None;
         let map_stream = None;
@@ -2733,7 +2747,6 @@ impl NetworkingSystem {
         let packet_history = TrackedState::default();
 
         Self {
-            login_settings,
             login_stream,
             character_stream,
             slot_count,
@@ -2754,25 +2767,24 @@ impl NetworkingSystem {
         }
     }
 
-    pub fn get_login_settings(&self) -> &LoginSettings {
-        &self.login_settings
-    }
-
-    pub fn toggle_remember_username(&mut self) {
-        self.login_settings.remember_username = !self.login_settings.remember_username;
-    }
-
-    pub fn toggle_remember_password(&mut self) {
-        self.login_settings.remember_password = !self.login_settings.remember_password;
-    }
-
-    pub fn log_in(&mut self, service: Service, username: String, password: String) -> Result<Vec<CharacterServerInformation>, String> {
+    pub fn log_in(
+        &mut self,
+        client_info: &ClientInfo,
+        service_id: ServiceId,
+        username: String,
+        password: String,
+    ) -> Result<Vec<CharacterServerInformation>, String> {
         #[cfg(feature = "debug")]
         let timer = Timer::new("log in");
 
+        let service = client_info
+            .services
+            .iter()
+            .find(|service| service.service_id() == service_id)
+            .unwrap();
         let service_address = format!("{}:{}", service.address, service.port);
 
-        let login_stream = TcpStream::connect(&service_address).expect("failed to connect to login server");
+        let login_stream = TcpStream::connect(service_address).map_err(|_| "failed to connect to login server".to_owned())?;
         login_stream.set_read_timeout(Duration::from_secs(1).into()).unwrap();
         self.login_stream = Some(login_stream);
 
@@ -2809,30 +2821,17 @@ impl NetworkingSystem {
             _ => panic!(),
         };
 
-        self.login_data = LoginData::new(
+        self.login_data = Some(LoginData::new(
             login_server_login_success_packet.account_id,
             login_server_login_success_packet.login_id1,
             login_server_login_success_packet.login_id2,
             login_server_login_success_packet.sex,
-        )
-        .into();
+        ));
 
         if login_server_login_success_packet.character_server_information.is_empty() {
             return Err("no character server available".to_string());
         }
 
-        self.login_settings.username = match self.login_settings.remember_username {
-            true => username,
-            // clear in case it was previously saved
-            false => String::new(),
-        };
-
-        self.login_settings.password = match self.login_settings.remember_password {
-            true => password,
-            // clear in case it was previously saved
-            false => String::new(),
-        };
-
         #[cfg(feature = "debug")]
         self.update_packet_history(&mut byte_stream);
 
@@ -2947,7 +2946,7 @@ impl NetworkingSystem {
     where
         T: OutgoingPacket + 'static,
     {
-        if *self.update_packets.borrow() {
+        if self.update_packets.get() {
             self.packet_history.with_mut(|buffer, changed| {
                 buffer.push((PacketEntry::new_outgoing(packet, T::NAME, T::IS_PING), UnsafeCell::new(None)));
                 changed()
diff --git a/src/world/entity/mod.rs b/src/world/entity/mod.rs
index aff75e0a6..2bfd4ad9b 100644
--- a/src/world/entity/mod.rs
+++ b/src/world/entity/mod.rs
@@ -8,7 +8,7 @@ use vulkano::buffer::Subbuffer;
 #[cfg(feature = "debug")]
 use crate::graphics::MarkerRenderer;
 use crate::graphics::{Camera, DeferredRenderer, EntityRenderer, ModelVertex, Renderer};
-use crate::interface::{InterfaceSettings, PrototypeWindow, Size, Theme, Window, WindowCache};
+use crate::interface::{GameTheme, InterfaceSettings, PrototypeWindow, Size, Window, WindowCache};
 use crate::loaders::{ActionLoader, Actions, AnimationState, GameFileLoader, ScriptLoader, Sprite, SpriteLoader};
 use crate::network::{AccountId, CharacterInformation, ClientTick, EntityData, EntityId, Sex, StatusType};
 use crate::world::Map;
@@ -820,7 +820,7 @@ impl Player {
         render_target: &mut <DeferredRenderer as Renderer>::Target,
         renderer: &DeferredRenderer,
         camera: &dyn Camera,
-        theme: &Theme,
+        theme: &GameTheme,
         window_size: Vector2<f32>,
     ) {
         let (view_matrix, projection_matrix) = camera.view_projection_matrices();
@@ -920,7 +920,7 @@ impl Npc {
         render_target: &mut <DeferredRenderer as Renderer>::Target,
         renderer: &DeferredRenderer,
         camera: &dyn Camera,
-        theme: &Theme,
+        theme: &GameTheme,
         window_size: Vector2<f32>,
     ) {
         if self.common.entity_type != EntityType::Monster {
@@ -1078,7 +1078,7 @@ impl Entity {
         render_target: &mut <DeferredRenderer as Renderer>::Target,
         renderer: &DeferredRenderer,
         camera: &dyn Camera,
-        theme: &Theme,
+        theme: &GameTheme,
         window_size: Vector2<f32>,
     ) {
         match self {