diff --git a/src/audio/mod.rs b/src/audio/mod.rs
index 2bfcf09..466e22d 100644
--- a/src/audio/mod.rs
+++ b/src/audio/mod.rs
@@ -89,6 +89,9 @@ fn on_play_soundtrack_event(
     };
 
     for audio_player_entity in audio_player.iter_mut() {
+        if audio_player_entity.1.0 == track_handle {
+            return;
+        }
         commands.entity(audio_player_entity.0).despawn();
     }
 
diff --git a/src/screens/game.rs b/src/screens/game.rs
index 909e9af..487c6d9 100644
--- a/src/screens/game.rs
+++ b/src/screens/game.rs
@@ -1,13 +1,12 @@
-use bevy::{prelude::*, text::FontSmoothing};
+use bevy::prelude::*;
 use leafwing_input_manager::prelude::*;
 use rand::random_range;
 
 use crate::{
-    PIXEL_PERFECT_LAYERS, ScaleFactor,
+    PIXEL_PERFECT_LAYERS,
     audio::{PlaySfxEvent, PlaySoundtrackEvent, SoundEffect, Soundtrack},
     input::Action,
-    screens::Screen,
-    sundry::BLACK,
+    screens::{Screen, pause::PauseState},
 };
 
 #[derive(Resource)]
@@ -27,11 +26,15 @@ pub enum GameState {
     GameOver,
 }
 
-#[derive(Component)]
-struct Thruster;
+#[derive(SystemSet, Debug, Clone, Hash, Eq, PartialEq)]
+pub enum GameSystems {
+    Play,
+    Environment,
+    GameOver,
+}
 
 #[derive(Resource, PartialEq)]
-struct HasEntered(bool);
+pub struct HasEntered(pub bool);
 
 pub(super) fn plugin(app: &mut App) {
     app.init_state::<GameState>();
@@ -43,17 +46,16 @@ pub(super) fn plugin(app: &mut App) {
         // time_played: 0.0,
         // successful_trip: false,
     });
-    app.insert_resource::<HasEntered>(HasEntered(false));
-
-    app.add_systems(
-        OnEnter(Screen::Game),
-        |mut has_entered: ResMut<HasEntered>| {
-            has_entered.0 = false;
-        },
-    );
+    app.insert_resource(HasEntered(false));
+    app.add_observer(restart_game);
+    app.add_observer(back_to_menu);
 
     app.add_systems(OnEnter(Screen::Game), trigger_music);
-    app.add_systems(OnEnter(GameState::Play), spawn_game_screen);
+
+    app.add_systems(Startup, spawn_player);
+    app.configure_sets(Startup, GameSystems::Play);
+    app.configure_sets(Startup, GameSystems::Environment);
+
     app.add_systems(
         FixedUpdate,
         enter_player.run_if(
@@ -61,11 +63,6 @@ pub(super) fn plugin(app: &mut App) {
                 .and(in_state(GameState::Play).and(resource_equals(HasEntered(false)))),
         ),
     );
-    app.add_systems(OnEnter(GameState::GameOver), spawn_game_over);
-    app.add_systems(OnExit(GameState::GameOver), despawn_game_screen);
-    app.configure_sets(Startup, GameSystems::Play);
-    app.configure_sets(Startup, GameSystems::Environment);
-    app.configure_sets(Startup, GameSystems::GameOver);
 
     app.add_systems(
         FixedUpdate,
@@ -79,20 +76,6 @@ pub(super) fn plugin(app: &mut App) {
             .run_if(in_state(Screen::Game)),
     );
 
-    app.add_systems(
-        Update,
-        (pause)
-            .in_set(GameSystems::Play)
-            .run_if(in_state(Screen::Game).and(in_state(GameState::Play))),
-    );
-
-    app.add_systems(
-        Update,
-        (game_over_input)
-            .in_set(GameSystems::GameOver)
-            .run_if(in_state(Screen::Game)),
-    );
-
     app.add_systems(
         FixedUpdate,
         (
@@ -110,11 +93,10 @@ pub(super) fn plugin(app: &mut App) {
     )));
 }
 
-fn spawn_game_screen(
-    mut commands: Commands,
-    asset_server: Res<AssetServer>,
-    mut time: ResMut<Time<Virtual>>,
-) {
+#[derive(Component)]
+struct Thruster;
+
+fn spawn_player(mut commands: Commands, asset_server: Res<AssetServer>) {
     let default_speed = asset_server.load("sprites/ships/ship3-default.png");
     commands.spawn((
         Name::new("Player Ship"),
@@ -122,7 +104,6 @@ fn spawn_game_screen(
             can_shoot: true,
             timer: Timer::from_seconds(0.15, TimerMode::Once),
         },
-        DespawnOnExit(Screen::Game),
         Sprite {
             image: asset_server.load("sprites/ships/ship3.png"),
             custom_size: Some(Vec2::splat(32.0)),
@@ -148,8 +129,6 @@ fn spawn_game_screen(
             }
         )],
     ));
-
-    time.unpause();
 }
 
 fn enter_player(
@@ -180,33 +159,8 @@ fn enter_player(
     thruster_sprite.image = ship_speed_sprites.fast.clone();
 }
 
-fn despawn_game_screen(
-    mut commands: Commands,
-    player: Query<Entity, With<Player>>,
-    asteraids: Query<Entity, With<Asteroid>>,
-    projectiles: Query<Entity, With<Projectile>>,
-) {
-    let player = player.single().unwrap();
-    commands.entity(player).despawn();
-
-    for asteroid in asteraids.iter() {
-        commands.entity(asteroid).despawn();
-    }
-
-    for projectile in projectiles.iter() {
-        commands.entity(projectile).despawn();
-    }
-}
-
-#[derive(SystemSet, Debug, Clone, Hash, Eq, PartialEq)]
-enum GameSystems {
-    Play,
-    Environment,
-    GameOver,
-}
-
 #[derive(Component)]
-struct Player {
+pub struct Player {
     pub can_shoot: bool,
     pub timer: Timer,
 }
@@ -313,17 +267,6 @@ fn player_input(
     }
 }
 
-fn pause(mut time: ResMut<Time<Virtual>>, input_query: Query<&ActionState<Action>>) {
-    let action_state = input_query.single().unwrap();
-    if action_state.just_pressed(&Action::Pause) {
-        if time.is_paused() {
-            time.unpause();
-        } else {
-            time.pause();
-        }
-    }
-}
-
 fn update_projectiles(mut projectiles: Query<&mut Transform, With<Projectile>>) {
     for mut projectile in projectiles.iter_mut() {
         projectile.translation += Vec3::Y * 15.0;
@@ -430,19 +373,20 @@ fn spawn_asteroid(
 }
 
 fn collide_with_asteroid_check(
+    mut commands: Commands,
     player: Query<&Transform, With<Player>>,
     asteroids: Query<&Transform, With<Asteroid>>,
     mut time: ResMut<Time<Virtual>>,
     mut state: ResMut<NextState<GameState>>,
+    asset_server: Res<AssetServer>,
+    mut texture_atlases: ResMut<Assets<TextureAtlasLayout>>,
 ) {
     let player = player.single();
     if player.is_err() {
         return;
     }
     let player_transform = player.unwrap();
-
     let hitbox_size = 8.0;
-
     for asteroid_transform in asteroids.iter() {
         let distance = player_transform
             .translation
@@ -450,6 +394,29 @@ fn collide_with_asteroid_check(
         if distance < (hitbox_size / 2.0) + (30.0 / 2.0) {
             time.pause();
             state.set(GameState::GameOver);
+            commands.trigger(PlaySfxEvent {
+                sfx: SoundEffect::Explosion,
+            });
+            let texture_atlas_layout =
+                TextureAtlasLayout::from_grid(UVec2::splat(32), 8, 1, None, None);
+            let texture_atlas_handle = texture_atlases.add(texture_atlas_layout);
+            commands.trigger(PlaySfxEvent {
+                sfx: SoundEffect::Explosion,
+            });
+            commands.spawn((
+                Name::new("Explosion"),
+                Sprite::from_atlas_image(
+                    asset_server.load("sprites/explosion.png"),
+                    TextureAtlas::from(texture_atlas_handle),
+                ),
+                Transform {
+                    translation: player_transform.translation,
+                    ..default()
+                },
+                DespawnOnExit(Screen::Game),
+                Explosion,
+                PIXEL_PERFECT_LAYERS,
+            ));
         }
     }
 }
@@ -518,220 +485,50 @@ fn update_explosions(
     }
 }
 
-fn spawn_game_over(
-    mut commands: Commands,
-    asset_server: Res<AssetServer>,
-    scale_factor: Res<ScaleFactor>,
-    game_stats: Res<GameStats>,
-) {
-    let scale = scale_factor.0;
-    let font_handle: Handle<Font> = asset_server.load("font.ttf");
-
-    commands.spawn((
-        Name::new("Game Over Screen"),
-        Transform {
-            translation: Vec3::new(0.0, 0.0, 100.0),
-            ..default()
-        },
-        Node {
-            width: Val::Percent(70.0),
-            height: Val::Percent(70.0),
-            position_type: PositionType::Absolute,
-            justify_content: JustifyContent::Center,
-            margin: UiRect::all(Val::Auto),
-            ..default()
-        },
-        DespawnOnExit(Screen::Game),
-        DespawnOnExit(GameState::GameOver),
-        PIXEL_PERFECT_LAYERS,
-        children![
-            (
-                Name::new("Game Over Text"),
-                Text::new("GAME OVER"),
-                TextFont {
-                    font_size: 16.0 * scale,
-                    font: font_handle.clone(),
-                    font_smoothing: FontSmoothing::None,
-
-                    ..default()
-                },
-                Node {
-                    position_type: PositionType::Absolute,
-                    top: Val::Px(8.0 * scale),
-                    margin: UiRect {
-                        left: Val::Auto,
-                        right: Val::Auto,
-                        ..default()
-                    },
-                    ..default()
-                }
-            ),
-            (
-                Name::new("Stats container"),
-                Node {
-                    display: Display::Flex,
-                    flex_direction: FlexDirection::Column,
-                    ..default()
-                },
-                children![
-                    stats_row(
-                        "DISTANCE TRAVELED",
-                        &game_stats.distance_traveled.to_string(),
-                        scale,
-                        font_handle.clone(),
-                    ),
-                    stats_row(
-                        "SHOTS FIRED",
-                        &game_stats.shots_fired.to_string(),
-                        scale,
-                        font_handle.clone(),
-                    ),
-                    stats_row(
-                        "SHOTS HIT",
-                        &game_stats.shots_hit.to_string(),
-                        scale,
-                        font_handle.clone()
-                    ),
-                    stats_row(
-                        "ASTEROIDS DESTROYED",
-                        &game_stats.asteroids_destroyed.to_string(),
-                        scale,
-                        font_handle.clone(),
-                    ),
-                ]
-            ),
-            (
-                Name::new("Replay Button"),
-                Button,
-                Node {
-                    position_type: PositionType::Absolute,
-                    bottom: Val::Px(32.0 * scale),
-                    ..default()
-                },
-                children![(
-                    Name::new("Replay Button Text"),
-                    Text::new("REPLAY"),
-                    Node::default(),
-                    TextFont {
-                        font_size: 16.0 * scale,
-                        font: font_handle.clone(),
-                        font_smoothing: FontSmoothing::None,
-                        ..default()
-                    }
-                )],
-            ),
-            (
-                Name::new("Back to Menu Button"),
-                Button,
-                Node {
-                    position_type: PositionType::Absolute,
-                    bottom: Val::Px(8.0 * scale),
-                    ..default()
-                },
-                children![(
-                    Name::new("Back to Menu Text"),
-                    Text::new("BACK TO MENU"),
-                    Node::default(),
-                    TextFont {
-                        font_size: 16.0 * scale,
-                        font: font_handle.clone(),
-                        font_smoothing: FontSmoothing::None,
-
-                        ..default()
-                    }
-                )]
-            )
-        ],
-    ));
+fn trigger_music(mut commands: Commands) {
+    commands.trigger(PlaySoundtrackEvent {
+        soundtrack: Soundtrack::BattleTheme,
+    });
 }
 
-fn game_over_input(
-    input_query: Query<&ActionState<Action>>,
-    current_game_state: Res<State<GameState>>,
-    mut state: ResMut<NextState<GameState>>,
-    interaction_query: Query<&Interaction, (Changed<Interaction>, With<Button>)>,
+#[derive(Event)]
+pub struct RestartGame;
+
+fn restart_game(
+    _event: On<RestartGame>,
+    mut commands: Commands,
+    mut time: ResMut<Time<Virtual>>,
+    mut pause_state: ResMut<NextState<PauseState>>,
+    mut game_state: ResMut<NextState<GameState>>,
     mut has_entered: ResMut<HasEntered>,
     mut player: Query<&mut Transform, With<Player>>,
+    asteroids: Query<Entity, With<Asteroid>>,
+    projectiles: Query<Entity, With<Projectile>>,
 ) {
-    let action_state = input_query.single().unwrap();
-    if action_state.just_pressed(&Action::Select)
-        && current_game_state.get() == &GameState::GameOver
-    {
-        has_entered.0 = false;
-        let mut player_transform = player.single_mut().unwrap();
-        player_transform.translation = Vec3::new(0.0, -280.0, 0.0);
-        state.set(GameState::Play);
+    for asteroid in asteroids.iter() {
+        commands.entity(asteroid).despawn();
     }
 
-    for interaction in interaction_query.iter() {
-        match *interaction {
-            Interaction::Pressed => {
-                has_entered.0 = false;
-                let mut player_transform = player.single_mut().unwrap();
-                player_transform.translation = Vec3::new(0.0, -280.0, 0.0);
-                state.set(GameState::Play);
-            }
-            Interaction::Hovered => {}
-            Interaction::None => {}
-        }
+    for projectile in projectiles.iter() {
+        commands.entity(projectile).despawn();
     }
-}
 
-fn trigger_music(mut commands: Commands) {
-    commands.trigger(PlaySoundtrackEvent {
-        soundtrack: Soundtrack::BattleTheme,
-    });
+    pause_state.set(PauseState::NotPaused);
+    let mut player_transform = player.single_mut().unwrap();
+    player_transform.translation = Vec3::new(0.0, -280.0, 0.0);
+    has_entered.0 = false;
+    game_state.set(GameState::Play);
+    time.unpause();
 }
 
-fn stats_row(stat: &str, value: &str, scale: f32, font_handle: Handle<Font>) -> impl Bundle {
-    (
-        Name::new(format!("{stat} Stat")),
-        BackgroundColor(BLACK),
-        Node {
-            display: Display::Flex,
-            justify_content: JustifyContent::SpaceBetween,
-            top: Val::Px(32.0 * scale),
-            width: Val::Percent(100.0),
-            padding: UiRect {
-                top: Val::Px(8.0 * scale),
-                ..default()
-            },
-            margin: UiRect {
-                left: Val::Px(32.0 * scale),
-                right: Val::Px(32.0 * scale),
-                ..default()
-            },
-            ..default()
-        },
-        children![
-            (
-                Name::new(format!("{stat} Label")),
-                Text::new(stat),
-                TextFont {
-                    font_size: 16.0 * scale,
-                    font: font_handle.clone(),
-                    font_smoothing: FontSmoothing::None,
-                    ..default()
-                },
-                Node {
-                    left: Val::Px(0.0),
-                    ..default()
-                },
-            ),
-            (
-                Name::new(format!("{stat} Value")),
-                Text::new(value),
-                TextFont {
-                    font_size: 16.0 * scale,
-                    font: font_handle.clone(),
-                    font_smoothing: FontSmoothing::None,
-                    ..default()
-                },
-                Node {
-                    right: Val::Px(0.0),
-                    ..default()
-                }
-            )
-        ],
-    )
+#[derive(Event)]
+pub struct BackToMenuEvent;
+
+fn back_to_menu(
+    _event: On<BackToMenuEvent>,
+    mut commands: Commands,
+    mut screen_state: ResMut<NextState<Screen>>,
+) {
+    commands.trigger(RestartGame);
+    screen_state.set(Screen::Title);
 }
diff --git a/src/screens/gameover.rs b/src/screens/gameover.rs
new file mode 100644
index 0000000..0b6538b
--- /dev/null
+++ b/src/screens/gameover.rs
@@ -0,0 +1,306 @@
+use bevy::{prelude::*, text::FontSmoothing};
+use leafwing_input_manager::prelude::ActionState;
+
+use crate::{
+    PIXEL_PERFECT_LAYERS, ScaleFactor,
+    input::Action,
+    screens::{
+        Screen,
+        game::{GameState, GameStats, GameSystems, RestartGame},
+    },
+    sundry::{BLACK, MEDIUM_GRAY, WHITE},
+};
+
+pub(super) fn plugin(app: &mut App) {
+    app.insert_resource(GameOverActiveIndex(0));
+    app.configure_sets(Startup, GameSystems::GameOver);
+
+    app.add_systems(OnEnter(GameState::GameOver), spawn_game_over);
+    app.add_systems(
+        Update,
+        (game_over_buttons, game_over_input_system)
+            .in_set(GameSystems::GameOver)
+            .run_if(in_state(Screen::Game).and(in_state(GameState::GameOver))),
+    );
+    app.add_systems(
+        Update,
+        style_button_text.run_if(in_state(Screen::Game).and(in_state(GameState::GameOver))),
+    );
+}
+
+fn spawn_game_over(
+    mut commands: Commands,
+    asset_server: Res<AssetServer>,
+    scale_factor: Res<ScaleFactor>,
+    game_stats: Res<GameStats>,
+) {
+    let scale = scale_factor.0;
+    let font_handle: Handle<Font> = asset_server.load("font.ttf");
+
+    commands.spawn((
+        Name::new("Game Over Screen"),
+        Transform {
+            translation: Vec3::new(0.0, 0.0, 100.0),
+            ..default()
+        },
+        Node {
+            width: Val::Percent(70.0),
+            height: Val::Percent(70.0),
+            position_type: PositionType::Absolute,
+            justify_content: JustifyContent::Center,
+            margin: UiRect::all(Val::Auto),
+            ..default()
+        },
+        DespawnOnExit(GameState::GameOver),
+        PIXEL_PERFECT_LAYERS,
+        children![
+            (
+                Name::new("Game Over Text"),
+                Text::new("GAME OVER"),
+                TextFont {
+                    font_size: 16.0 * scale,
+                    font: font_handle.clone(),
+                    font_smoothing: FontSmoothing::None,
+                    ..default()
+                },
+                Node {
+                    position_type: PositionType::Absolute,
+                    top: Val::Px(8.0 * scale),
+                    margin: UiRect {
+                        left: Val::Auto,
+                        right: Val::Auto,
+                        ..default()
+                    },
+                    ..default()
+                }
+            ),
+            (
+                Name::new("Stats container"),
+                Node {
+                    display: Display::Flex,
+                    flex_direction: FlexDirection::Column,
+                    padding: UiRect::all(Val::Px(8.0 * scale)),
+                    ..default()
+                },
+                children![
+                    stats_row(
+                        "DISTANCE TRAVELED",
+                        &game_stats.distance_traveled.to_string(),
+                        scale,
+                        font_handle.clone(),
+                    ),
+                    stats_row(
+                        "SHOTS FIRED",
+                        &game_stats.shots_fired.to_string(),
+                        scale,
+                        font_handle.clone(),
+                    ),
+                    stats_row(
+                        "SHOTS HIT",
+                        &game_stats.shots_hit.to_string(),
+                        scale,
+                        font_handle.clone()
+                    ),
+                    stats_row(
+                        "ASTEROIDS DESTROYED",
+                        &game_stats.asteroids_destroyed.to_string(),
+                        scale,
+                        font_handle.clone(),
+                    ),
+                ]
+            ),
+            (
+                Name::new("Game Over Button Container"),
+                Node {
+                    position_type: PositionType::Absolute,
+                    display: Display::Flex,
+                    flex_direction: FlexDirection::Column,
+                    bottom: Val::Px(0.0),
+                    justify_content: JustifyContent::Center,
+                    align_items: AlignItems::Center,
+                    ..default()
+                },
+                children![
+                    game_over_button(
+                        "REPLAY",
+                        0,
+                        GameOverButton::Replay,
+                        font_handle.clone(),
+                        scale
+                    ),
+                    game_over_button(
+                        "BACK TO MENU",
+                        1,
+                        GameOverButton::BackToMenu,
+                        font_handle.clone(),
+                        scale
+                    )
+                ]
+            )
+        ],
+    ));
+}
+
+fn game_over_button(
+    button: &str,
+    index: usize,
+    game_over_button: GameOverButton,
+    font_handle: Handle<Font>,
+    scale: f32,
+) -> impl Bundle {
+    (
+        Name::new(format!("{button} Button")),
+        game_over_button,
+        Node::DEFAULT,
+        children![(
+            Name::new(format!("{button} Button Text")),
+            Text::new(button),
+            Node::default(),
+            GameOverButtonIndex(index),
+            TextFont {
+                font_size: 16.0 * scale,
+                font: font_handle.clone(),
+                font_smoothing: FontSmoothing::None,
+                ..default()
+            }
+        )],
+    )
+}
+
+#[derive(Component)]
+#[require(Button)]
+enum GameOverButton {
+    Replay,
+    BackToMenu,
+}
+
+#[derive(Component)]
+struct GameOverButtonIndex(usize);
+
+#[derive(Resource)]
+struct GameOverActiveIndex(usize);
+
+fn game_over_input_system(
+    mut commands: Commands,
+    input_query: Query<&ActionState<Action>>,
+    mut screen_state: ResMut<NextState<Screen>>,
+    mut active_index: ResMut<GameOverActiveIndex>,
+) {
+    let action_state = input_query.single().unwrap();
+
+    let max_index = 1;
+
+    if action_state.just_pressed(&Action::Up) {
+        if active_index.0 == 0 {
+            active_index.0 = max_index;
+        } else {
+            active_index.0 -= 1;
+        }
+    }
+    if action_state.just_pressed(&Action::Down) {
+        if active_index.0 == max_index {
+            active_index.0 = 0
+        } else {
+            active_index.0 += 1
+        };
+    }
+
+    if action_state.just_pressed(&Action::Select) {
+        if active_index.0 == 0 {
+            commands.trigger(RestartGame);
+        } else if active_index.0 == 1 {
+            commands.trigger(RestartGame);
+            screen_state.set(Screen::Title);
+        }
+    }
+}
+
+fn game_over_buttons(
+    mut commands: Commands,
+    interaction_query: Query<(&Interaction, &GameOverButton), Changed<Interaction>>,
+    mut screen_state: ResMut<NextState<Screen>>,
+    mut active_index: ResMut<GameOverActiveIndex>,
+) {
+    for (interaction, game_button) in interaction_query {
+        match *interaction {
+            Interaction::Pressed => match game_button {
+                GameOverButton::Replay => commands.trigger(RestartGame),
+                GameOverButton::BackToMenu => {
+                    commands.trigger(RestartGame);
+                    screen_state.set(Screen::Title);
+                }
+            },
+            Interaction::Hovered => match game_button {
+                GameOverButton::Replay => active_index.0 = 0,
+                GameOverButton::BackToMenu => active_index.0 = 1,
+            },
+            _ => {}
+        }
+    }
+}
+
+fn style_button_text(
+    mut text: Query<(&GameOverButtonIndex, &mut TextColor)>,
+    active: ResMut<GameOverActiveIndex>,
+) {
+    for (button_index, mut color) in text.iter_mut() {
+        if button_index.0 == active.0 {
+            color.0 = WHITE;
+        } else {
+            color.0 = MEDIUM_GRAY;
+        }
+    }
+}
+
+fn stats_row(stat: &str, value: &str, scale: f32, font_handle: Handle<Font>) -> impl Bundle {
+    (
+        Name::new(format!("{stat} Stat")),
+        BackgroundColor(BLACK),
+        Node {
+            display: Display::Flex,
+            justify_content: JustifyContent::SpaceBetween,
+            top: Val::Px(32.0 * scale),
+            width: Val::Percent(100.0),
+            padding: UiRect {
+                top: Val::Px(8.0 * scale),
+                ..default()
+            },
+            margin: UiRect {
+                left: Val::Px(32.0 * scale),
+                right: Val::Px(32.0 * scale),
+                ..default()
+            },
+            ..default()
+        },
+        children![
+            (
+                Name::new(format!("{stat} Label")),
+                Text::new(stat),
+                TextFont {
+                    font_size: 16.0 * scale,
+                    font: font_handle.clone(),
+                    font_smoothing: FontSmoothing::None,
+                    ..default()
+                },
+                Node {
+                    left: Val::Px(0.0),
+                    ..default()
+                },
+            ),
+            (
+                Name::new(format!("{stat} Value")),
+                Text::new(value),
+                TextFont {
+                    font_size: 16.0 * scale,
+                    font: font_handle.clone(),
+                    font_smoothing: FontSmoothing::None,
+                    ..default()
+                },
+                Node {
+                    right: Val::Px(0.0),
+                    ..default()
+                }
+            )
+        ],
+    )
+}
diff --git a/src/screens/mod.rs b/src/screens/mod.rs
index 5ab1e33..03d3eaf 100644
--- a/src/screens/mod.rs
+++ b/src/screens/mod.rs
@@ -1,13 +1,21 @@
 use bevy::prelude::*;
 
 mod game;
+mod gameover;
+mod pause;
 mod splash;
 mod title;
 
 pub(super) fn plugin(app: &mut App) {
     app.init_state::<Screen>();
 
-    app.add_plugins((splash::plugin, title::plugin, game::plugin));
+    app.add_plugins((
+        splash::plugin,
+        title::plugin,
+        game::plugin,
+        pause::plugin,
+        gameover::plugin,
+    ));
 }
 
 #[derive(States, Copy, Clone, Eq, PartialEq, Hash, Debug, Default)]
diff --git a/src/screens/pause.rs b/src/screens/pause.rs
new file mode 100644
index 0000000..40ebb79
--- /dev/null
+++ b/src/screens/pause.rs
@@ -0,0 +1,215 @@
+use bevy::{prelude::*, text::FontSmoothing};
+use leafwing_input_manager::prelude::ActionState;
+
+use crate::{
+    PIXEL_PERFECT_LAYERS, ScaleFactor,
+    input::Action,
+    screens::{
+        Screen,
+        game::{BackToMenuEvent, GameState, GameSystems},
+    },
+    sundry::{MEDIUM_GRAY, WHITE},
+};
+
+pub(super) fn plugin(app: &mut App) {
+    app.init_state::<PauseState>();
+    app.insert_resource(PauseActiveIndex(0));
+    app.add_observer(pause);
+    app.add_observer(resume);
+    app.add_systems(
+        Update,
+        (pause_button_system, pause_input_system)
+            .run_if(in_state(Screen::Game).and(in_state(PauseState::Paused))),
+    );
+    app.add_systems(
+        Update,
+        (pause_input)
+            .in_set(GameSystems::Play)
+            .run_if(in_state(Screen::Game).and(in_state(GameState::Play))),
+    );
+    app.add_systems(
+        Update,
+        style_button_text.run_if(in_state(Screen::Game).and(in_state(PauseState::Paused))),
+    );
+}
+
+#[derive(States, Copy, Clone, Eq, PartialEq, Hash, Debug, Default)]
+pub enum PauseState {
+    #[default]
+    NotPaused,
+    Paused,
+}
+
+#[derive(Component)]
+#[require(Button)]
+enum PauseButton {
+    Resume,
+    Menu,
+}
+
+#[derive(Component)]
+struct PauseButtonIndex(usize);
+
+#[derive(Resource)]
+struct PauseActiveIndex(usize);
+
+fn pause_input(
+    mut commands: Commands,
+    time: ResMut<Time<Virtual>>,
+    action_state: Single<&ActionState<Action>>,
+) {
+    if action_state.just_pressed(&Action::Pause) {
+        if time.is_paused() {
+            commands.trigger(ResumeEvent);
+        } else {
+            commands.trigger(PauseEvent);
+        }
+    }
+}
+
+#[derive(Event)]
+struct PauseEvent;
+
+fn pause(
+    _event: On<PauseEvent>,
+    commands: Commands,
+    mut time: ResMut<Time<Virtual>>,
+    asset_server: Res<AssetServer>,
+    scale_factor: Res<ScaleFactor>,
+    mut pause_state: ResMut<NextState<PauseState>>,
+    mut pause_active_index: ResMut<PauseActiveIndex>,
+) {
+    pause_active_index.0 = 0;
+    time.pause();
+    pause_state.set(PauseState::Paused);
+    spawn_pause_menu(commands, asset_server.load("font.ttf"), scale_factor.0);
+}
+
+#[derive(Event)]
+struct ResumeEvent;
+
+fn resume(
+    _event: On<ResumeEvent>,
+    mut time: ResMut<Time<Virtual>>,
+    mut pause_state: ResMut<NextState<PauseState>>,
+) {
+    time.unpause();
+    pause_state.set(PauseState::NotPaused);
+}
+
+fn pause_menu_button(
+    button: &str,
+    index: usize,
+    pause_button: PauseButton,
+    font_handle: Handle<Font>,
+    scale: f32,
+) -> impl Bundle {
+    (
+        Name::new(format!("{button} Button")),
+        pause_button,
+        children![(
+            Name::new(format!("{button} Button Text")),
+            Text::new(button),
+            PauseButtonIndex(index),
+            TextColor(WHITE),
+            TextFont {
+                font_size: 16.0 * scale,
+                font: font_handle,
+                font_smoothing: FontSmoothing::None,
+                ..default()
+            },
+            Node {
+                padding: UiRect::all(Val::Px(8.0 * scale)),
+                ..default()
+            }
+        )],
+    )
+}
+
+fn spawn_pause_menu(mut commands: Commands, font: Handle<Font>, scale: f32) {
+    commands.spawn((
+        Name::new("Pause Menu"),
+        Node {
+            position_type: PositionType::Absolute,
+            margin: UiRect::all(Val::Auto),
+            display: Display::Flex,
+            flex_direction: FlexDirection::Column,
+            justify_content: JustifyContent::Center,
+            align_items: AlignItems::Center,
+            ..default()
+        },
+        DespawnOnExit(PauseState::Paused),
+        PIXEL_PERFECT_LAYERS,
+        children![
+            pause_menu_button("RESUME", 0, PauseButton::Resume, font.clone(), scale),
+            pause_menu_button("BACK TO MENU", 1, PauseButton::Menu, font.clone(), scale),
+        ],
+    ));
+}
+
+fn pause_input_system(
+    mut commands: Commands,
+    input_query: Query<&ActionState<Action>>,
+    mut active_index: ResMut<PauseActiveIndex>,
+) {
+    let action_state: &ActionState<Action> = input_query.single().unwrap();
+
+    let max_index = 1;
+
+    if action_state.just_pressed(&Action::Up) {
+        if active_index.0 == 0 {
+            active_index.0 = max_index;
+        } else {
+            active_index.0 -= 1;
+        }
+    }
+
+    if action_state.just_pressed(&Action::Down) {
+        if active_index.0 == max_index {
+            active_index.0 = 0
+        } else {
+            active_index.0 += 1
+        };
+    }
+
+    if action_state.just_pressed(&Action::Select) {
+        if active_index.0 == 0 {
+            commands.trigger(ResumeEvent);
+        } else if active_index.0 == 1 {
+            commands.trigger(BackToMenuEvent);
+        }
+    }
+}
+
+fn pause_button_system(
+    mut commands: Commands,
+    interaction_query: Query<(&Interaction, &PauseButton), Changed<Interaction>>,
+    mut active_index: ResMut<PauseActiveIndex>,
+) {
+    for (interaction, pause_button) in interaction_query {
+        match *interaction {
+            Interaction::Pressed => match pause_button {
+                PauseButton::Resume => commands.trigger(ResumeEvent),
+                PauseButton::Menu => commands.trigger(BackToMenuEvent),
+            },
+            Interaction::Hovered => match pause_button {
+                PauseButton::Resume => active_index.0 = 0,
+                PauseButton::Menu => active_index.0 = 1,
+            },
+            _ => {}
+        }
+    }
+}
+
+fn style_button_text(
+    mut text: Query<(&PauseButtonIndex, &mut TextColor)>,
+    active: ResMut<PauseActiveIndex>,
+) {
+    for (button_index, mut color) in text.iter_mut() {
+        if button_index.0 == active.0 {
+            color.0 = WHITE;
+        } else {
+            color.0 = MEDIUM_GRAY;
+        }
+    }
+}
diff --git a/src/screens/splash.rs b/src/screens/splash.rs
index 48d0c6e..16017ae 100644
--- a/src/screens/splash.rs
+++ b/src/screens/splash.rs
@@ -84,7 +84,6 @@ fn setup_splash(
             translation: Vec3::new(-1000.0, -1000.0, -10.0),
             ..default()
         },
-        DespawnOnExit(Screen::Game),
         PIXEL_PERFECT_LAYERS,
     ));
     star_pool.inactive_stars.push(star.id());
diff --git a/src/screens/title.rs b/src/screens/title.rs
index 28da389..c5ea192 100644
--- a/src/screens/title.rs
+++ b/src/screens/title.rs
@@ -3,6 +3,7 @@ use leafwing_input_manager::prelude::ActionState;
 
 use crate::{
     PIXEL_PERFECT_LAYERS, ScaleFactor,
+    audio::{PlaySoundtrackEvent, Soundtrack},
     input::Action,
     screens::{Screen, splash::Title},
     sundry::{MEDIUM_GRAY, TRANSPARENT_MEDIUM_GRAY, WHITE},
@@ -20,7 +21,7 @@ pub(super) fn plugin(app: &mut App) {
 #[derive(Component)]
 enum MenuButton {
     NewGame,
-    Settings,
+    // Settings,
     #[cfg(not(target_arch = "wasm32"))]
     Quit,
 }
@@ -40,9 +41,30 @@ fn spawn_title_screen(
     mut title_transform: Query<&mut Transform, With<Title>>,
     scale_factor: Res<ScaleFactor>,
 ) {
+    commands.trigger(PlaySoundtrackEvent {
+        soundtrack: Soundtrack::MainTheme,
+    });
     let scale = scale_factor.0;
-    let mut transform = title_transform.single_mut().unwrap();
-    transform.translation = Vec3::new(0.0, 32.0, 0.0);
+    let transform = title_transform.single_mut();
+    if let Ok(mut transform) = transform {
+        transform.translation = Vec3::new(0.0, 32.0, 0.0);
+    } else {
+        commands.spawn((
+            Title,
+            Sprite {
+                image: asset_server.load("sprites/title.png"),
+                color: Color::srgb_u8(235, 237, 233),
+                custom_size: Some(Vec2::new(256.0, 64.0)),
+                ..default()
+            },
+            DespawnOnExit(Screen::Title),
+            Transform {
+                translation: Vec3::new(0.0, 32.0, 0.0),
+                ..default()
+            },
+            PIXEL_PERFECT_LAYERS,
+        ));
+    }
     let font_handle: Handle<Font> = asset_server.load("font.ttf");
 
     let new_game = title_menu_button(
@@ -52,20 +74,20 @@ fn spawn_title_screen(
         font_handle.clone(),
         scale,
     );
-    let settings = title_menu_button(
-        "SETTINGS",
-        1,
-        MenuButton::Settings,
-        font_handle.clone(),
-        scale,
-    );
+    // let settings = title_menu_button(
+    //     "SETTINGS",
+    //     1,
+    //     MenuButton::Settings,
+    //     font_handle.clone(),
+    //     scale,
+    // );
 
     #[cfg(target_arch = "wasm32")]
-    let menu_buttons = children![new_game, settings];
+    let menu_buttons = children![new_game];
     #[cfg(not(target_arch = "wasm32"))]
-    let quit = title_menu_button("QUIT", 2, MenuButton::Quit, font_handle.clone(), scale);
+    let quit = title_menu_button("QUIT", 1, MenuButton::Quit, font_handle.clone(), scale);
     #[cfg(not(target_arch = "wasm32"))]
-    let menu_buttons = children![new_game, settings, quit];
+    let menu_buttons = children![new_game, quit];
 
     commands.spawn((
         Node {
@@ -103,9 +125,9 @@ fn input_system(
     let action_state = input_query.single().unwrap();
 
     #[cfg(not(target_arch = "wasm32"))]
-    let max_index = 2;
-    #[cfg(target_arch = "wasm32")]
     let max_index = 1;
+    #[cfg(target_arch = "wasm32")]
+    let max_index = 0;
 
     if action_state.just_pressed(&Action::Up) {
         if active_index.0 == 0 {
@@ -137,9 +159,6 @@ fn input_system(
                 screen_state.set(Screen::Game);
             }
             1 => {
-                println!("Settings button pressed");
-            }
-            2 => {
                 message_writer.write(AppExit::Success);
             }
             _ => {}
@@ -160,9 +179,9 @@ fn button_system(
                 MenuButton::NewGame => {
                     screen_state.set(Screen::Game);
                 }
-                MenuButton::Settings => {
-                    println!("Settings button pressed");
-                }
+                // MenuButton::Settings => {
+                //     println!("Settings button pressed");
+                // }
                 #[cfg(not(target_arch = "wasm32"))]
                 MenuButton::Quit => {
                     message_writer.write(AppExit::Success);
@@ -176,12 +195,12 @@ fn button_system(
                     MenuButton::NewGame => {
                         active_index.0 = 0;
                     }
-                    MenuButton::Settings => {
-                        active_index.0 = 1;
-                    }
+                    // MenuButton::Settings => {
+                    //     active_index.0 = 1;
+                    // }
                     #[cfg(not(target_arch = "wasm32"))]
                     MenuButton::Quit => {
-                        active_index.0 = 2;
+                        active_index.0 = 1;
                     }
                 }
             }
diff --git a/src/stars/mod.rs b/src/stars/mod.rs
index 27b5992..8350e50 100644
--- a/src/stars/mod.rs
+++ b/src/stars/mod.rs
@@ -86,7 +86,6 @@ fn spawn_new_star(
             translation: Vec3::new(x, y, -10.0),
             ..default()
         },
-        DespawnOnExit(Screen::Game),
         PIXEL_PERFECT_LAYERS,
     ));
 }