diff --git a/Cargo.lock b/Cargo.lock
index 0c0372d6..ab0e35b1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1549,6 +1549,15 @@ dependencies = [
  "nohash-hasher",
 ]
 
+[[package]]
+name = "egui_extras"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877bfcce06463cdbcfd7f4efd57608b1384d6d9ae03b33e503fbba1d1a899a52"
+dependencies = [
+ "egui",
+]
+
 [[package]]
 name = "either"
 version = "1.7.0"
@@ -2282,7 +2291,7 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
 [[package]]
 name = "leafwing_input_manager"
 version = "0.5.0"
-source = "git+https://github.com/Leafwing-Studios/leafwing-input-manager.git?rev=e8bd6e0#e8bd6e00886f45cd37c3289cf2a726b514058fda"
+source = "git+https://github.com/zicklag/leafwing-input-manager.git?branch=backport-leafwing-dev-to-bevy-0.7#000cee2ae7bc1bf206d63c3a2dfbacbb07fa23f2"
 dependencies = [
  "bevy_app",
  "bevy_core",
@@ -2303,7 +2312,7 @@ dependencies = [
 [[package]]
 name = "leafwing_input_manager_macros"
 version = "0.5.0"
-source = "git+https://github.com/Leafwing-Studios/leafwing-input-manager.git?rev=e8bd6e0#e8bd6e00886f45cd37c3289cf2a726b514058fda"
+source = "git+https://github.com/zicklag/leafwing-input-manager.git?branch=backport-leafwing-dev-to-bevy-0.7#000cee2ae7bc1bf206d63c3a2dfbacbb07fa23f2"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",
@@ -3156,6 +3165,7 @@ dependencies = [
  "bevy_mod_debugdump",
  "bevy_rapier2d",
  "directories",
+ "egui_extras",
  "fluent",
  "getrandom",
  "iyes_loopless",
diff --git a/Cargo.toml b/Cargo.toml
index b013b034..e09db2e6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,6 +9,7 @@ anyhow = "1.0.58"
 bevy = "0.7.0"
 bevy-parallax = "0.1.2"
 bevy_egui = "0.14"
+egui_extras = "0.18.0"
 bevy_kira_audio = { version = "0.10.0", features = ["mp3"] }
 bevy_rapier2d = { version = "0.14.1", features = ["debug-render"] }
 iyes_loopless = "0.6.1"
@@ -22,7 +23,7 @@ getrandom = { version = "0.2", features = ["js"] }
 bevy_mod_debugdump = { version = "0.4", optional = true }
 bevy-inspector-egui = { version = "0.11", optional = true }
 bevy-inspector-egui-rapier = { version = "0.4", optional = true, features = ["rapier2d"] }
-leafwing_input_manager = { git = "https://github.com/Leafwing-Studios/leafwing-input-manager.git", rev = "e8bd6e0" }
+leafwing_input_manager = { git = "https://github.com/zicklag/leafwing-input-manager.git", branch = "backport-leafwing-dev-to-bevy-0.7" }
 unic-langid = "0.9.0"
 bevy_fluent = { git = "https://github.com/kgv/bevy_fluent", rev = "d41f514" }
 sys-locale = "0.2.1"
diff --git a/assets/default.game.yaml b/assets/default.game.yaml
index da116f8c..3b2cf816 100644
--- a/assets/default.game.yaml
+++ b/assets/default.game.yaml
@@ -8,7 +8,7 @@ main_menu:
   title_font:
     family: ark
     color: [0, 0, 0]
-    size: 55
+    size: 40
 
   background_image:
     image: ui/main-menu-background.png
@@ -16,179 +16,77 @@ main_menu:
 
   music: ui/Fishycuffs [title screen].ogg
 
-default_input_maps:
-  players:
-    # Player 1
-    - Move:
-      - VirtualDPad:
-          up:
-            Keyboard: W
-          down:
-            Keyboard: S
-          left:
-            Keyboard: A
-          right:
-            Keyboard: D
-      - VirtualDPad:
-          up:
-            GamepadButton: DPadUp
-          down:
-            GamepadButton: DPadDown
-          left:
-            GamepadButton: DPadLeft
-          right:
-            GamepadButton: DPadRight
-      - Single:
-          DualGamepadAxis:
-            x_axis: LeftStickX
-            y_axis: LeftStickY
-            x_positive_low: 0.1
-            x_negative_low: -0.1
-            y_positive_low: 0.1
-            y_negative_low: -0.1
-      FlopAttack:
-        - Single:
-            Keyboard: Space
-        - Single:
-            GamepadButton: South
-      Throw:
-        - Single:
-            Keyboard: C
-        - Single:
-            GamepadButton: West
-      Shoot:
-        - Single:
-            Keyboard: V
-        - Single:
-            GamepadButton: East
-    # Player 2
-    - Move:
-      - VirtualDPad:
-          up:
-            Keyboard: Up
-          down:
-            Keyboard: Down
-          left:
-            Keyboard: Left
-          right:
-            Keyboard: Right
-      - Single:
-          DualGamepadAxis:
-            x_axis: LeftStickX
-            y_axis: LeftStickY
-            x_positive_low: 0.1
-            x_negative_low: -0.1
-            y_positive_low: 0.1
-            y_negative_low: -0.1
-      - VirtualDPad:
-          up:
-            GamepadButton: DPadUp
-          down:
-            GamepadButton: DPadDown
-          left:
-            GamepadButton: DPadLeft
-          right:
-            GamepadButton: DPadRight
-      FlopAttack:
-        - Single:
-            Keyboard: Comma
-        - Single:
-            GamepadButton: South
-      Throw:
-        - Single:
-            Keyboard: Period
-        - Single:
-            GamepadButton: West
-      Shoot:
-        - Single:
-            Keyboard: RShift
-        - Single:
-            GamepadButton: East
-
-  camera:
-    Up:
-      - Chord:
-          - Keyboard: Up
-          - Keyboard: LControl
-    Down:
-      - Chord:
-          - Keyboard: Down
-          - Keyboard: LControl
-    Left:
-      - Chord:
-          - Keyboard: Left
-          - Keyboard: LControl
-    Right:
-      - Chord:
-          - Keyboard: Right
-          - Keyboard: LControl
-    ZoomIn:
-      - Chord:
-          - Keyboard: Equals
-          - Keyboard: LControl
-    ZoomOut:
-      - Chord:
-          - Keyboard: Minus
-          - Keyboard: LControl
-
-  menu:
-    Confirm:
-      - Single:
-          GamepadButton: South
-      - Single:
-          GamepadButton: Start
-    Forward:
-      - Single:
-          Keyboard: Down
-      - Single:
-          Keyboard: Right
-      - Single:
-          GamepadButton: DPadDown
-      - Single:
-          GamepadButton: DPadRight
-      - Single:
-          GamepadButton: Select
-      - Single:
-          SingleGamepadAxis:
-            axis: LeftStickY
+default_settings:
+  player_controls:
+    # Gamepad controls
+    gamepad:
+      movement:
+        up:
+          SingleAxis:
+            axis_type:
+              Gamepad: LeftStickY
+            positive_low: 0.1
+            negative_low: -1.0
+        left:
+          SingleAxis:
+            axis_type:
+              Gamepad: LeftStickX
             positive_low: 1.0
-            negative_low: -0.5
-      - Single:
-          SingleGamepadAxis:
-            axis: LeftStickX
+            negative_low: -0.1
+        down:
+          SingleAxis:
+            axis_type:
+              Gamepad: LeftStickY
+            positive_low: 1.0
+            negative_low: -0.1
+        right:
+          SingleAxis:
+            axis_type:
+              Gamepad: LeftStickX
+            positive_low: 0.1
             negative_low: -1.0
-            positive_low: 0.5
-    Backward:
-      - Single:
-          Keyboard: Left
-      - Single:
+      flop_attack:
+        GamepadButton: South
+      shoot:
+        GamepadButton: East
+      throw:
+        GamepadButton: West
+
+    # Controls for the first keyboard player ( left side )
+    keyboard1:
+      movement:
+        up:
+          Keyboard: W
+        down:
+          Keyboard: S
+        left:
+          Keyboard: A
+        right:
+          Keyboard: D
+      flop_attack:
+        Keyboard: Space
+      shoot:
+        Keyboard: V
+      throw:
+        Keyboard: C
+
+    # Controls for the second keyboard player ( right side )
+    keyboard2:
+      movement:
+        up:
           Keyboard: Up
-      - Single:
-          GamepadButton: DPadLeft
-      - Single:
-          GamepadButton: DPadUp
-      - Single:
-          SingleGamepadAxis:
-            axis: LeftStickY
-            negative_low: -1.0
-            positive_low: 0.5
-      - Single:
-          SingleGamepadAxis:
-            axis: LeftStickX
-            negative_low: -0.5
-            positive_low: 1.0
-    Pause:
-      - Single:
-          Keyboard: Escape
-      - Single:
-          Keyboard: P
-      - Single:
-          GamepadButton: Start
-    ToggleFullscreen:
-      - Single:
-          Keyboard: F11
-      - Single:
-          GamepadButton: Mode
+        down:
+          Keyboard: Down
+        left:
+          Keyboard: Left
+        right:
+          Keyboard: Right
+      flop_attack:
+        Keyboard: Comma
+      shoot:
+        Keyboard: RShift
+      throw:
+        Keyboard: Period
 
 ui_theme:
   font_families:
@@ -199,6 +97,14 @@ ui_theme:
       family: ark
       size: 30
       color: [0, 0, 0]
+    bigger:
+      family: ark
+      size: 20
+      color: [0, 0, 0]
+    normal:
+      family: ark
+      size: 15
+      color: [0, 0, 0]
 
   hud:
     font:
@@ -247,19 +153,19 @@ ui_theme:
         bottom: 11
         left: 11
         right: 11
-      scale: 4.0
+      scale: 3.0
 
   button_styles:
-    jumbo:
+    normal:
       font:
         family: ark
         color: [255, 255, 255]
-        size: 30
+        size: 17
       padding:
-        top: 12
-        left: 12
-        right: 12
-        bottom: 16
+        top: 8
+        left: 8
+        right: 8
+        bottom: 10
       borders:
         default:
           image: ui/green-button.png
@@ -269,7 +175,7 @@ ui_theme:
             bottom: 5
             right: 5
             left: 5
-          scale: 3
+          scale: 2
         focused:
           image: ui/green-button-focused.png
           image_size: [14, 14]
@@ -278,7 +184,7 @@ ui_theme:
             bottom: 5
             right: 5
             left: 5
-          scale: 3
+          scale: 2
         clicked:
           image: ui/green-button-down.png
           image_size: [14, 14]
@@ -287,18 +193,18 @@ ui_theme:
             bottom: 5
             right: 5
             left: 5
-          scale: 3
+          scale: 2
 
-    normal:
+    small:
       font:
         family: ark
         color: [255, 255, 255]
-        size: 20
+        size: 15
       padding:
-        top: 8
-        left: 8
-        right: 8
-        bottom: 10
+        top: 4
+        left: 4
+        right: 4
+        bottom: 6
       borders:
         default:
           image: ui/green-button.png
@@ -308,7 +214,7 @@ ui_theme:
             bottom: 5
             right: 5
             left: 5
-          scale: 2
+          scale: 1
         focused:
           image: ui/green-button-focused.png
           image_size: [14, 14]
@@ -317,7 +223,7 @@ ui_theme:
             bottom: 5
             right: 5
             left: 5
-          scale: 2
+          scale: 1
         clicked:
           image: ui/green-button-down.png
           image_size: [14, 14]
@@ -326,7 +232,7 @@ ui_theme:
             bottom: 5
             right: 5
             left: 5
-          scale: 2
+          scale: 1
 
 translations:
   # This is the locale that we will fallback to if the selected locale doesn't have
diff --git a/assets/locales/en-US/main.ftl b/assets/locales/en-US/main.ftl
index c4ee956c..1f1bd834 100644
--- a/assets/locales/en-US/main.ftl
+++ b/assets/locales/en-US/main.ftl
@@ -3,8 +3,31 @@ title =
     Fish Fight
     Punchy
 start-game = Start Game
+settings = Settings
+quit = Quit
+cancel = Cancel
+save = Save
 
 # Pause Menu
 paused = Paused
 continue = Continue
-main-menu = Main Menu
\ No newline at end of file
+main-menu = Main Menu
+
+# Settings Menu
+controls = Controls
+sound = Sound
+reset = Reset
+
+# Controls
+action = Action
+keyboard-1 = Keyboard 1
+keyboard-2 = Keyboard 2
+gamepad = Gamepad
+move-up = Move Up
+move-down = Move Down
+move-left = Move Left
+move-right = Move Right
+flop-attack = Flop Attack
+shoot = Shoot
+throw = Throw
+bind-input = Press an input or press Escape to cancel.
\ No newline at end of file
diff --git a/src/camera.rs b/src/camera.rs
index 16ebc786..931c3180 100644
--- a/src/camera.rs
+++ b/src/camera.rs
@@ -1,17 +1,10 @@
 use bevy::{
-    core::Time,
     math::Vec2,
-    prelude::{
-        Camera, Component, EventWriter, OrthographicProjection, Query, Res, ResMut, Transform,
-        With, Without,
-    },
-    render::camera::CameraProjection,
-    window::Windows,
+    prelude::{Camera, Component, EventWriter, Query, Res, Transform, With, Without},
 };
 use bevy_parallax::ParallaxMoveEvent;
-use leafwing_input_manager::prelude::ActionState;
 
-use crate::{consts, input::CameraAction, metadata::GameMeta, Player};
+use crate::{consts, metadata::GameMeta, Player};
 
 #[cfg_attr(feature = "debug", derive(bevy_inspector_egui::Inspectable))]
 #[derive(Component)]
@@ -19,53 +12,6 @@ pub struct Panning {
     pub offset: Vec2,
 }
 
-pub fn helper_camera_controller(
-    mut query: Query<(
-        &mut Camera,
-        &mut OrthographicProjection,
-        &mut Panning,
-        &ActionState<CameraAction>,
-    )>,
-    time: Res<Time>,
-    mut windows: ResMut<Windows>,
-) {
-    let (mut camera, mut projection, mut panning, input) = query.single_mut();
-
-    use CameraAction::*;
-    if input.pressed(Up) {
-        panning.offset.y += 150.0 * time.delta_seconds();
-    }
-    if input.pressed(Left) {
-        panning.offset.x -= 150.0 * time.delta_seconds();
-    }
-    if input.pressed(Down) {
-        panning.offset.y -= 150.0 * time.delta_seconds();
-    }
-    if input.pressed(Right) {
-        panning.offset.x += 150.0 * time.delta_seconds();
-    }
-
-    if input.pressed(ZoomIn) {
-        projection.scale = f32::clamp(
-            projection.scale - 150. * time.delta_seconds(),
-            1.,
-            projection.scale,
-        );
-    }
-    if input.pressed(ZoomOut) {
-        projection.scale += 150. * time.delta_seconds();
-    }
-
-    let scale = projection.scale;
-    let window = windows.primary_mut();
-
-    if (projection.scale - scale).abs() > f32::EPSILON {
-        projection.update(window.width(), window.height());
-        camera.projection_matrix = projection.get_projection_matrix();
-        camera.depth_calculation = projection.depth_calculation();
-    }
-}
-
 /// Moves the camera according to the RIGHT_BOUNDARY_DISTANCE. Note that this does not enforce
 /// limitations of any kind - that's up to the players movement logic (e.g. max distance).
 pub fn camera_follow_player(
diff --git a/src/game_init.rs b/src/game_init.rs
index d7f0d2fd..fbcf97fc 100644
--- a/src/game_init.rs
+++ b/src/game_init.rs
@@ -3,11 +3,16 @@ use bevy_egui::{egui, EguiContext};
 use bevy_fluent::Locale;
 use bevy_parallax::ParallaxCameraComponent;
 use iyes_loopless::state::NextState;
-use leafwing_input_manager::InputManagerBundle;
+use leafwing_input_manager::{
+    axislike::{AxisType, SingleAxis},
+    prelude::InputMap,
+    InputManagerBundle,
+};
 
 use crate::{
     camera::Panning,
     consts,
+    input::MenuAction,
     metadata::{BorderImageMeta, GameMeta},
     GameState,
 };
@@ -107,14 +112,9 @@ impl<'w, 's> GameLoader<'w, 's> {
                     offset: Vec2::new(0., -consts::GROUND_Y),
                 })
                 .insert(ParallaxCameraComponent)
-                // Insert insert manager bundle for `CameraAction`s
-                .insert_bundle(InputManagerBundle {
-                    input_map: game.default_input_maps.get_camera_map().build(),
-                    ..default()
-                })
                 // We also add another input manager bundle for `MenuAction`s
                 .insert_bundle(InputManagerBundle {
-                    input_map: game.default_input_maps.get_menu_map().build(),
+                    input_map: menu_input_map(),
                     ..default()
                 });
 
@@ -175,3 +175,69 @@ impl<'w, 's> GameLoader<'w, 's> {
         false
     }
 }
+
+fn menu_input_map() -> InputMap<MenuAction> {
+    InputMap::default()
+        // Up
+        .insert(KeyCode::Up, MenuAction::Up)
+        .insert(GamepadButtonType::DPadUp, MenuAction::Up)
+        .insert(
+            SingleAxis {
+                axis_type: AxisType::Gamepad(GamepadAxisType::LeftStickY),
+                positive_low: 0.5,
+                negative_low: -1.0,
+                value: None,
+            },
+            MenuAction::Up,
+        )
+        // Left
+        .insert(KeyCode::Left, MenuAction::Left)
+        .insert(GamepadButtonType::DPadLeft, MenuAction::Left)
+        .insert(
+            SingleAxis {
+                axis_type: AxisType::Gamepad(GamepadAxisType::LeftStickX),
+                positive_low: 1.0,
+                negative_low: -0.5,
+                value: None,
+            },
+            MenuAction::Left,
+        )
+        // Down
+        .insert(KeyCode::Down, MenuAction::Down)
+        .insert(GamepadButtonType::DPadDown, MenuAction::Down)
+        .insert(
+            SingleAxis {
+                axis_type: AxisType::Gamepad(GamepadAxisType::LeftStickY),
+                positive_low: 1.0,
+                negative_low: -0.5,
+                value: None,
+            },
+            MenuAction::Down,
+        )
+        // Right
+        .insert(KeyCode::Right, MenuAction::Right)
+        .insert(GamepadButtonType::DPadRight, MenuAction::Right)
+        .insert(
+            SingleAxis {
+                axis_type: AxisType::Gamepad(GamepadAxisType::LeftStickX),
+                positive_low: 0.5,
+                negative_low: -1.0,
+                value: None,
+            },
+            MenuAction::Right,
+        )
+        // Confirm
+        .insert(KeyCode::Return, MenuAction::Confirm)
+        .insert(GamepadButtonType::South, MenuAction::Confirm)
+        .insert(GamepadButtonType::Start, MenuAction::Confirm)
+        // Back
+        .insert(KeyCode::Escape, MenuAction::Back)
+        .insert(GamepadButtonType::East, MenuAction::Back)
+        // Toggle Fullscreen
+        .insert(KeyCode::F11, MenuAction::ToggleFullscreen)
+        .insert(GamepadButtonType::Mode, MenuAction::ToggleFullscreen)
+        // Pause
+        .insert(KeyCode::Escape, MenuAction::Pause)
+        .insert(GamepadButtonType::Start, MenuAction::Pause)
+        .build()
+}
diff --git a/src/input.rs b/src/input.rs
index 6494b4ab..11261a26 100644
--- a/src/input.rs
+++ b/src/input.rs
@@ -11,20 +11,13 @@ pub enum PlayerAction {
 }
 
 #[derive(Debug, Copy, Clone, Actionlike, Deserialize, Eq, PartialEq, Hash)]
-pub enum CameraAction {
+pub enum MenuAction {
     Up,
     Down,
-    Right,
     Left,
-    ZoomIn,
-    ZoomOut,
-}
-
-#[derive(Debug, Copy, Clone, Actionlike, Deserialize, Eq, PartialEq, Hash)]
-pub enum MenuAction {
+    Right,
     Confirm,
-    Forward,
-    Backward,
+    Back,
     Pause,
     ToggleFullscreen,
 }
diff --git a/src/main.rs b/src/main.rs
index 8cedbb1e..b0ef2f2e 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -15,6 +15,7 @@ use enemy::*;
 use input::MenuAction;
 use iyes_loopless::prelude::*;
 use leafwing_input_manager::prelude::*;
+use platform::Storage;
 use player::*;
 use rand::{seq::SliceRandom, Rng};
 
@@ -63,7 +64,8 @@ use y_sort::*;
 use crate::{
     attack::{attack_cleanup, attack_tick},
     config::EngineConfig,
-    input::{CameraAction, PlayerAction},
+    input::PlayerAction,
+    metadata::Settings,
 };
 
 #[cfg_attr(feature = "debug", derive(bevy_inspector_egui::Inspectable))]
@@ -201,7 +203,6 @@ fn main() {
         .add_plugin(localization::LocalizationPlugin)
         .add_plugin(RapierPhysicsPlugin::<NoUserData>::pixels_per_meter(100.0))
         .add_plugin(InputManagerPlugin::<PlayerAction>::default())
-        .add_plugin(InputManagerPlugin::<CameraAction>::default())
         .add_plugin(InputManagerPlugin::<MenuAction>::default())
         .add_plugin(AttackPlugin)
         .add_plugin(AnimationPlugin)
@@ -226,7 +227,6 @@ fn main() {
                 .with_system(spawn_throwable_items)
                 .with_system(player_controller)
                 .with_system(player_flop)
-                .with_system(helper_camera_controller)
                 .with_system(y_sort)
                 .with_system(player_attack_enemy_collision)
                 .with_system(enemy_attack_player_collision)
@@ -337,6 +337,7 @@ fn load_level(
     asset_server: Res<AssetServer>,
     game: Res<GameMeta>,
     windows: Res<Windows>,
+    mut storage: ResMut<Storage>,
 ) {
     if let Some(level) = assets.get(level_handle.clone_weak()) {
         debug!("Loaded level");
@@ -352,7 +353,12 @@ fn load_level(
 
         // Spawn the players
         for (i, player) in level.players.iter().enumerate() {
-            commands.spawn_bundle(PlayerBundle::new(player, i, &game));
+            commands.spawn_bundle(PlayerBundle::new(
+                player,
+                i,
+                &game,
+                storage.get(Settings::STORAGE_KEY).as_ref(),
+            ));
         }
 
         // Spawn the enemies
diff --git a/src/metadata.rs b/src/metadata.rs
index 123ec1f0..5131e005 100644
--- a/src/metadata.rs
+++ b/src/metadata.rs
@@ -8,16 +8,12 @@ use bevy::{
 use bevy_egui::egui;
 use bevy_kira_audio::AudioSource;
 use bevy_parallax::{LayerData, ParallaxResource};
-use leafwing_input_manager::{prelude::InputMap, user_input::UserInput, Actionlike};
 use serde::Deserialize;
 
-use crate::{
-    animation::Clip,
-    assets::EguiFont,
-    input::{CameraAction, MenuAction, PlayerAction},
-    state::State,
-    Stats,
-};
+use crate::{animation::Clip, assets::EguiFont, state::State, Stats};
+
+pub mod settings;
+pub use settings::*;
 
 pub use ui::*;
 pub mod ui;
@@ -37,49 +33,10 @@ pub struct GameMeta {
     pub camera_height: u32,
     pub camera_move_right_boundary: f32,
 
-    pub default_input_maps: InputMapsMeta,
+    pub default_settings: Settings,
     pub translations: TranslationsMeta,
 }
 
-#[derive(Deserialize, Clone, Debug)]
-#[serde(deny_unknown_fields)]
-pub struct InputMapsMeta {
-    /// Each item in `players` is the input map for the corresponding player index.
-    ///
-    /// i.e. the first entry is the input map for player one, the second is for player two, etc.
-    #[serde(default)]
-    pub players: Vec<HashMap<PlayerAction, Vec<UserInput>>>,
-    #[serde(default)]
-    pub camera: HashMap<CameraAction, Vec<UserInput>>,
-    #[serde(default)]
-    pub menu: HashMap<MenuAction, Vec<UserInput>>,
-}
-
-impl InputMapsMeta {
-    fn get_input_map<T: Actionlike + Copy>(map: &HashMap<T, Vec<UserInput>>) -> InputMap<T> {
-        let mut bindings = Vec::new();
-        for (action, inputs) in map {
-            for input in inputs {
-                bindings.push((input.clone(), *action));
-            }
-        }
-        InputMap::new(bindings)
-    }
-
-    pub fn get_player_map(&self, player_idx: usize) -> Option<InputMap<PlayerAction>> {
-        let player_map = self.players.get(player_idx)?;
-        Some(Self::get_input_map(player_map))
-    }
-
-    pub fn get_camera_map(&self) -> InputMap<CameraAction> {
-        Self::get_input_map(&self.camera)
-    }
-
-    pub fn get_menu_map(&self) -> InputMap<MenuAction> {
-        Self::get_input_map(&self.menu)
-    }
-}
-
 #[derive(Deserialize, Clone, Debug)]
 #[serde(deny_unknown_fields)]
 pub struct MainMenuMeta {
diff --git a/src/metadata/settings.rs b/src/metadata/settings.rs
new file mode 100644
index 00000000..ed7254d4
--- /dev/null
+++ b/src/metadata/settings.rs
@@ -0,0 +1,62 @@
+use bevy::prelude::Gamepad;
+use leafwing_input_manager::{axislike::VirtualDPad, prelude::InputMap, user_input::InputKind};
+use serde::{Deserialize, Serialize};
+
+use crate::input::PlayerAction;
+
+/// Global settings, stored and accessed through [`crate::platform::Storage`]
+#[derive(Deserialize, Serialize, Debug, Clone)]
+pub struct Settings {
+    // The player controller bindings
+    pub player_controls: PlayerControlMethods,
+}
+
+impl Settings {
+    /// The key used to store the settings in the [`crate::platform::Storage`] resource.
+    pub const STORAGE_KEY: &'static str = "settings";
+}
+
+#[derive(Deserialize, Serialize, Clone, Debug)]
+pub struct PlayerControlMethods {
+    /// Controls for game remotes
+    pub gamepad: PlayerControls,
+    /// Controls for keyboard player 1
+    pub keyboard1: PlayerControls,
+    /// Controls for keyboard player 2
+    pub keyboard2: PlayerControls,
+}
+
+impl PlayerControlMethods {
+    /// Get the input map for the given player index
+    pub fn get_input_map(&self, player_idx: usize) -> InputMap<PlayerAction> {
+        let mut input_map = InputMap::default();
+
+        input_map.set_gamepad(Gamepad(player_idx));
+
+        let mut add_controls = |ctrls: &PlayerControls| {
+            input_map.insert(ctrls.movement.clone(), PlayerAction::Move);
+            input_map.insert(ctrls.flop_attack, PlayerAction::FlopAttack);
+            input_map.insert(ctrls.shoot, PlayerAction::Shoot);
+            input_map.insert(ctrls.throw, PlayerAction::Throw);
+        };
+
+        add_controls(&self.gamepad);
+
+        match player_idx {
+            0 => add_controls(&self.keyboard1),
+            1 => add_controls(&self.keyboard2),
+            _ => (),
+        }
+
+        input_map
+    }
+}
+
+/// Binds inputs to player actions
+#[derive(Deserialize, Serialize, Clone, Debug)]
+pub struct PlayerControls {
+    pub movement: VirtualDPad,
+    pub flop_attack: InputKind,
+    pub throw: InputKind,
+    pub shoot: InputKind,
+}
diff --git a/src/metadata/ui.rs b/src/metadata/ui.rs
index 56b23716..2e899021 100644
--- a/src/metadata/ui.rs
+++ b/src/metadata/ui.rs
@@ -21,6 +21,7 @@ pub struct UIThemeMeta {
 pub enum FontStyle {
     Heading,
     Normal,
+    Bigger,
 }
 
 impl TryFrom<String> for FontStyle {
@@ -30,6 +31,7 @@ impl TryFrom<String> for FontStyle {
         use FontStyle::*;
         Ok(match value.as_str() {
             "heading" => Heading,
+            "bigger" => Bigger,
             "normal" => Normal,
             _ => {
                 return Err("Invalid font style");
@@ -77,8 +79,8 @@ impl FontMeta {
 #[serde(deny_unknown_fields)]
 #[serde(try_from = "String")]
 pub enum ButtonStyle {
-    Jumbo,
     Normal,
+    Small,
 }
 
 impl TryFrom<String> for ButtonStyle {
@@ -87,10 +89,10 @@ impl TryFrom<String> for ButtonStyle {
     fn try_from(value: String) -> Result<Self, Self::Error> {
         use ButtonStyle::*;
         Ok(match value.as_str() {
-            "jumbo" => Jumbo,
             "normal" => Normal,
+            "small" => Small,
             _ => {
-                return Err("Invalid font style");
+                return Err("Invalid button style");
             }
         })
     }
diff --git a/src/movement.rs b/src/movement.rs
index e5941ac5..d100c807 100644
--- a/src/movement.rs
+++ b/src/movement.rs
@@ -85,7 +85,7 @@ pub fn player_controller(
                 let mut dir = Vec2::ZERO;
 
                 if input.pressed(PlayerAction::Move) {
-                    dir = input.action_axis_pair(PlayerAction::Move).unwrap().xy();
+                    dir = input.axis_pair(PlayerAction::Move).unwrap().xy();
                 }
 
                 // Apply speed
diff --git a/src/platform.rs b/src/platform.rs
index 959a91f3..051e2200 100644
--- a/src/platform.rs
+++ b/src/platform.rs
@@ -250,6 +250,7 @@ impl Storage {
 pub struct SaveTask(Receiver<()>);
 
 impl SaveTask {
+    /// Get whether or not saving has been completed.
     pub fn is_complete(&mut self) -> bool {
         !self.0.is_empty()
     }
diff --git a/src/player.rs b/src/player.rs
index ef00e589..95991af8 100644
--- a/src/player.rs
+++ b/src/player.rs
@@ -5,7 +5,7 @@ use crate::{
     animation::Facing,
     consts,
     input::PlayerAction,
-    metadata::{FighterMeta, FighterSpawnMeta, GameMeta},
+    metadata::{FighterMeta, FighterSpawnMeta, GameMeta, Settings},
 };
 
 #[derive(Component)]
@@ -27,7 +27,12 @@ pub struct PlayerBundle {
 }
 
 impl PlayerBundle {
-    pub fn new(player_meta: &FighterSpawnMeta, player_i: usize, game_meta: &GameMeta) -> Self {
+    pub fn new(
+        player_meta: &FighterSpawnMeta,
+        player_i: usize,
+        game_meta: &GameMeta,
+        settings: Option<&Settings>,
+    ) -> Self {
         let ground_offset = Vec3::new(0.0, consts::GROUND_Y, 0.0);
         let player_pos = player_meta.location + ground_offset;
 
@@ -37,11 +42,10 @@ impl PlayerBundle {
         let fighter_handle = player_meta.fighter_handle.clone();
 
         let input_manager_bundle = InputManagerBundle {
-            input_map: game_meta
-                .default_input_maps
-                .get_player_map(player_i)
-                .map(|mut map| map.set_gamepad(Gamepad(player_i)).build())
-                .unwrap_or_default(),
+            input_map: settings
+                .unwrap_or(&game_meta.default_settings)
+                .player_controls
+                .get_input_map(player_i),
             ..default()
         };
 
diff --git a/src/ui.rs b/src/ui.rs
index f8b39818..e71c6a54 100644
--- a/src/ui.rs
+++ b/src/ui.rs
@@ -1,58 +1,125 @@
 use bevy::{prelude::*, utils::HashMap, window::WindowId};
-use bevy_egui::{
-    egui::{self, style::Margin},
-    EguiContext, EguiInput, EguiPlugin, EguiSettings,
-};
-use bevy_fluent::Localization;
+use bevy_egui::{egui, EguiContext, EguiInput, EguiPlugin, EguiSettings};
 use iyes_loopless::prelude::*;
 use leafwing_input_manager::prelude::ActionState;
 
-use crate::{
-    assets::EguiFont,
-    audio::*,
-    config::EngineConfig,
-    input::MenuAction,
-    metadata::{localization::LocalizationExt, ButtonStyle, FontStyle, GameMeta},
-    GameState,
-};
-
-use self::widgets::{bordered_button::BorderedButton, bordered_frame::BorderedFrame, EguiUIExt};
+use crate::{assets::EguiFont, audio, input::MenuAction, metadata::GameMeta, GameState};
 
 pub mod hud;
 pub mod widgets;
 
+pub mod main_menu;
+pub mod pause_menu;
+
+pub mod extensions;
+pub use extensions::*;
+
 pub struct UIPlugin;
 
 impl Plugin for UIPlugin {
     fn build(&self, app: &mut App) {
-        app.add_plugin(EguiPlugin)
+        app.init_resource::<WidgetAdjacencies>()
+            .add_plugin(EguiPlugin)
             .add_system(handle_menu_input.run_if_resource_exists::<GameMeta>())
-            .add_enter_system(GameState::MainMenu, spawn_main_menu_background)
-            .add_enter_system(GameState::MainMenu, play_menu_music)
-            .add_exit_system(GameState::MainMenu, despawn_main_menu_background)
-            .add_exit_system(GameState::MainMenu, stop_menu_music)
+            .add_enter_system(GameState::MainMenu, main_menu::spawn_main_menu_background)
+            .add_enter_system(GameState::MainMenu, audio::play_menu_music)
+            .add_exit_system(GameState::MainMenu, main_menu::despawn_main_menu_background)
+            .add_exit_system(GameState::MainMenu, audio::stop_menu_music)
             .add_system(hud::render_hud.run_in_state(GameState::InGame))
             .add_system(update_egui_fonts)
             .add_system(update_ui_scale.run_if_resource_exists::<GameMeta>())
             .add_system_set(
                 ConditionSet::new()
                     .run_in_state(GameState::Paused)
-                    .with_system(pause_menu)
+                    .with_system(pause_menu::pause_menu)
                     .into(),
             )
             .add_system_set(
                 ConditionSet::new()
                     .run_in_state(GameState::MainMenu)
-                    .with_system(main_menu)
+                    .with_system(main_menu::main_menu_system)
                     .into(),
             );
     }
 }
 
+/// Resource that stores which ui widgets are adjacent to which other widgets.
+///
+/// This is used to figure out which widget to focus on next when you press a direction on the
+/// gamepad, for instance.
+#[derive(Debug, Clone, Default)]
+pub struct WidgetAdjacencies(HashMap<egui::Id, WidgetAdjacency>);
+
+impl std::ops::Deref for WidgetAdjacencies {
+    type Target = HashMap<egui::Id, WidgetAdjacency>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl std::ops::DerefMut for WidgetAdjacencies {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+/// The list of widgets in each direction from another widget
+#[derive(Debug, Clone, Default)]
+pub struct WidgetAdjacency {
+    pub up: Option<egui::Id>,
+    pub down: Option<egui::Id>,
+    pub left: Option<egui::Id>,
+    pub right: Option<egui::Id>,
+}
+
+impl WidgetAdjacencies {
+    pub fn widget(&mut self, resp: &egui::Response) -> WidgetAdjacencyEntry {
+        WidgetAdjacencyEntry {
+            id: resp.id,
+            adjacencies: self,
+        }
+    }
+}
+
+pub struct WidgetAdjacencyEntry<'a> {
+    id: egui::Id,
+    adjacencies: &'a mut WidgetAdjacencies,
+}
+
+#[allow(clippy::wrong_self_convention)]
+impl<'a> WidgetAdjacencyEntry<'a> {
+    pub fn to_left_of(self, resp: &egui::Response) -> Self {
+        let other_id = resp.id;
+        self.adjacencies.0.entry(self.id).or_default().right = Some(other_id);
+        self.adjacencies.0.entry(other_id).or_default().left = Some(self.id);
+        self
+    }
+    pub fn to_right_of(self, resp: &egui::Response) -> Self {
+        let other_id = resp.id;
+        self.adjacencies.0.entry(self.id).or_default().left = Some(other_id);
+        self.adjacencies.0.entry(other_id).or_default().right = Some(self.id);
+        self
+    }
+    pub fn above(self, resp: &egui::Response) -> Self {
+        let other_id = resp.id;
+        self.adjacencies.0.entry(self.id).or_default().down = Some(other_id);
+        self.adjacencies.0.entry(other_id).or_default().up = Some(self.id);
+        self
+    }
+    pub fn below(self, resp: &egui::Response) -> Self {
+        let other_id = resp.id;
+        self.adjacencies.0.entry(self.id).or_default().up = Some(other_id);
+        self.adjacencies.0.entry(other_id).or_default().down = Some(self.id);
+        self
+    }
+}
+
 fn handle_menu_input(
     mut windows: ResMut<Windows>,
     input: Query<&ActionState<MenuAction>>,
     mut egui_inputs: ResMut<HashMap<WindowId, EguiInput>>,
+    adjacencies: Res<WidgetAdjacencies>,
+    mut egui_ctx: ResMut<EguiContext>,
 ) {
     use bevy::window::WindowMode;
     let input = input.single();
@@ -67,8 +134,6 @@ fn handle_menu_input(
         }
     }
 
-    // Emit tab / shift + tab Egui events in response to menu navigation inputs. This is pretty
-    // hacky and may need to be re-visited.
     let events = &mut egui_inputs
         .get_mut(&WindowId::primary())
         .unwrap()
@@ -83,20 +148,53 @@ fn handle_menu_input(
         });
     }
 
-    if input.just_pressed(MenuAction::Forward) {
-        events.push(egui::Event::Key {
-            key: egui::Key::Tab,
-            pressed: true,
-            modifiers: egui::Modifiers::NONE,
-        });
-    }
-
-    if input.just_pressed(MenuAction::Backward) {
-        events.push(egui::Event::Key {
-            key: egui::Key::Tab,
-            pressed: true,
-            modifiers: egui::Modifiers::SHIFT,
-        });
+    // Helper to fall back on using tab order instead of adjacency map to determine next focused
+    // widget.
+    let mut tab_fallback = || {
+        if input.just_pressed(MenuAction::Up) || input.just_pressed(MenuAction::Left) {
+            events.push(egui::Event::Key {
+                key: egui::Key::Tab,
+                pressed: true,
+                modifiers: egui::Modifiers::SHIFT,
+            });
+        } else if input.just_pressed(MenuAction::Down) || input.just_pressed(MenuAction::Right) {
+            events.push(egui::Event::Key {
+                key: egui::Key::Tab,
+                pressed: true,
+                modifiers: egui::Modifiers::NONE,
+            });
+        }
+    };
+
+    let mut memory = egui_ctx.ctx_mut().memory();
+    if let Some(adjacency) = memory.focus().and_then(|id| adjacencies.get(&id)) {
+        if input.just_pressed(MenuAction::Up) {
+            if let Some(adjacent) = adjacency.up {
+                memory.request_focus(adjacent);
+            } else {
+                tab_fallback()
+            }
+        } else if input.just_pressed(MenuAction::Down) {
+            if let Some(adjacent) = adjacency.down {
+                memory.request_focus(adjacent);
+            } else {
+                tab_fallback()
+            }
+        } else if input.just_pressed(MenuAction::Left) {
+            if let Some(adjacent) = adjacency.left {
+                memory.request_focus(adjacent);
+            } else {
+                tab_fallback()
+            }
+        } else if input.just_pressed(MenuAction::Right) {
+            if let Some(adjacent) = adjacency.right {
+                memory.request_focus(adjacent);
+            } else {
+                tab_fallback()
+            }
+        }
+    } else {
+        tab_fallback();
     }
 }
 
@@ -182,180 +280,3 @@ fn update_ui_scale(
         }
     }
 }
-
-fn pause_menu(
-    mut commands: Commands,
-    mut egui_context: ResMut<EguiContext>,
-    game: Res<GameMeta>,
-    non_camera_entities: Query<Entity, Without<Camera>>,
-    mut camera_transform: Query<&mut Transform, With<Camera>>,
-    localization: Res<Localization>,
-) {
-    let ui_theme = &game.ui_theme;
-
-    egui::CentralPanel::default()
-        .frame(egui::Frame::none())
-        .show(egui_context.ctx_mut(), |ui| {
-            let screen_rect = ui.max_rect();
-
-            let pause_menu_width = 300.0;
-            let x_margin = (screen_rect.width() - pause_menu_width) / 2.0;
-            let outer_margin = egui::style::Margin::symmetric(x_margin, screen_rect.height() * 0.2);
-
-            BorderedFrame::new(&ui_theme.panel.border)
-                .margin(outer_margin)
-                .padding(ui_theme.panel.padding.into())
-                .show(ui, |ui| {
-                    ui.set_min_width(ui.available_width());
-
-                    let heading_font = ui_theme
-                        .font_styles
-                        .get(&FontStyle::Heading)
-                        .expect("Missing 'heading' font style")
-                        .colored(ui_theme.panel.font_color);
-
-                    ui.vertical_centered(|ui| {
-                        ui.themed_label(&heading_font, &localization.get("paused"));
-
-                        ui.add_space(10.0);
-
-                        let width = ui.available_width();
-
-                        let continue_button = BorderedButton::themed(
-                            ui_theme,
-                            &ButtonStyle::Normal,
-                            &localization.get("continue"),
-                        )
-                        .min_size(egui::vec2(width, 0.0))
-                        .show(ui);
-
-                        // Focus continue button by default
-                        if ui.memory().focus().is_none() {
-                            continue_button.request_focus();
-                        }
-
-                        if continue_button.clicked() {
-                            commands.insert_resource(NextState(GameState::InGame));
-                        }
-
-                        if BorderedButton::themed(
-                            ui_theme,
-                            &ButtonStyle::Normal,
-                            &localization.get("main-menu"),
-                        )
-                        .min_size(egui::vec2(width, 0.0))
-                        .show(ui)
-                        .clicked()
-                        {
-                            // Clean up all entities other than the camera
-                            for entity in non_camera_entities.iter() {
-                                commands.entity(entity).despawn();
-                            }
-                            // Reset camera position
-                            let mut camera_transform = camera_transform.single_mut();
-                            camera_transform.translation.x = 0.0;
-                            camera_transform.translation.y = 0.0;
-
-                            // Show the main menu
-                            commands.insert_resource(NextState(GameState::MainMenu));
-                        }
-                    });
-                })
-        });
-}
-
-#[derive(Component)]
-struct MainMenuBackground;
-
-/// Spawns the background image for the main menu
-fn spawn_main_menu_background(mut commands: Commands, game: Res<GameMeta>, windows: Res<Windows>) {
-    let window = windows.primary();
-    let bg_handle = game.main_menu.background_image.image_handle.clone();
-    let img_size = game.main_menu.background_image.image_size;
-    let ratio = img_size.x / img_size.y;
-    let height = window.height();
-    let width = height * ratio;
-    commands
-        .spawn_bundle(SpriteBundle {
-            texture: bg_handle,
-            sprite: Sprite {
-                custom_size: Some(Vec2::new(width, height)),
-                ..default()
-            },
-            ..default()
-        })
-        .insert(MainMenuBackground);
-}
-
-/// Despawns the background image for the main menu
-fn despawn_main_menu_background(
-    mut commands: Commands,
-    background: Query<Entity, With<MainMenuBackground>>,
-) {
-    let bg = background.single();
-    commands.entity(bg).despawn();
-}
-
-/// Render the main menu UI
-fn main_menu(
-    mut commands: Commands,
-    mut egui_context: ResMut<EguiContext>,
-    game: Res<GameMeta>,
-    localization: Res<Localization>,
-    engine_config: Res<EngineConfig>,
-) {
-    let ui_theme = &game.ui_theme;
-
-    egui::CentralPanel::default()
-        .frame(egui::Frame::none())
-        .show(egui_context.ctx_mut(), |ui| {
-            let screen_rect = ui.max_rect();
-
-            // Calculate a margin of 20% of the screen size
-            let outer_margin = screen_rect.size() * 0.20;
-            let outer_margin = Margin {
-                left: outer_margin.x,
-                right: outer_margin.x,
-                // Make top and bottom margins smaller
-                top: outer_margin.y / 1.5,
-                bottom: outer_margin.y / 1.5,
-            };
-
-            BorderedFrame::new(&ui_theme.panel.border)
-                .margin(outer_margin)
-                .padding(ui_theme.panel.padding.into())
-                .show(ui, |ui| {
-                    // Make sure the frame ocupies the entire rect that we allocated for it.
-                    //
-                    // Without this it would only take up enough size to fit it's content.
-                    ui.set_min_size(ui.available_size());
-
-                    // Create a vertical list of items, centered horizontally
-                    ui.vertical_centered(|ui| {
-                        ui.themed_label(&game.main_menu.title_font, &localization.get("title"));
-
-                        // Now switch the layout to bottom_up so that we can start adding widgets
-                        // from the bottom of the frame.
-                        ui.with_layout(egui::Layout::bottom_up(egui::Align::Center), |ui| {
-                            let start_button = BorderedButton::themed(
-                                ui_theme,
-                                &ButtonStyle::Jumbo,
-                                &localization.get("start-game"),
-                            )
-                            .show(ui);
-
-                            // Focus the start button if nothing else is focused. That way you can
-                            // play the game just by pressing Enter.
-                            if ui.memory().focus().is_none() {
-                                start_button.request_focus();
-                            }
-
-                            if start_button.clicked() || engine_config.auto_start {
-                                commands.insert_resource(game.start_level_handle.clone());
-                                commands.insert_resource(NextState(GameState::LoadingLevel));
-                            }
-                        });
-                    });
-                })
-        });
-}
diff --git a/src/ui/extensions.rs b/src/ui/extensions.rs
new file mode 100644
index 00000000..267ff84f
--- /dev/null
+++ b/src/ui/extensions.rs
@@ -0,0 +1,33 @@
+//! Extension traits for egui
+
+use bevy_egui::egui;
+
+/// Extension trait with helpers for the egui context
+pub trait EguiContextExt {
+    /// Clear the UI focus
+    fn clear_focus(self);
+}
+
+impl EguiContextExt for &egui::Context {
+    fn clear_focus(self) {
+        self.memory().request_focus(egui::Id::null());
+    }
+}
+
+/// Extension trait with helpers for egui responses
+pub trait EguiResponseExt {
+    /// Set this response to focused if nothing else is focused
+    fn focus_by_default(self, ui: &mut egui::Ui) -> egui::Response;
+}
+
+impl EguiResponseExt for egui::Response {
+    fn focus_by_default(self, ui: &mut egui::Ui) -> egui::Response {
+        if ui.ctx().memory().focus().is_none() {
+            ui.ctx().memory().request_focus(self.id);
+
+            self
+        } else {
+            self
+        }
+    }
+}
diff --git a/src/ui/main_menu.rs b/src/ui/main_menu.rs
new file mode 100644
index 00000000..6fa5735f
--- /dev/null
+++ b/src/ui/main_menu.rs
@@ -0,0 +1,768 @@
+use bevy::{app::AppExit, ecs::system::SystemParam, prelude::*};
+use bevy_egui::{egui::style::Margin, *};
+use bevy_fluent::Localization;
+use iyes_loopless::state::NextState;
+use leafwing_input_manager::{
+    axislike::SingleAxis, prelude::ActionState, user_input::InputKind, Actionlike,
+};
+
+use crate::{
+    config::EngineConfig,
+    input::MenuAction,
+    metadata::{localization::LocalizationExt, ButtonStyle, FontStyle, GameMeta, Settings},
+    platform::Storage,
+    GameState,
+};
+
+use super::{
+    widgets::{bordered_button::BorderedButton, bordered_frame::BorderedFrame, EguiUIExt},
+    EguiContextExt, EguiResponseExt, WidgetAdjacencies,
+};
+
+#[derive(Component)]
+pub struct MainMenuBackground;
+
+/// Spawns the background image for the main menu
+pub fn spawn_main_menu_background(
+    mut commands: Commands,
+    game: Res<GameMeta>,
+    windows: Res<Windows>,
+) {
+    let window = windows.primary();
+    let bg_handle = game.main_menu.background_image.image_handle.clone();
+    let img_size = game.main_menu.background_image.image_size;
+    let ratio = img_size.x / img_size.y;
+    let height = window.height();
+    let width = height * ratio;
+    commands
+        .spawn_bundle(SpriteBundle {
+            texture: bg_handle,
+            sprite: Sprite {
+                custom_size: Some(Vec2::new(width, height)),
+                ..default()
+            },
+            ..default()
+        })
+        .insert(MainMenuBackground);
+}
+
+/// Despawns the background image for the main menu
+pub fn despawn_main_menu_background(
+    mut commands: Commands,
+    background: Query<Entity, With<MainMenuBackground>>,
+) {
+    let bg = background.single();
+    commands.entity(bg).despawn();
+}
+
+/// Which page of the menu we are on
+#[derive(Clone, Copy)]
+pub enum MenuPage {
+    Main,
+    Settings { tab: SettingsTab },
+}
+
+/// Which settings tab we are on
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum SettingsTab {
+    Controls,
+    #[allow(unused)] // Just for now until we get sound settings setup
+    Sound,
+}
+
+impl Default for MenuPage {
+    fn default() -> Self {
+        Self::Main
+    }
+}
+
+impl Default for SettingsTab {
+    fn default() -> Self {
+        Self::Controls
+    }
+}
+
+impl SettingsTab {
+    const TABS: &'static [(Self, &'static str)] = &[
+        (Self::Controls, "controls"),
+        // For now, hide the sound tab because we don't have it working yet.
+        // (Self::Sound, "sound")
+    ];
+}
+
+/// Group of parameters needed by the main menu system
+#[derive(SystemParam)]
+pub struct MenuSystemParams<'w, 's> {
+    menu_page: Local<'s, MenuPage>,
+    modified_settings: Local<'s, Option<Settings>>,
+    currently_binding_input_idx: Local<'s, Option<usize>>,
+    commands: Commands<'w, 's>,
+    game: Res<'w, GameMeta>,
+    localization: Res<'w, Localization>,
+    engine_config: Res<'w, EngineConfig>,
+    menu_input: Query<'w, 's, &'static mut ActionState<MenuAction>>,
+    app_exit: EventWriter<'w, 's, AppExit>,
+    storage: ResMut<'w, Storage>,
+    adjacencies: ResMut<'w, WidgetAdjacencies>,
+    control_inputs: ControlInputBindingEvents<'w, 's>,
+}
+
+/// Render the main menu UI
+pub fn main_menu_system(mut params: MenuSystemParams, mut egui_context: ResMut<EguiContext>) {
+    let menu_input = params.menu_input.single();
+
+    // Go to previous menu if back button is pressed
+    if menu_input.pressed(MenuAction::Back) {
+        if let MenuPage::Settings { .. } = *params.menu_page {
+            *params.menu_page = MenuPage::Main;
+            egui_context.ctx_mut().clear_focus();
+        }
+    }
+
+    egui::CentralPanel::default()
+        .frame(egui::Frame::none())
+        .show(egui_context.ctx_mut(), |ui| {
+            let screen_rect = ui.max_rect();
+
+            // Calculate a margin
+            let outer_margin = screen_rect.size() * 0.10;
+            let outer_margin = Margin {
+                left: outer_margin.x,
+                right: outer_margin.x,
+                // Make top and bottom margins smaller
+                top: outer_margin.y / 1.5,
+                bottom: outer_margin.y / 1.5,
+            };
+
+            // Create menu panel
+            BorderedFrame::new(&params.game.ui_theme.panel.border)
+                .margin(outer_margin)
+                .padding(params.game.ui_theme.panel.padding.into())
+                .show(ui, |ui| {
+                    // Make sure the frame ocupies the entire rect that we allocated for it.
+                    //
+                    // Without this it would only take up enough size to fit it's content.
+                    ui.set_min_size(ui.available_size());
+
+                    // Render the menu based on the current menu selection
+                    match *params.menu_page {
+                        MenuPage::Main => main_menu_ui(&mut params, ui),
+                        MenuPage::Settings { tab } => settings_menu_ui(&mut params, ui, tab),
+                    }
+                });
+        });
+}
+
+/// Render the main menu
+fn main_menu_ui(params: &mut MenuSystemParams, ui: &mut egui::Ui) {
+    let MenuSystemParams {
+        menu_page,
+        modified_settings,
+        commands,
+        game,
+        localization,
+        engine_config,
+        app_exit,
+        storage,
+        ..
+    } = params;
+
+    let ui_theme = &game.ui_theme;
+
+    // Create a vertical list of items, centered horizontally
+    ui.vertical_centered(|ui| {
+        ui.themed_label(&game.main_menu.title_font, &localization.get("title"));
+        ui.add_space(game.main_menu.title_font.size);
+
+        let min_button_size = egui::vec2(ui.available_width() / 2.0, 0.0);
+
+        // Start button
+        let start_button = BorderedButton::themed(
+            ui_theme,
+            &ButtonStyle::Normal,
+            &localization.get("start-game"),
+        )
+        .min_size(min_button_size)
+        .show(ui)
+        .focus_by_default(ui);
+
+        if start_button.clicked() || engine_config.auto_start {
+            commands.insert_resource(game.start_level_handle.clone());
+            commands.insert_resource(NextState(GameState::LoadingLevel));
+        }
+
+        // Settings button
+        if BorderedButton::themed(
+            ui_theme,
+            &ButtonStyle::Normal,
+            &localization.get("settings"),
+        )
+        .min_size(min_button_size)
+        .show(ui)
+        .clicked()
+        {
+            **menu_page = MenuPage::Settings { tab: default() };
+            **modified_settings = Some(
+                storage
+                    .get(Settings::STORAGE_KEY)
+                    .unwrap_or_else(|| game.default_settings.clone()),
+            );
+        }
+
+        // Quit button
+        #[cfg(not(target_arch = "wasm32"))] // Quitting doesn't make sense in a web context
+        if BorderedButton::themed(ui_theme, &ButtonStyle::Normal, &localization.get("quit"))
+            .min_size(min_button_size)
+            .show(ui)
+            .clicked()
+        {
+            app_exit.send(AppExit);
+        }
+
+        // use the app exit variable on WASM to avoid warnings
+        #[cfg(target_arch = "wasm32")]
+        let _ = app_exit;
+    });
+}
+
+/// Render the settings menu
+fn settings_menu_ui(params: &mut MenuSystemParams, ui: &mut egui::Ui, current_tab: SettingsTab) {
+    // Disable all the buttons if we are currently binding an input
+    ui.set_enabled(params.currently_binding_input_idx.is_none());
+
+    ui.vertical_centered(|ui| {
+        // Settings Heading
+        ui.themed_label(
+            params
+                .game
+                .ui_theme
+                .font_styles
+                .get(&FontStyle::Heading)
+                .unwrap(),
+            &params.localization.get("settings"),
+        );
+
+        // Add tab list at the top of the panel
+        let mut tabs = Vec::new();
+        ui.horizontal(|ui| {
+            for (i, (tab, name)) in SettingsTab::TABS.iter().enumerate() {
+                let name = &params.localization.get(*name);
+                let mut name = egui::RichText::new(name);
+
+                // Underline the current tab
+                if tab == &current_tab {
+                    name = name.underline();
+                }
+
+                let mut button =
+                    BorderedButton::themed(&params.game.ui_theme, &ButtonStyle::Normal, name)
+                        .show(ui);
+
+                // Focus the first tab by default
+                if i == 0 {
+                    button = button.focus_by_default(ui);
+                }
+
+                // Change tab when clicked
+                if button.clicked() {
+                    *params.menu_page = MenuPage::Settings { tab: *tab };
+                }
+
+                tabs.push(button);
+            }
+        });
+
+        // Add buttons to the bottom
+        ui.with_layout(egui::Layout::bottom_up(egui::Align::Center), |ui| {
+            // Collect button responses so we can add them to adjacency map later
+            let bottom_buttons = ui
+                .horizontal(|ui| {
+                    // Calculate button size and spacing
+                    let width = ui.available_width();
+                    let button_width = width / 4.0;
+                    let button_min_size = egui::vec2(button_width, 0.0);
+                    let button_spacing = (width - 3.0 * button_width) / 4.0;
+
+                    ui.add_space(button_spacing);
+
+                    // Cancel button
+                    let cancel_button = BorderedButton::themed(
+                        &params.game.ui_theme,
+                        &ButtonStyle::Normal,
+                        &params.localization.get("cancel"),
+                    )
+                    .min_size(button_min_size)
+                    .show(ui);
+
+                    // Go to menu when cancel is clicked
+                    if cancel_button.clicked() {
+                        *params.menu_page = MenuPage::Main;
+                        ui.ctx().clear_focus();
+                    }
+
+                    ui.add_space(button_spacing);
+
+                    // Reset button
+                    let reset_button = BorderedButton::themed(
+                        &params.game.ui_theme,
+                        &ButtonStyle::Normal,
+                        &params.localization.get("reset"),
+                    )
+                    .min_size(button_min_size)
+                    .show(ui);
+
+                    ui.add_space(button_spacing);
+
+                    // Save button
+                    let save_button = BorderedButton::themed(
+                        &params.game.ui_theme,
+                        &ButtonStyle::Normal,
+                        &params.localization.get("save"),
+                    )
+                    .min_size(button_min_size)
+                    .show(ui);
+
+                    // Save new settings if settings button clicked
+                    if save_button.clicked() {
+                        // Update in-memory settings
+                        params.storage.set(
+                            Settings::STORAGE_KEY,
+                            params.modified_settings.as_ref().unwrap(),
+                        );
+                        // Persist to storage
+                        params.storage.save();
+
+                        // Go to main menu
+                        *params.menu_page = MenuPage::Main;
+                        ui.ctx().clear_focus();
+                    }
+
+                    [cancel_button, reset_button, save_button]
+                })
+                .inner;
+
+            // Set the last bottom button's adjacency to be to the "left" of the first tab. This way
+            // you can wrap around from the bottom right button to the top left.
+            params
+                .adjacencies
+                .widget(&bottom_buttons[bottom_buttons.len() - 1])
+                .to_left_of(&tabs[0]);
+
+            ui.vertical(|ui| {
+                // Render selected tab
+                match current_tab {
+                    SettingsTab::Controls => {
+                        controls_settings_ui(
+                            params,
+                            ui,
+                            // Reset button clicked
+                            bottom_buttons[1].clicked(),
+                            &tabs,
+                            &bottom_buttons,
+                        )
+                    }
+                    SettingsTab::Sound => sound_settings_ui(ui, &params.game),
+                }
+            });
+        });
+    });
+}
+
+// Render the control input grid
+fn controls_settings_ui(
+    params: &mut MenuSystemParams,
+    ui: &mut egui::Ui,
+    should_reset: bool,
+    settings_tabs: &[egui::Response],
+    bottom_buttons: &[egui::Response],
+) {
+    use egui_extras::Size;
+
+    let ui_theme = &params.game.ui_theme;
+
+    // Reset the settings when reset button is clicked
+    if should_reset {
+        params.modified_settings.as_mut().unwrap().player_controls =
+            params.game.default_settings.player_controls.clone();
+    }
+
+    // Get the font meta for the table headings and labels
+    let bigger_font = ui_theme
+        .font_styles
+        .get(&FontStyle::Bigger)
+        .unwrap()
+        .colored(ui_theme.panel.font_color);
+    let label_font = ui_theme
+        .font_styles
+        .get(&FontStyle::Normal)
+        .unwrap()
+        .colored(ui_theme.panel.font_color);
+
+    ui.add_space(bigger_font.size * 0.1);
+
+    // Calculate the row height so that it can fit the input buttons
+    let small_button_style = ui_theme.button_styles.get(&ButtonStyle::Small).unwrap();
+    let row_height = small_button_style.font.size
+        + small_button_style.padding.top
+        + small_button_style.padding.bottom;
+
+    // Mutably borrow the player controlls settings
+    let controls = &mut params.modified_settings.as_mut().unwrap().player_controls;
+
+    // Build the table rows of control bindings as an array of mutable InputKind's
+    let mut input_rows = [
+        (
+            &params.localization.get("move-up"),
+            [
+                &mut controls.keyboard1.movement.up,
+                &mut controls.keyboard2.movement.up,
+                &mut controls.gamepad.movement.up,
+            ],
+        ),
+        (
+            &params.localization.get("move-down"),
+            [
+                &mut controls.keyboard1.movement.down,
+                &mut controls.keyboard2.movement.down,
+                &mut controls.gamepad.movement.down,
+            ],
+        ),
+        (
+            &params.localization.get("move-left"),
+            [
+                &mut controls.keyboard1.movement.left,
+                &mut controls.keyboard2.movement.left,
+                &mut controls.gamepad.movement.left,
+            ],
+        ),
+        (
+            &params.localization.get("move-right"),
+            [
+                &mut controls.keyboard1.movement.right,
+                &mut controls.keyboard2.movement.right,
+                &mut controls.gamepad.movement.right,
+            ],
+        ),
+        (
+            &params.localization.get("flop-attack"),
+            [
+                &mut controls.keyboard1.flop_attack,
+                &mut controls.keyboard2.flop_attack,
+                &mut controls.gamepad.flop_attack,
+            ],
+        ),
+        (
+            &params.localization.get("shoot"),
+            [
+                &mut controls.keyboard1.shoot,
+                &mut controls.keyboard2.shoot,
+                &mut controls.gamepad.shoot,
+            ],
+        ),
+        (
+            &params.localization.get("throw"),
+            [
+                &mut controls.keyboard1.throw,
+                &mut controls.keyboard2.throw,
+                &mut controls.gamepad.throw,
+            ],
+        ),
+    ];
+
+    // Collect input button responses for building adjacency graph
+    let mut input_buttons = Vec::new();
+
+    // Create input table
+    egui_extras::TableBuilder::new(ui)
+        .cell_layout(egui::Layout::centered_and_justified(
+            egui::Direction::LeftToRight,
+        ))
+        .column(Size::exact(label_font.size * 7.0))
+        .column(Size::remainder())
+        .column(Size::remainder())
+        .column(Size::remainder())
+        .header(bigger_font.size * 1.5, |mut row| {
+            row.col(|ui| {
+                ui.themed_label(&bigger_font, &params.localization.get("action"));
+            });
+            row.col(|ui| {
+                ui.themed_label(&bigger_font, &params.localization.get("keyboard-1"));
+            });
+            row.col(|ui| {
+                ui.themed_label(&bigger_font, &params.localization.get("keyboard-2"));
+            });
+            row.col(|ui| {
+                ui.themed_label(&bigger_font, &params.localization.get("gamepad"));
+            });
+        })
+        .body(|mut body| {
+            // Keep track of the input button index we are on
+            let mut input_idx = 0;
+
+            // Loop through the input rows
+            for (title, inputs) in &mut input_rows {
+                body.row(row_height, |mut row| {
+                    // Add row label
+                    row.col(|ui| {
+                        ui.themed_label(&label_font, title);
+                    });
+
+                    // Add buttons for each kind of input
+                    for (button_idx, input) in inputs.iter_mut().enumerate() {
+                        // The last button is a gamepad binding, the others are keyboard
+                        let binding_kind = if button_idx == 2 {
+                            BindingKind::Gamepad
+                        } else {
+                            BindingKind::Keyboard
+                        };
+
+                        // Render the button
+                        row.col(|ui| {
+                            let button = BorderedButton::themed(
+                                ui_theme,
+                                &ButtonStyle::Small,
+                                format_input(input),
+                            )
+                            .show(ui);
+
+                            // Start an input binding if the button is clicked
+                            if button.clicked() {
+                                *params.currently_binding_input_idx = Some(input_idx);
+                            }
+
+                            // If we are binding an input for this button
+                            if *params.currently_binding_input_idx == Some(input_idx) {
+                                // Render the binding window
+                                egui::Window::new("input_binding_overlay")
+                                    .auto_sized()
+                                    .collapsible(false)
+                                    .anchor(egui::Align2::CENTER_CENTER, egui::Vec2::ZERO)
+                                    .frame(egui::Frame::none())
+                                    .title_bar(false)
+                                    .show(ui.ctx(), |ui| {
+                                        let font = params
+                                            .game
+                                            .ui_theme
+                                            .font_styles
+                                            .get(&FontStyle::Normal)
+                                            .unwrap()
+                                            .colored(params.game.ui_theme.panel.font_color);
+
+                                        let border = &params.game.ui_theme.panel.border;
+                                        let m = &border.border_size;
+                                        let s = border.scale;
+                                        BorderedFrame::new(border)
+                                            // Just enough padding to fit the frame's border image
+                                            .padding(Margin {
+                                                left: m.left * s,
+                                                right: m.right * s,
+                                                top: m.top * s,
+                                                bottom: m.bottom * s,
+                                            })
+                                            .show(ui, |ui| {
+                                                ui.themed_label(
+                                                    &font,
+                                                    &params.localization.get("bind-input"),
+                                                );
+
+                                                // See if there has been any inputs of the kind we
+                                                // are binding.
+                                                let get_input =
+                                                    params.control_inputs.get_event(binding_kind);
+
+                                                // If there has been an input
+                                                if let Ok(Some(input_kind)) = get_input {
+                                                    // Stop listening for inputs
+                                                    *params.currently_binding_input_idx = None;
+
+                                                    // Reset the focus on the input button
+                                                    button.request_focus();
+
+                                                    // Set the input for this button to the pressed
+                                                    // input
+                                                    **input = input_kind;
+
+                                                // If the user cancelled the input binding
+                                                } else if get_input.is_err() {
+                                                    // Set the focus back on the button
+                                                    button.request_focus();
+                                                    // And stop listening for inputs
+                                                    *params.currently_binding_input_idx = None;
+                                                }
+
+                                                // Make sure we don't double-trigger any menu
+                                                // actions while on this menu by consuming all menu
+                                                // actions.
+                                                let mut menu_input = params.menu_input.single_mut();
+                                                for action in MenuAction::variants() {
+                                                    menu_input.consume(action);
+                                                }
+                                            });
+                                    });
+                            }
+
+                            // Add input button to the list
+                            input_buttons.push(button);
+                        });
+
+                        // Increment the input button index
+                        input_idx += 1;
+                    }
+                });
+            }
+        });
+
+    // Set adjacency for all of the gamepad input buttons
+    for row_idx in 0..input_rows.len() {
+        if row_idx == 0 {
+            // Reverse button order here so that the first input button gets priority when
+            // navigating down from the tabs.
+            for i in (0..3).rev() {
+                let button = &input_buttons[row_idx * 3 + i];
+
+                // The top row of buttons is below the settings tabs
+                for tab in settings_tabs {
+                    params.adjacencies.widget(tab).above(button);
+                }
+
+                // The last tab is considered to the left of the first button
+                if i == 0 {
+                    params
+                        .adjacencies
+                        .widget(button)
+                        .to_right_of(&settings_tabs[settings_tabs.len() - 1]);
+                }
+            }
+
+        // If this is the last row, the input buttons are above the bottom buttons
+        } else if row_idx == input_rows.len() - 1 {
+            for i in 0..3 {
+                let button_above = &input_buttons[(row_idx - 1) * 3 + i];
+                let button = &input_buttons[row_idx * 3 + i];
+
+                params
+                    .adjacencies
+                    .widget(button)
+                    .above(&bottom_buttons[i])
+                    .below(button_above);
+
+                // The first bottom button is to the right of the last input button
+                if i == 2 {
+                    params
+                        .adjacencies
+                        .widget(button)
+                        .to_left_of(&bottom_buttons[0]);
+                }
+            }
+
+        // If this is a middle row, set the input buttons to be below the ones in the row above
+        } else {
+            for i in 0..3 {
+                let button_above = &input_buttons[(row_idx - 1) * 3 + i];
+                let button = &input_buttons[row_idx * 3 + i];
+
+                params.adjacencies.widget(button).below(button_above);
+            }
+        }
+    }
+}
+
+/// Render the sound settings UI
+fn sound_settings_ui(_ui: &mut egui::Ui, _game: &GameMeta) {
+    // This is un-reachable right now
+    todo!("Implement sound settings UI");
+}
+
+/// Format an InputKind as a user-facing string
+fn format_input(input: &InputKind) -> String {
+    match input {
+        InputKind::SingleAxis(axis) => {
+            // If we set the positive low to 1.0, then that means we don't trigger on positive
+            // movement, and it must be a negative movement binding.
+            let direction = if axis.positive_low == 1.0 { "-" } else { "+" };
+
+            let stick = match axis.axis_type {
+                leafwing_input_manager::axislike::AxisType::Gamepad(axis) => format!("{:?}", axis),
+                other => format!("{:?}", other),
+            };
+
+            format!("{} {}", stick, direction)
+        }
+        other => other.to_string(),
+    }
+}
+
+/// Helper system param to get input events that we are interested in for input binding.
+#[derive(SystemParam)]
+pub struct ControlInputBindingEvents<'w, 's> {
+    keys: Res<'w, Input<KeyCode>>,
+    gamepad_buttons: Res<'w, Input<GamepadButton>>,
+    gamepad_events: EventReader<'w, 's, GamepadEvent>,
+}
+
+/// The kind of input binding to listen for.
+enum BindingKind {
+    Keyboard,
+    Gamepad,
+}
+
+impl<'w, 's> ControlInputBindingEvents<'w, 's> {
+    // Get the next event, if any
+    fn get_event(&mut self, binding_kind: BindingKind) -> Result<Option<InputKind>, ()> {
+        if self.keys.just_pressed(KeyCode::Escape) {
+            return Err(());
+        }
+
+        Ok(match binding_kind {
+            // If we are looking for keyboard inputs
+            BindingKind::Keyboard => {
+                // Just return the first pressed button we find
+                if let Some(&key_code) = self.keys.get_just_pressed().next() {
+                    Some(key_code.into())
+                } else {
+                    None
+                }
+            }
+            // If we are looking for gamepad events
+            BindingKind::Gamepad => {
+                // Return the first pressed button we find, if any
+                if let Some(&button) = self.gamepad_buttons.get_just_pressed().next() {
+                    Some(button.1.into())
+
+                // If we can't find a button pressed
+                } else {
+                    // Look for axes tilted more than 0.5 in either direction.
+                    for gamepad_event in self.gamepad_events.iter() {
+                        if let GamepadEventType::AxisChanged(axis, value) = gamepad_event.1 {
+                            // Create an axis positive movement binding
+                            if value > 0.5 {
+                                return Ok(Some(
+                                    SingleAxis {
+                                        axis_type: axis.into(),
+                                        positive_low: 0.1,
+                                        negative_low: -1.0,
+                                        value: None,
+                                    }
+                                    .into(),
+                                ));
+                            // Create an axis negative movement binding
+                            } else if value < -0.5 {
+                                return Ok(Some(
+                                    SingleAxis {
+                                        axis_type: axis.into(),
+                                        positive_low: 1.0,
+                                        negative_low: -0.1,
+                                        value: None,
+                                    }
+                                    .into(),
+                                ));
+                            }
+                        }
+                    }
+
+                    None
+                }
+            }
+        })
+    }
+}
diff --git a/src/ui/pause_menu.rs b/src/ui/pause_menu.rs
new file mode 100644
index 00000000..8a02a068
--- /dev/null
+++ b/src/ui/pause_menu.rs
@@ -0,0 +1,96 @@
+use bevy::prelude::*;
+use bevy_egui::*;
+use bevy_fluent::Localization;
+use iyes_loopless::state::NextState;
+
+use crate::{
+    metadata::{localization::LocalizationExt, ButtonStyle, FontStyle, GameMeta},
+    GameState,
+};
+
+use super::{
+    widgets::{bordered_button::BorderedButton, bordered_frame::BorderedFrame, EguiUIExt},
+    EguiContextExt,
+};
+
+pub fn pause_menu(
+    mut commands: Commands,
+    mut egui_context: ResMut<EguiContext>,
+    game: Res<GameMeta>,
+    non_camera_entities: Query<Entity, Without<Camera>>,
+    mut camera_transform: Query<&mut Transform, With<Camera>>,
+    localization: Res<Localization>,
+) {
+    let ui_theme = &game.ui_theme;
+
+    egui::CentralPanel::default()
+        .frame(egui::Frame::none())
+        .show(egui_context.ctx_mut(), |ui| {
+            let screen_rect = ui.max_rect();
+
+            let pause_menu_width = 300.0;
+            let x_margin = (screen_rect.width() - pause_menu_width) / 2.0;
+            let outer_margin = egui::style::Margin::symmetric(x_margin, screen_rect.height() * 0.2);
+
+            BorderedFrame::new(&ui_theme.panel.border)
+                .margin(outer_margin)
+                .padding(ui_theme.panel.padding.into())
+                .show(ui, |ui| {
+                    ui.set_min_width(ui.available_width());
+
+                    let heading_font = ui_theme
+                        .font_styles
+                        .get(&FontStyle::Heading)
+                        .expect("Missing 'heading' font style")
+                        .colored(ui_theme.panel.font_color);
+
+                    ui.vertical_centered(|ui| {
+                        ui.themed_label(&heading_font, &localization.get("paused"));
+
+                        ui.add_space(10.0);
+
+                        let width = ui.available_width();
+
+                        let continue_button = BorderedButton::themed(
+                            ui_theme,
+                            &ButtonStyle::Normal,
+                            &localization.get("continue"),
+                        )
+                        .min_size(egui::vec2(width, 0.0))
+                        .show(ui);
+
+                        // Focus continue button by default
+                        if ui.memory().focus().is_none() {
+                            continue_button.request_focus();
+                        }
+
+                        if continue_button.clicked() {
+                            commands.insert_resource(NextState(GameState::InGame));
+                        }
+
+                        if BorderedButton::themed(
+                            ui_theme,
+                            &ButtonStyle::Normal,
+                            &localization.get("main-menu"),
+                        )
+                        .min_size(egui::vec2(width, 0.0))
+                        .show(ui)
+                        .clicked()
+                        {
+                            // Clean up all entities other than the camera
+                            for entity in non_camera_entities.iter() {
+                                commands.entity(entity).despawn();
+                            }
+                            // Reset camera position
+                            let mut camera_transform = camera_transform.single_mut();
+                            camera_transform.translation.x = 0.0;
+                            camera_transform.translation.y = 0.0;
+
+                            // Show the main menu
+                            commands.insert_resource(NextState(GameState::MainMenu));
+                            ui.ctx().clear_focus();
+                        }
+                    });
+                })
+        });
+}
diff --git a/src/ui/widgets/bordered_button.rs b/src/ui/widgets/bordered_button.rs
index 74dfd642..a0183d0a 100644
--- a/src/ui/widgets/bordered_button.rs
+++ b/src/ui/widgets/bordered_button.rs
@@ -43,7 +43,7 @@ impl<'a> BorderedButton<'a> {
     pub fn themed(
         ui_theme: &'a UIThemeMeta,
         button_style: &'a ButtonStyle,
-        label: &'a str,
+        label: impl Into<RichText>,
     ) -> BorderedButton<'a> {
         let style = ui_theme
             .button_styles
@@ -51,7 +51,8 @@ impl<'a> BorderedButton<'a> {
             .expect("Missing button theme");
 
         BorderedButton::new(
-            egui::RichText::new(label)
+            label
+                .into()
                 .font(style.font.font_id())
                 .color(style.font.color),
         )
@@ -164,8 +165,8 @@ impl<'a> Widget for BorderedButton<'a> {
         let (rect, response) = ui.allocate_at_least(desired_size, sense);
         response.widget_info(|| WidgetInfo::labeled(WidgetType::Button, text.text()));
 
-        // Focus the button automatically when it is hovered
-        if response.hovered() {
+        // Focus the button automatically when it is hovered and the mouse is moving
+        if response.hovered() && ui.ctx().input().pointer.velocity().length_sq() > 0.0 {
             response.request_focus();
         }