diff --git a/Cargo.lock b/Cargo.lock
index 2b4624d..6f649bd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1664,6 +1664,12 @@ dependencies = [
  "libloading",
 ]
 
+[[package]]
+name = "claxon"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bfbf56724aa9eca8afa4fcfadeb479e722935bb2a0900c2d37e0cc477af0688"
+
 [[package]]
 name = "codespan-reporting"
 version = "0.12.0"
@@ -3792,6 +3798,7 @@ version = "0.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e7ceb6607dd738c99bc8cb28eff249b7cd5c8ec88b9db96c0608c1480d140fb1"
 dependencies = [
+ "claxon",
  "cpal",
  "hound",
  "lewton",
diff --git a/Cargo.toml b/Cargo.toml
index 2a57794..0f654ee 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -20,6 +20,7 @@ bevy = { version = "0.17.2", default-features = false, features = [
     "bevy_state",
     "bevy_audio",
     "multi_threaded",
+    "flac",
     "png",
     "std",
     "vorbis",
diff --git a/assets/soundtrack/space.flac b/assets/soundtrack/space.flac
new file mode 100644
index 0000000..6341773
Binary files /dev/null and b/assets/soundtrack/space.flac differ
diff --git a/assets/soundtrack/the-last-parsec.ogg b/assets/soundtrack/the-last-parsec.ogg
deleted file mode 100644
index 24eb898..0000000
Binary files a/assets/soundtrack/the-last-parsec.ogg and /dev/null differ
diff --git a/src/audio/mod.rs b/src/audio/mod.rs
index 466e22d..c6fe9b5 100644
--- a/src/audio/mod.rs
+++ b/src/audio/mod.rs
@@ -8,7 +8,7 @@ pub(super) fn plugin(app: &mut App) {
     app.init_resource::<SfxLibrary>();
     app.add_observer(on_play_soundtrack_event);
     app.add_observer(on_play_sfx_event);
-    app.add_systems(Update, fade_in);
+    app.add_systems(Update, (fade_in, fade_out));
 }
 
 #[derive(Resource)]
@@ -48,6 +48,7 @@ struct SoundtrackPlayer;
 pub struct Soundtracks {
     pub main_theme: Handle<AudioSource>,
     pub battle_theme: Handle<AudioSource>,
+    pub end_theme: Handle<AudioSource>,
 }
 
 impl FromWorld for Soundtracks {
@@ -56,17 +57,20 @@ impl FromWorld for Soundtracks {
         let soundtracks = Soundtracks {
             main_theme: asset_server.load("soundtrack/spacetheme.ogg"),
             battle_theme: asset_server.load("soundtrack/through-space.ogg"),
+            end_theme: asset_server.load("soundtrack/space.flac"),
         };
         Self {
             main_theme: soundtracks.main_theme,
             battle_theme: soundtracks.battle_theme,
+            end_theme: soundtracks.end_theme,
         }
     }
 }
 
 pub enum Soundtrack {
-    MainTheme,
-    BattleTheme,
+    Main,
+    Battle,
+    End,
 }
 
 #[derive(Event)]
@@ -84,29 +88,36 @@ fn on_play_soundtrack_event(
     >,
 ) {
     let track_handle = match soundtrack_event.soundtrack {
-        Soundtrack::MainTheme => soundtracks.main_theme.clone(),
-        Soundtrack::BattleTheme => soundtracks.battle_theme.clone(),
+        Soundtrack::Main => soundtracks.main_theme.clone(),
+        Soundtrack::Battle => soundtracks.battle_theme.clone(),
+        Soundtrack::End => soundtracks.end_theme.clone(),
     };
 
+    let mut is_already_playing = false;
     for audio_player_entity in audio_player.iter_mut() {
         if audio_player_entity.1.0 == track_handle {
-            return;
+            is_already_playing = true;
+        } else {
+            commands
+                .entity(audio_player_entity.0)
+                .insert(FadeOut { duration: 0.5 });
         }
-        commands.entity(audio_player_entity.0).despawn();
     }
 
-    commands.spawn((
-        SoundtrackPlayer,
-        AudioPlayer(track_handle.clone()),
-        PlaybackSettings {
-            mode: PlaybackMode::Loop,
-            volume: Volume::Linear(0.0),
-            ..default()
-        },
-        FadeIn { duration: 4.0 },
-        Transform::default(),
-        GlobalTransform::default(),
-    ));
+    if !is_already_playing {
+        commands.spawn((
+            SoundtrackPlayer,
+            AudioPlayer(track_handle.clone()),
+            PlaybackSettings {
+                mode: PlaybackMode::Loop,
+                volume: Volume::Linear(0.0),
+                ..default()
+            },
+            FadeIn { duration: 4.0 },
+            Transform::default(),
+            GlobalTransform::default(),
+        ));
+    }
 }
 
 fn on_play_sfx_event(sfx_event: On<PlaySfxEvent>, mut commands: Commands, sfx: Res<SfxLibrary>) {
@@ -148,3 +159,25 @@ fn fade_in(
         }
     }
 }
+
+#[derive(Component)]
+struct FadeOut {
+    duration: f32,
+}
+
+fn fade_out(
+    mut commands: Commands,
+    mut audio_sink: Query<(&FadeOut, &mut AudioSink, Entity)>,
+    time: Res<Time>,
+) {
+    for (fade_out, mut audio, entity) in audio_sink.iter_mut() {
+        let current_volume = audio.volume();
+        audio.set_volume(
+            current_volume.fade_towards(Volume::Linear(0.0), time.delta_secs() / fade_out.duration),
+        );
+        println!("fading out: {:?}", audio.volume().to_linear());
+        if audio.volume().to_linear() <= 0.15 {
+            commands.entity(entity).despawn();
+        }
+    }
+}
diff --git a/src/screens/endgame.rs b/src/screens/endgame.rs
new file mode 100644
index 0000000..1eda743
--- /dev/null
+++ b/src/screens/endgame.rs
@@ -0,0 +1,322 @@
+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(EndGameActiveIndex(0));
+    app.configure_sets(Startup, GameSystems::EndGame);
+
+    app.add_systems(OnEnter(GameState::EndGame), spawn_game_over);
+    app.add_systems(
+        Update,
+        (game_over_buttons, game_over_input_system)
+            .in_set(GameSystems::EndGame)
+            .run_if(in_state(Screen::Game).and(in_state(GameState::EndGame))),
+    );
+    app.add_systems(
+        Update,
+        style_button_text.run_if(in_state(Screen::Game).and(in_state(GameState::EndGame))),
+    );
+}
+
+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::EndGame),
+        PIXEL_PERFECT_LAYERS,
+        children![
+            (
+                Name::new("Game Over Text"),
+                Text::new("YOU SAVED HUMANITY"),
+                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(
+                        "TIME PLAYED",
+                        format!("{:.0}", &game_stats.time_played).as_str(),
+                        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,
+                        EndGameButton::Replay,
+                        font_handle.clone(),
+                        scale
+                    ),
+                    game_over_button(
+                        "CREDITS",
+                        1,
+                        EndGameButton::Credits,
+                        font_handle.clone(),
+                        scale
+                    ),
+                    game_over_button(
+                        "BACK TO MENU",
+                        2,
+                        EndGameButton::BackToMenu,
+                        font_handle.clone(),
+                        scale
+                    )
+                ]
+            )
+        ],
+    ));
+}
+
+fn game_over_button(
+    button: &str,
+    index: usize,
+    game_over_button: EndGameButton,
+    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(),
+            EndGameButtonIndex(index),
+            TextFont {
+                font_size: 16.0 * scale,
+                font: font_handle.clone(),
+                font_smoothing: FontSmoothing::None,
+                ..default()
+            }
+        )],
+    )
+}
+
+#[derive(Component)]
+#[require(Button)]
+enum EndGameButton {
+    Replay,
+    Credits,
+    BackToMenu,
+}
+
+#[derive(Component)]
+struct EndGameButtonIndex(usize);
+
+#[derive(Resource)]
+struct EndGameActiveIndex(usize);
+
+fn game_over_input_system(
+    mut commands: Commands,
+    input_query: Query<&ActionState<Action>>,
+    mut screen_state: ResMut<NextState<Screen>>,
+    mut active_index: ResMut<EndGameActiveIndex>,
+) {
+    let action_state = input_query.single().unwrap();
+
+    let max_index = 2;
+
+    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::Credits);
+        } else if active_index.0 == 2 {
+            commands.trigger(RestartGame);
+            screen_state.set(Screen::Title);
+        }
+    }
+}
+
+fn game_over_buttons(
+    mut commands: Commands,
+    interaction_query: Query<(&Interaction, &EndGameButton), Changed<Interaction>>,
+    mut screen_state: ResMut<NextState<Screen>>,
+    mut active_index: ResMut<EndGameActiveIndex>,
+) {
+    for (interaction, game_button) in interaction_query {
+        match *interaction {
+            Interaction::Pressed => match game_button {
+                EndGameButton::Replay => commands.trigger(RestartGame),
+                EndGameButton::Credits => {
+                    commands.trigger(RestartGame);
+                    screen_state.set(Screen::Credits);
+                }
+                EndGameButton::BackToMenu => {
+                    commands.trigger(RestartGame);
+                    screen_state.set(Screen::Title);
+                }
+            },
+            Interaction::Hovered => match game_button {
+                EndGameButton::Replay => active_index.0 = 0,
+                EndGameButton::Credits => active_index.0 = 1,
+                EndGameButton::BackToMenu => active_index.0 = 2,
+            },
+            _ => {}
+        }
+    }
+}
+
+fn style_button_text(
+    mut text: Query<(&EndGameButtonIndex, &mut TextColor)>,
+    active: ResMut<EndGameActiveIndex>,
+) {
+    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/game.rs b/src/screens/game.rs
index 487c6d9..4f56cef 100644
--- a/src/screens/game.rs
+++ b/src/screens/game.rs
@@ -15,7 +15,7 @@ pub struct GameStats {
     pub distance_traveled: u32,
     pub shots_fired: u32,
     pub shots_hit: u32,
-    // pub time_played: f32,
+    pub time_played: f32,
     // pub successful_trip: bool,
 }
 
@@ -24,6 +24,7 @@ pub enum GameState {
     #[default]
     Play,
     GameOver,
+    EndGame,
 }
 
 #[derive(SystemSet, Debug, Clone, Hash, Eq, PartialEq)]
@@ -31,6 +32,7 @@ pub enum GameSystems {
     Play,
     Environment,
     GameOver,
+    EndGame,
 }
 
 #[derive(Resource, PartialEq)]
@@ -43,19 +45,34 @@ pub(super) fn plugin(app: &mut App) {
         distance_traveled: 0,
         shots_fired: 0,
         shots_hit: 0,
-        // time_played: 0.0,
+        time_played: 0.0,
         // successful_trip: false,
     });
     app.insert_resource(HasEntered(false));
+    app.insert_resource(EndGame(false));
     app.add_observer(restart_game);
     app.add_observer(back_to_menu);
 
     app.add_systems(OnEnter(Screen::Game), trigger_music);
 
-    app.add_systems(Startup, spawn_player);
+    app.add_systems(Startup, (spawn_player, spawn_planet));
     app.configure_sets(Startup, GameSystems::Play);
     app.configure_sets(Startup, GameSystems::Environment);
 
+    app.add_systems(
+        Update,
+        stopwatch.run_if(in_state(GameState::Play).and(in_state(PauseState::NotPaused))),
+    );
+
+    app.add_systems(
+        FixedUpdate,
+        run_endgame.run_if(
+            in_state(GameState::Play)
+                .and(in_state(PauseState::NotPaused))
+                .and(resource_equals(EndGame(true))),
+        ),
+    );
+
     app.add_systems(
         FixedUpdate,
         enter_player.run_if(
@@ -136,11 +153,15 @@ fn enter_player(
     mut thruster: Query<&mut Sprite, With<Thruster>>,
     mut has_entered: ResMut<HasEntered>,
     mut game_stats: ResMut<GameStats>,
+    mut end_game: ResMut<EndGame>,
 ) {
     game_stats.asteroids_destroyed = 0;
     game_stats.distance_traveled = 0;
     game_stats.shots_fired = 0;
     game_stats.shots_hit = 0;
+    game_stats.time_played = 0.0;
+    println!("resetting end game");
+    end_game.0 = false;
     let player = player.single_mut();
     if player.is_err() {
         return;
@@ -150,6 +171,7 @@ fn enter_player(
     if player_transform.translation.y > -200.0 {
         player_transform.translation.y = -200.0;
         has_entered.0 = true;
+        game_stats.time_played = 0.0;
     }
     let thruster = thruster.single_mut();
     if thruster.is_err() {
@@ -185,6 +207,60 @@ struct Asteroid {
 #[derive(Resource)]
 struct AsteroidSpawnTimer(Timer);
 
+#[derive(Resource, PartialEq)]
+struct EndGame(bool);
+
+fn stopwatch(
+    mut commands: Commands,
+    time: Res<Time<Virtual>>,
+    mut game_stats: ResMut<GameStats>,
+    mut end_game: ResMut<EndGame>,
+) {
+    println!("time played: {:?}", game_stats.time_played);
+    if game_stats.time_played > 300.0 {
+        game_stats.time_played = 300.0;
+        end_game.0 = true;
+        commands.trigger(PlaySoundtrackEvent {
+            soundtrack: Soundtrack::End,
+        });
+    }
+    game_stats.time_played += time.delta_secs();
+}
+
+#[derive(Component)]
+struct Planet;
+
+fn spawn_planet(mut commands: Commands, asset_server: Res<AssetServer>) {
+    commands.spawn((
+        Planet,
+        Sprite {
+            image: asset_server.load("sprites/planet-smol.png"),
+            ..default()
+        },
+        Transform {
+            translation: Vec3 {
+                x: 0.0,
+                y: 400.0,
+                z: -11.0,
+            },
+            ..default()
+        },
+    ));
+}
+
+fn run_endgame(
+    mut planet: Single<&mut Transform, With<Planet>>,
+    mut time: ResMut<Time<Virtual>>,
+    mut game_state: ResMut<NextState<GameState>>,
+) {
+    planet.translation.y -= 0.5;
+    if planet.translation.y < -100.0 {
+        planet.translation.y = -100.0;
+        time.pause();
+        game_state.set(GameState::EndGame);
+    }
+}
+
 fn player_input(
     mut commands: Commands,
     input_query: Query<&ActionState<Action>>,
@@ -278,7 +354,11 @@ fn spawn_asteroids(
     asset_server: Res<AssetServer>,
     mut timer: ResMut<AsteroidSpawnTimer>,
     time: Res<Time<Virtual>>,
+    end_game: Res<EndGame>,
 ) {
+    if end_game.0 {
+        return;
+    }
     timer.0.tick(time.delta());
     if !timer.0.is_finished() {
         return;
@@ -487,7 +567,7 @@ fn update_explosions(
 
 fn trigger_music(mut commands: Commands) {
     commands.trigger(PlaySoundtrackEvent {
-        soundtrack: Soundtrack::BattleTheme,
+        soundtrack: Soundtrack::Battle,
     });
 }
 
@@ -504,6 +584,8 @@ fn restart_game(
     mut player: Query<&mut Transform, With<Player>>,
     asteroids: Query<Entity, With<Asteroid>>,
     projectiles: Query<Entity, With<Projectile>>,
+    mut end_game: ResMut<EndGame>,
+    mut planet: Query<&mut Transform, (With<Planet>, Without<Player>)>,
 ) {
     for asteroid in asteroids.iter() {
         commands.entity(asteroid).despawn();
@@ -513,9 +595,14 @@ fn restart_game(
         commands.entity(projectile).despawn();
     }
 
+    end_game.0 = false;
     pause_state.set(PauseState::NotPaused);
     let mut player_transform = player.single_mut().unwrap();
     player_transform.translation = Vec3::new(0.0, -280.0, 0.0);
+
+    let mut planet_transform = planet.single_mut().unwrap();
+    planet_transform.translation = Vec3::new(0.0, 400.0, -11.0);
+
     has_entered.0 = false;
     game_state.set(GameState::Play);
     time.unpause();
diff --git a/src/screens/gameover.rs b/src/screens/gameover.rs
index 0b6538b..01eb617 100644
--- a/src/screens/gameover.rs
+++ b/src/screens/gameover.rs
@@ -84,8 +84,8 @@ fn spawn_game_over(
                 },
                 children![
                     stats_row(
-                        "DISTANCE TRAVELED",
-                        &game_stats.distance_traveled.to_string(),
+                        "TIME PLAYED",
+                        format!("{:.0}", &game_stats.time_played).as_str(),
                         scale,
                         font_handle.clone(),
                     ),
@@ -129,8 +129,15 @@ fn spawn_game_over(
                         scale
                     ),
                     game_over_button(
-                        "BACK TO MENU",
+                        "CREDITS",
                         1,
+                        GameOverButton::Credits,
+                        font_handle.clone(),
+                        scale
+                    ),
+                    game_over_button(
+                        "BACK TO MENU",
+                        2,
                         GameOverButton::BackToMenu,
                         font_handle.clone(),
                         scale
@@ -171,6 +178,7 @@ fn game_over_button(
 #[require(Button)]
 enum GameOverButton {
     Replay,
+    Credits,
     BackToMenu,
 }
 
@@ -188,7 +196,7 @@ fn game_over_input_system(
 ) {
     let action_state = input_query.single().unwrap();
 
-    let max_index = 1;
+    let max_index = 2;
 
     if action_state.just_pressed(&Action::Up) {
         if active_index.0 == 0 {
@@ -209,6 +217,9 @@ fn game_over_input_system(
         if active_index.0 == 0 {
             commands.trigger(RestartGame);
         } else if active_index.0 == 1 {
+            commands.trigger(RestartGame);
+            screen_state.set(Screen::Credits);
+        } else if active_index.0 == 2 {
             commands.trigger(RestartGame);
             screen_state.set(Screen::Title);
         }
@@ -225,6 +236,10 @@ fn game_over_buttons(
         match *interaction {
             Interaction::Pressed => match game_button {
                 GameOverButton::Replay => commands.trigger(RestartGame),
+                GameOverButton::Credits => {
+                    commands.trigger(RestartGame);
+                    screen_state.set(Screen::Credits);
+                }
                 GameOverButton::BackToMenu => {
                     commands.trigger(RestartGame);
                     screen_state.set(Screen::Title);
@@ -232,7 +247,8 @@ fn game_over_buttons(
             },
             Interaction::Hovered => match game_button {
                 GameOverButton::Replay => active_index.0 = 0,
-                GameOverButton::BackToMenu => active_index.0 = 1,
+                GameOverButton::Credits => active_index.0 = 1,
+                GameOverButton::BackToMenu => active_index.0 = 2,
             },
             _ => {}
         }
diff --git a/src/screens/mod.rs b/src/screens/mod.rs
index 3640453..97d301f 100644
--- a/src/screens/mod.rs
+++ b/src/screens/mod.rs
@@ -1,6 +1,7 @@
 use bevy::prelude::*;
 
 mod credits;
+mod endgame;
 mod game;
 mod gameover;
 mod pause;
@@ -17,6 +18,7 @@ pub(super) fn plugin(app: &mut App) {
         credits::plugin,
         pause::plugin,
         gameover::plugin,
+        endgame::plugin,
     ));
 }
 
diff --git a/src/screens/splash.rs b/src/screens/splash.rs
index 16017ae..f0560b7 100644
--- a/src/screens/splash.rs
+++ b/src/screens/splash.rs
@@ -81,7 +81,7 @@ fn setup_splash(
             ..default()
         },
         Transform {
-            translation: Vec3::new(-1000.0, -1000.0, -10.0),
+            translation: Vec3::new(-1000.0, -1000.0, -15.0),
             ..default()
         },
         PIXEL_PERFECT_LAYERS,
@@ -173,7 +173,7 @@ fn fade_out(
 
 fn trigger_music(mut commands: Commands) {
     commands.trigger(PlaySoundtrackEvent {
-        soundtrack: Soundtrack::MainTheme,
+        soundtrack: Soundtrack::Main,
     });
 }
 
diff --git a/src/screens/title.rs b/src/screens/title.rs
index 970886e..48f94e1 100644
--- a/src/screens/title.rs
+++ b/src/screens/title.rs
@@ -5,7 +5,7 @@ use crate::{
     PIXEL_PERFECT_LAYERS, ScaleFactor,
     audio::{PlaySoundtrackEvent, Soundtrack},
     input::Action,
-    screens::{Screen, splash::Title},
+    screens::{Screen, game::RestartGame, splash::Title},
     sundry::{MEDIUM_GRAY, TRANSPARENT_MEDIUM_GRAY, WHITE},
 };
 
@@ -43,7 +43,7 @@ fn spawn_title_screen(
     scale_factor: Res<ScaleFactor>,
 ) {
     commands.trigger(PlaySoundtrackEvent {
-        soundtrack: Soundtrack::MainTheme,
+        soundtrack: Soundtrack::Main,
     });
     let scale = scale_factor.0;
     let transform = title_transform.single_mut();
@@ -124,6 +124,7 @@ fn spawn_title_screen(
 }
 
 fn input_system(
+    mut commands: Commands,
     input_query: Query<&ActionState<Action>>,
     mut screen_state: ResMut<NextState<Screen>>,
     mut message_writer: MessageWriter<AppExit>,
@@ -165,6 +166,7 @@ fn input_system(
         match active_index.0 {
             0 => {
                 screen_state.set(Screen::Game);
+                commands.trigger(RestartGame);
             }
             1 => {
                 screen_state.set(Screen::Credits);
@@ -187,7 +189,10 @@ fn button_system(
     for (interaction, menu_button, children) in interaction_query {
         match *interaction {
             Interaction::Pressed => match menu_button {
-                MenuButton::NewGame => screen_state.set(Screen::Game),
+                MenuButton::NewGame => {
+                    screen_state.set(Screen::Game);
+                    commands.trigger(RestartGame);
+                }
                 // MenuButton::Settings => {
                 //     println!("Settings button pressed");
                 // }
diff --git a/src/stars/mod.rs b/src/stars/mod.rs
index 8350e50..11ca103 100644
--- a/src/stars/mod.rs
+++ b/src/stars/mod.rs
@@ -45,7 +45,7 @@ fn spawn_stars(
     if let Some(entity) = star_entity {
         commands.entity(entity).insert((
             Transform {
-                translation: Vec3::new(x, y, -10.0),
+                translation: Vec3::new(x, y, -15.0),
                 ..default()
             },
             Sprite {
@@ -83,7 +83,7 @@ fn spawn_new_star(
             ..default()
         },
         Transform {
-            translation: Vec3::new(x, y, -10.0),
+            translation: Vec3::new(x, y, -15.0),
             ..default()
         },
         PIXEL_PERFECT_LAYERS,