diff --git a/Cargo.lock b/Cargo.lock
index 7666376923..6205821c53 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4828,9 +4828,9 @@ dependencies = [
 
 [[package]]
 name = "shlex"
-version = "1.2.0"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7cee0529a6d40f580e7a5e6c495c8fbfe21b7b52795ed4bb5e62cdf92bc6380"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "simba"
diff --git a/assets/game.yaml b/assets/game.yaml
index 7d2b8a5834..49b6743bb7 100644
--- a/assets/game.yaml
+++ b/assets/game.yaml
@@ -30,6 +30,7 @@ main_menu:
   menu_width: 350
 
 default_settings:
+  main_volume: 1.0
   matchmaking_server: matchmaker.bones.fishfolk.org:65534
   player_controls:
     # Gamepad controls
diff --git a/assets/locales/en-US/settings.ftl b/assets/locales/en-US/settings.ftl
index 2363951568..79ab2c36f0 100644
--- a/assets/locales/en-US/settings.ftl
+++ b/assets/locales/en-US/settings.ftl
@@ -19,6 +19,13 @@ action = Action
 networking = Networking
 matchmaking-server = Matchmaking Server
 
+# Audio settings
+audio = Audio
+volume = Volume
+volume-main = Main
+volume-music = Music
+volume-effects = Effects
+
 # Graphics settings
 graphics = Graphics
 fullscreen = Fullscreen
diff --git a/src/audio.rs b/src/audio.rs
new file mode 100644
index 0000000000..fd3882f0f9
--- /dev/null
+++ b/src/audio.rs
@@ -0,0 +1,210 @@
+use std::collections::VecDeque;
+
+use bones_framework::prelude::kira::{
+    sound::{
+        static_sound::{StaticSoundHandle, StaticSoundSettings},
+        PlaybackState,
+    },
+    tween::{self, Tween},
+    Volume,
+};
+
+use crate::prelude::*;
+
+pub mod music;
+
+pub use music::*;
+
+pub fn game_plugin(game: &mut Game) {
+    game.init_shared_resource::<AudioCenter>();
+
+    let session = game.sessions.create(SessionNames::AUDIO);
+
+    // Audio doesn't do any rendering
+    session.visible = false;
+    session
+        .stages
+        .add_system_to_stage(First, music_system)
+        .add_system_to_stage(First, process_audio_events)
+        .add_system_to_stage(Last, kill_finished_audios);
+}
+
+/// A resource that can be used to control game audios.
+#[derive(HasSchema)]
+#[schema(no_clone)]
+pub struct AudioCenter {
+    /// Buffer for audio events that have not yet been processed.
+    events: VecDeque<AudioEvent>,
+    /// The handle to the current music.
+    music: Option<Audio>,
+}
+
+impl Default for AudioCenter {
+    fn default() -> Self {
+        Self {
+            events: VecDeque::with_capacity(16),
+            music: None,
+        }
+    }
+}
+
+impl AudioCenter {
+    /// Push an audio event to the queue for later processing.
+    pub fn event(&mut self, event: AudioEvent) {
+        self.events.push_back(event);
+    }
+
+    /// Get the playback state of the music.
+    pub fn music_state(&self) -> Option<PlaybackState> {
+        self.music.as_ref().map(|m| m.handle.state())
+    }
+
+    /// Play a sound. These are usually short audios that indicate something
+    /// happened in game, e.g. a player jump, an explosion, etc.
+    pub fn play_sound(&mut self, sound_source: Handle<AudioSource>, volume: f64) {
+        self.events.push_back(AudioEvent::PlaySound {
+            sound_source,
+            volume,
+        })
+    }
+
+    /// Play some music. These may or may not loop.
+    ///
+    /// Any current music is stopped.
+    pub fn play_music(
+        &mut self,
+        sound_source: Handle<AudioSource>,
+        sound_settings: StaticSoundSettings,
+    ) {
+        self.events.push_back(AudioEvent::PlayMusic {
+            sound_source,
+            sound_settings: Box::new(sound_settings),
+        });
+    }
+}
+
+/// An audio event that may be sent to the [`AudioCenter`] resource for
+/// processing.
+#[derive(Clone, Debug)]
+pub enum AudioEvent {
+    /// Update the volume of all audios using the new values.
+    VolumeChange {
+        main_volume: f64,
+        music_volume: f64,
+        effects_volume: f64,
+    },
+    /// Play some music.
+    ///
+    /// Any current music is stopped.
+    PlayMusic {
+        /// The handle for the music.
+        sound_source: Handle<AudioSource>,
+        /// The settings for the music.
+        sound_settings: Box<StaticSoundSettings>,
+    },
+    /// Play a sound.
+    PlaySound {
+        /// The handle to the sound to play.
+        sound_source: Handle<AudioSource>,
+        /// The volume to play the sound at.
+        volume: f64,
+    },
+}
+
+#[derive(HasSchema)]
+#[schema(no_clone, no_default, opaque)]
+#[repr(C)]
+pub struct Audio {
+    /// The handle for the audio.
+    handle: StaticSoundHandle,
+    /// The original volume requested for the audio.
+    volume: f64,
+}
+
+fn process_audio_events(
+    mut audio_manager: ResMut<AudioManager>,
+    mut audio_center: ResMut<AudioCenter>,
+    assets: ResInit<AssetServer>,
+    mut entities: ResMut<Entities>,
+    mut audios: CompMut<Audio>,
+    storage: Res<Storage>,
+) {
+    let settings = storage.get::<Settings>().unwrap();
+
+    for event in audio_center.events.drain(..).collect::<Vec<_>>() {
+        match event {
+            AudioEvent::VolumeChange {
+                main_volume,
+                music_volume,
+                effects_volume,
+            } => {
+                let tween = Tween::default();
+                // Update music volume
+                if let Some(music) = &mut audio_center.music {
+                    let volume = main_volume * music_volume * music.volume;
+                    if let Err(err) = music.handle.set_volume(volume, tween) {
+                        warn!("Error setting music volume: {err}");
+                    }
+                }
+                // Update sound volumes
+                for audio in audios.iter_mut() {
+                    let volume = main_volume * effects_volume * audio.volume;
+                    if let Err(err) = audio.handle.set_volume(volume, tween) {
+                        warn!("Error setting audio volume: {err}");
+                    }
+                }
+            }
+            AudioEvent::PlayMusic {
+                sound_source,
+                mut sound_settings,
+            } => {
+                // Stop the current music
+                if let Some(mut music) = audio_center.music.take() {
+                    let tween = Tween {
+                        start_time: kira::StartTime::Immediate,
+                        duration: MUSIC_FADE_DURATION,
+                        easing: tween::Easing::Linear,
+                    };
+                    music.handle.stop(tween).unwrap();
+                }
+                // Scale the requested volume by the settings value
+                let volume = match sound_settings.volume {
+                    tween::Value::Fixed(vol) => vol.as_amplitude(),
+                    _ => MUSIC_VOLUME,
+                };
+                let scaled_volume = settings.main_volume * settings.music_volume * volume;
+                sound_settings.volume = tween::Value::Fixed(Volume::Amplitude(scaled_volume));
+                // Play the new music
+                let sound_data = assets.get(sound_source).with_settings(*sound_settings);
+                match audio_manager.play(sound_data) {
+                    Err(err) => warn!("Error playing music: {err}"),
+                    Ok(handle) => audio_center.music = Some(Audio { handle, volume }),
+                }
+            }
+            AudioEvent::PlaySound {
+                sound_source,
+                volume,
+            } => {
+                let scaled_volume = settings.main_volume * settings.effects_volume * volume;
+                let sound_data = assets
+                    .get(sound_source)
+                    .with_settings(StaticSoundSettings::default().volume(scaled_volume));
+                match audio_manager.play(sound_data) {
+                    Err(err) => warn!("Error playing sound: {err}"),
+                    Ok(handle) => {
+                        let audio_ent = entities.create();
+                        audios.insert(audio_ent, Audio { handle, volume });
+                    }
+                }
+            }
+        }
+    }
+}
+
+fn kill_finished_audios(entities: Res<Entities>, audios: Comp<Audio>, mut commands: Commands) {
+    for (audio_ent, audio) in entities.iter_with(&audios) {
+        if audio.handle.state() == PlaybackState::Stopped {
+            commands.add(move |mut entities: ResMut<Entities>| entities.kill(audio_ent));
+        }
+    }
+}
diff --git a/src/audio/music.rs b/src/audio/music.rs
new file mode 100644
index 0000000000..954c9273c2
--- /dev/null
+++ b/src/audio/music.rs
@@ -0,0 +1,101 @@
+use bones_framework::prelude::kira::{
+    sound::{static_sound::StaticSoundSettings, PlaybackState, Region},
+    tween::Tween,
+};
+
+use crate::{prelude::*, ui::main_menu::MenuPage};
+
+/// The music playback state.
+#[derive(HasSchema, Default, PartialEq, Eq)]
+#[schema(no_clone)]
+pub enum MusicState {
+    /// Music is not playing.
+    #[default]
+    None,
+    /// Playing the main menu music.
+    MainMenu,
+    /// Playing the character select music.
+    CharacterSelect,
+    /// Playing the credits music.
+    Credits,
+    /// Playing the fight music.
+    Fight {
+        /// The index of the song in the shuffled playlist.
+        idx: usize,
+    },
+}
+
+/// Bevy resource containing the in-game music playlist shuffled.
+#[derive(HasSchema, Deref, DerefMut, Clone, Default)]
+#[repr(C)]
+pub struct ShuffledPlaylist(pub SVec<Handle<AudioSource>>);
+
+/// The amount of time to spend fading the music in and out.
+pub const MUSIC_FADE_DURATION: Duration = Duration::from_millis(500);
+
+pub const MUSIC_VOLUME: f64 = 0.1;
+
+/// System that plays music according to the game mode.
+pub(super) fn music_system(
+    meta: Root<GameMeta>,
+    mut audio: ResMut<AudioCenter>,
+    mut shuffled_fight_music: ResMutInit<ShuffledPlaylist>,
+    mut music_state: ResMutInit<MusicState>,
+    ctx: Res<EguiCtx>,
+    sessions: Res<Sessions>,
+) {
+    if shuffled_fight_music.is_empty() {
+        let mut songs = meta.music.fight.clone();
+        THREAD_RNG.with(|rng| rng.shuffle(&mut songs));
+        **shuffled_fight_music = songs;
+    }
+
+    let tween = Tween {
+        start_time: kira::StartTime::Immediate,
+        duration: MUSIC_FADE_DURATION,
+        easing: kira::tween::Easing::Linear,
+    };
+    let play_settings = StaticSoundSettings::default()
+        .volume(MUSIC_VOLUME)
+        .fade_in_tween(tween);
+
+    // If we are in a game
+    if sessions.get(SessionNames::GAME).is_some() {
+        if let MusicState::Fight { idx } = &mut *music_state {
+            if let Some(PlaybackState::Stopped) = audio.music_state() {
+                *idx = (*idx + 1) % shuffled_fight_music.len();
+                audio.play_music(shuffled_fight_music[*idx], play_settings);
+            }
+        } else if let Some(song) = shuffled_fight_music.get(0) {
+            audio.play_music(*song, play_settings);
+            *music_state = MusicState::Fight { idx: 0 };
+        }
+
+    // If we are on a menu page
+    } else if sessions.get(SessionNames::MAIN_MENU).is_some() {
+        let menu_page = ctx.get_state::<MenuPage>();
+        match menu_page {
+            MenuPage::PlayerSelect | MenuPage::MapSelect { .. } | MenuPage::NetworkGame => {
+                if *music_state != MusicState::CharacterSelect {
+                    audio.play_music(
+                        meta.music.title_screen,
+                        play_settings.loop_region(Region::default()),
+                    );
+                    *music_state = MusicState::CharacterSelect;
+                }
+            }
+            MenuPage::Home | MenuPage::Settings => {
+                if *music_state != MusicState::MainMenu {
+                    audio.play_music(meta.music.title_screen, play_settings);
+                    *music_state = MusicState::MainMenu;
+                }
+            }
+            MenuPage::Credits => {
+                if *music_state != MusicState::Credits {
+                    audio.play_music(meta.music.credits, play_settings);
+                    *music_state = MusicState::Credits;
+                }
+            }
+        }
+    }
+}
diff --git a/src/core.rs b/src/core.rs
index 1a05921708..cc319696e0 100644
--- a/src/core.rs
+++ b/src/core.rs
@@ -1,5 +1,4 @@
 pub mod attachment;
-pub mod audio;
 pub mod bullet;
 pub mod camera;
 pub mod damage;
@@ -30,7 +29,7 @@ use crate::{prelude::*, settings::PlayerControlMapping};
 
 pub mod prelude {
     pub use super::{
-        attachment::*, audio::*, bullet::*, camera::*, damage::*, debug::*, editor::*, editor::*,
+        attachment::*, bullet::*, camera::*, damage::*, debug::*, editor::*, editor::*,
         elements::prelude::*, flappy_jellyfish::*, globals::*, input::*, item::*, lifetime::*,
         map::*, map_constructor::*, metadata::*, physics::*, player::*, random::*, utils::*, FPS,
         MAX_PLAYERS,
@@ -67,8 +66,7 @@ impl SessionPlugin for MatchPlugin {
     fn install(self, session: &mut Session) {
         session
             .install_plugin(DefaultSessionPlugin)
-            .install_plugin(LuaPluginLoaderSessionPlugin(self.plugins))
-            .install_plugin(audio::session_plugin);
+            .install_plugin(LuaPluginLoaderSessionPlugin(self.plugins));
 
         physics::install(session);
         input::install(session);
diff --git a/src/core/audio.rs b/src/core/audio.rs
deleted file mode 100644
index ca24a16841..0000000000
--- a/src/core/audio.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-use std::collections::VecDeque;
-
-use bones_framework::prelude::kira::sound::static_sound::StaticSoundSettings;
-
-use crate::prelude::*;
-
-pub fn session_plugin(session: &mut Session) {
-    session.add_system_to_stage(Last, play_sounds);
-}
-
-/// Resource containing the audio event queue.
-#[derive(Default, HasSchema, Clone, Debug)]
-pub struct AudioEvents {
-    /// List of audio events that haven't been handled by the audio system yet.
-    pub queue: VecDeque<AudioEvent>,
-}
-
-impl AudioEvents {
-    /// Add an event to the audio event queue.
-    pub fn send(&mut self, event: AudioEvent) {
-        self.queue.push_back(event);
-    }
-
-    /// Play a sound.
-    ///
-    /// Shortcut for sending an [`AudioEvent`] with [`send()`][Self::send].
-    pub fn play(&mut self, sound_source: Handle<AudioSource>, volume: f64) {
-        self.queue.push_back(AudioEvent::PlaySound {
-            sound_source,
-            volume,
-        })
-    }
-}
-
-/// An audio event that may be sent to the [`AudioEvents`] resource.
-#[derive(Clone, Debug)]
-pub enum AudioEvent {
-    /// Play a sound.
-    PlaySound {
-        /// The handle to the sound to play.
-        sound_source: Handle<AudioSource>,
-        /// The volume to play the sound at.
-        volume: f64,
-    },
-}
-
-fn play_sounds(
-    mut audio: ResMut<AudioManager>,
-    mut audio_events: ResMut<AudioEvents>,
-    assets: Res<AssetServer>,
-) {
-    // Play all the sounds in the queue
-    for event in audio_events.queue.drain(..) {
-        match event {
-            AudioEvent::PlaySound {
-                sound_source,
-                volume,
-            } => {
-                if let Err(e) = audio.play(
-                    assets
-                        .get(sound_source)
-                        .with_settings(StaticSoundSettings::default().volume(volume)),
-                ) {
-                    warn!("Error playing sound: {e}");
-                };
-            }
-        }
-    }
-}
diff --git a/src/core/bullet.rs b/src/core/bullet.rs
index bcbd13667a..ce364d754b 100644
--- a/src/core/bullet.rs
+++ b/src/core/bullet.rs
@@ -109,7 +109,7 @@ fn update(
     collision_world: CollisionWorld,
     mut transforms: CompMut<Transform>,
     mut bullets: CompMut<Bullet>,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
     invincibles: CompMut<Invincibility>,
     mut emote_regions: CompMut<EmoteRegion>,
     asset_server: Res<AssetServer>,
@@ -163,7 +163,7 @@ fn update(
 
         // Bullet hit something
         if hit_player || hit_solid {
-            audio_events.play(*explosion_sound, *explosion_volume);
+            audio_center.play_sound(*explosion_sound, *explosion_volume);
 
             let mut explosion_transform = *transforms.get(entity).unwrap();
             explosion_transform.translation.z += 1.0;
diff --git a/src/core/elements/crate_item.rs b/src/core/elements/crate_item.rs
index 3153f0e459..a7beabf1fa 100644
--- a/src/core/elements/crate_item.rs
+++ b/src/core/elements/crate_item.rs
@@ -191,7 +191,7 @@ fn update_thrown_crates(
     players: Comp<PlayerIdx>,
     collision_world: CollisionWorld,
     mut bodies: CompMut<KinematicBody>,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
     transforms: Comp<Transform>,
     spawners: Comp<DehydrateOutOfBounds>,
     invincibles: CompMut<Invincibility>,
@@ -245,7 +245,7 @@ fn update_thrown_crates(
         if colliding_with_tile && !thrown_crate.was_colliding {
             thrown_crate.was_colliding = true;
             thrown_crate.crate_break_state += 1;
-            audio_events.play(*bounce_sound, *bounce_sound_volume);
+            audio_center.play_sound(*bounce_sound, *bounce_sound_volume);
         } else if !colliding_with_tile {
             thrown_crate.was_colliding = false;
         }
@@ -297,7 +297,7 @@ fn update_thrown_crates(
             let breaking_anim_fps = *breaking_anim_fps;
             let atlas = *breaking_atlas;
 
-            audio_events.play(*break_sound, *break_sound_volume);
+            audio_center.play_sound(*break_sound, *break_sound_volume);
 
             commands.add(
                 move |mut entities: ResMutInit<Entities>,
diff --git a/src/core/elements/flappy_jellyfish.rs b/src/core/elements/flappy_jellyfish.rs
index b7986c8e94..65703fa7f1 100644
--- a/src/core/elements/flappy_jellyfish.rs
+++ b/src/core/elements/flappy_jellyfish.rs
@@ -225,7 +225,7 @@ fn explode_flappy_jellyfish(
     element_handles: Comp<ElementHandle>,
     assets: Res<AssetServer>,
     mut transforms: CompMut<Transform>,
-    mut audio_events: ResMut<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
     mut trauma_events: ResMut<CameraTraumaEvents>,
     mut sprites: CompMut<AtlasSprite>,
     mut animated_sprites: CompMut<AnimatedSprite>,
@@ -301,7 +301,7 @@ fn explode_flappy_jellyfish(
 
         entities.kill(flappy_ent);
 
-        audio_events.play(flappy_meta.explosion_sound, flappy_meta.explosion_volume);
+        audio_center.play_sound(flappy_meta.explosion_sound, flappy_meta.explosion_volume);
 
         trauma_events.send(5.0);
 
diff --git a/src/core/elements/grenade.rs b/src/core/elements/grenade.rs
index 93274c5c9b..2f03101a3c 100644
--- a/src/core/elements/grenade.rs
+++ b/src/core/elements/grenade.rs
@@ -142,7 +142,7 @@ fn update_idle_grenades(
     items_used: Comp<ItemUsed>,
     element_handles: Comp<ElementHandle>,
     assets: Res<AssetServer>,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
     mut idle_grenades: CompMut<IdleGrenade>,
     mut animated_sprites: CompMut<AnimatedSprite>,
 ) {
@@ -171,7 +171,7 @@ fn update_idle_grenades(
             animated_sprite.fps = 8.0;
 
             // Play that hissss sound
-            audio_events.play(*fuse_sound, *fuse_sound_volume);
+            audio_center.play_sound(*fuse_sound, *fuse_sound_volume);
 
             commands.add(
                 move |mut lit: CompMut<LitGrenade>,
@@ -204,7 +204,7 @@ fn update_lit_grenades(
     transforms: CompMut<Transform>,
     element_handles: Comp<ElementHandle>,
     spawners: Comp<DehydrateOutOfBounds>,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
     mut lit_grenades: CompMut<LitGrenade>,
     player_inventories: PlayerInventories,
     assets: Res<AssetServer>,
@@ -266,7 +266,7 @@ fn update_lit_grenades(
 
         // If it's time to explode
         if grenade.fuse_time.finished() {
-            audio_events.play(*explosion_sound, *explosion_volume);
+            audio_center.play_sound(*explosion_sound, *explosion_volume);
 
             trauma_events.send(5.0);
 
diff --git a/src/core/elements/kick_bomb.rs b/src/core/elements/kick_bomb.rs
index 762b135417..9dd2090f88 100644
--- a/src/core/elements/kick_bomb.rs
+++ b/src/core/elements/kick_bomb.rs
@@ -140,7 +140,7 @@ fn update_idle_kick_bombs(
     entities: Res<Entities>,
     mut commands: Commands,
     mut items_used: CompMut<ItemUsed>,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
     element_handles: Comp<ElementHandle>,
     mut idle_bombs: CompMut<IdleKickBomb>,
     assets: Res<AssetServer>,
@@ -167,7 +167,7 @@ fn update_idle_kick_bombs(
         let fuse_time = *fuse_time;
 
         if items_used.remove(entity).is_some() {
-            audio_events.play(*fuse_sound, *fuse_sound_volume);
+            audio_center.play_sound(*fuse_sound, *fuse_sound_volume);
             let animated_sprite = animated_sprites.get_mut(entity).unwrap();
             animated_sprite.frames = [3, 4, 5].into_iter().collect();
             animated_sprite.repeat = true;
@@ -197,7 +197,7 @@ fn update_lit_kick_bombs(
 
     collision_world: CollisionWorld,
     player_indexes: Comp<PlayerIdx>,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
     mut trauma_events: ResMutInit<CameraTraumaEvents>,
     mut lit_grenades: CompMut<LitKickBomb>,
     mut sprites: CompMut<AtlasSprite>,
@@ -293,7 +293,7 @@ fn update_lit_kick_bombs(
 
         // If it's time to explode
         if should_explode {
-            audio_events.play(*explosion_sound, *explosion_volume);
+            audio_center.play_sound(*explosion_sound, *explosion_volume);
 
             trauma_events.send(7.5);
 
diff --git a/src/core/elements/mine.rs b/src/core/elements/mine.rs
index de7a6a0072..3d7df802a9 100644
--- a/src/core/elements/mine.rs
+++ b/src/core/elements/mine.rs
@@ -173,7 +173,7 @@ fn update_thrown_mines(
     entities: Res<Entities>,
     element_handles: Comp<ElementHandle>,
     assets: Res<AssetServer>,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
     mut trauma_events: ResMutInit<CameraTraumaEvents>,
     mut thrown_mines: CompMut<ThrownMine>,
     mut animated_sprites: CompMut<AnimatedSprite>,
@@ -221,7 +221,7 @@ fn update_thrown_mines(
         thrown_mine.arm_delay.tick(time.delta());
 
         if thrown_mine.arm_delay.just_finished() {
-            audio_events.play(*arm_sound, *arm_sound_volume);
+            audio_center.play_sound(*arm_sound, *arm_sound_volume);
 
             sprite.frames = (0..*armed_frames).collect();
             sprite.fps = *armed_fps;
@@ -247,7 +247,7 @@ fn update_thrown_mines(
                 ));
             }
 
-            audio_events.play(*explosion_sound, *explosion_volume);
+            audio_center.play_sound(*explosion_sound, *explosion_volume);
 
             hydrated.remove(**spawner);
 
diff --git a/src/core/elements/musket.rs b/src/core/elements/musket.rs
index a2820819b2..00fcbc134f 100644
--- a/src/core/elements/musket.rs
+++ b/src/core/elements/musket.rs
@@ -145,7 +145,7 @@ fn update(
     mut muskets: CompMut<Musket>,
     transforms: CompMut<Transform>,
     mut sprites: CompMut<AtlasSprite>,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
 
     player_inventories: PlayerInventories,
     mut items_used: CompMut<ItemUsed>,
@@ -186,14 +186,14 @@ fn update(
             if item_used && musket.cooldown.finished() {
                 // Empty
                 if musket.ammo.eq(&0) {
-                    audio_events.play(*empty_shoot_sound, *empty_shoot_sound_volume);
+                    audio_center.play_sound(*empty_shoot_sound, *empty_shoot_sound_volume);
                     continue;
                 }
 
                 // Reset fire cooldown and subtract ammo
                 musket.cooldown = Timer::new(*cooldown, TimerMode::Once);
                 musket.ammo = musket.ammo.saturating_sub(1).clamp(0, musket.ammo);
-                audio_events.play(*shoot_sound, *shoot_sound_volume);
+                audio_center.play_sound(*shoot_sound, *shoot_sound_volume);
 
                 let player_sprite = sprites.get_mut(player).unwrap();
                 let player_flip_x = player_sprite.flip_x;
diff --git a/src/core/elements/sproinger.rs b/src/core/elements/sproinger.rs
index f3227e0747..fd7c80c528 100644
--- a/src/core/elements/sproinger.rs
+++ b/src/core/elements/sproinger.rs
@@ -100,7 +100,7 @@ fn update(
     mut atlas_sprites: CompMut<AtlasSprite>,
     mut bodies: CompMut<KinematicBody>,
     collision_world: CollisionWorld,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
 ) {
     for (entity, (sproinger, sprite)) in entities.iter_with((&mut sproingers, &mut atlas_sprites)) {
         let element_handle = element_handles.get(entity).unwrap();
@@ -136,7 +136,7 @@ fn update(
         for collider_ent in collision_world.actor_collisions(entity) {
             if let Some(body) = bodies.get_mut(collider_ent) {
                 if body.velocity.y < *spring_velocity - body.gravity {
-                    audio_events.play(*sound, *sound_volume);
+                    audio_center.play_sound(*sound, *sound_volume);
                     body.velocity.y = *spring_velocity;
                     sproinger.sproinging = true;
                 }
diff --git a/src/core/elements/sword.rs b/src/core/elements/sword.rs
index 97a7587c05..b95009366b 100644
--- a/src/core/elements/sword.rs
+++ b/src/core/elements/sword.rs
@@ -139,7 +139,7 @@ fn update(
     element_handles: Comp<ElementHandle>,
     assets: Res<AssetServer>,
     collision_world: CollisionWorld,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
     mut swords: CompMut<Sword>,
     mut sprites: CompMut<AtlasSprite>,
     bodies: CompMut<KinematicBody>,
@@ -289,7 +289,7 @@ fn update(
             if item_used && matches!(sword.state, SwordState::Idle) {
                 sprite.index = 8;
                 sword.state = SwordState::Swinging { frame: 0 };
-                audio_events.play(*sound, *sound_volume);
+                audio_center.play_sound(*sound, *sound_volume);
             }
         } else {
             let body = bodies.get(entity).unwrap();
diff --git a/src/core/player/state.rs b/src/core/player/state.rs
index 179f16d6c3..91fc8a985c 100644
--- a/src/core/player/state.rs
+++ b/src/core/player/state.rs
@@ -71,7 +71,7 @@ fn use_drop_or_grab_items_system(id: Ustr) -> StaticSystem<(), ()> {
            items: Comp<Item>,
            collision_world: CollisionWorld,
            mut inventories: CompMut<Inventory>,
-           mut audio_events: ResMutInit<AudioEvents>,
+           mut audio_center: ResMut<AudioCenter>,
            mut commands: Commands| {
         // Collect a list of items that are being held by players
         let held_items = entities
@@ -110,7 +110,7 @@ fn use_drop_or_grab_items_system(id: Ustr) -> StaticSystem<(), ()> {
                         commands.add(PlayerCommand::set_inventory(player_ent, Some(*item)));
 
                         // Play grab sound
-                        audio_events.play(meta.sounds.grab, meta.sounds.grab_volume);
+                        audio_center.play_sound(meta.sounds.grab, meta.sounds.grab_volume);
                     }
 
                 // If we are already carrying an item
@@ -119,7 +119,7 @@ fn use_drop_or_grab_items_system(id: Ustr) -> StaticSystem<(), ()> {
                     commands.add(PlayerCommand::set_inventory(player_ent, None));
 
                     // Play drop sound
-                    audio_events.play(meta.sounds.drop, meta.sounds.drop_volume);
+                    audio_center.play_sound(meta.sounds.drop, meta.sounds.drop_volume);
                 }
             }
 
diff --git a/src/core/player/state/states/idle.rs b/src/core/player/state/states/idle.rs
index d2f2713d5a..eaeca821ee 100644
--- a/src/core/player/state/states/idle.rs
+++ b/src/core/player/state/states/idle.rs
@@ -42,7 +42,7 @@ pub fn handle_player_state(
     assets: Res<AssetServer>,
     mut sprites: CompMut<AnimationBankSprite>,
     mut bodies: CompMut<KinematicBody>,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
     collision_world: CollisionWorld,
     slippery: CompMut<Slippery>,
 ) {
@@ -65,7 +65,7 @@ pub fn handle_player_state(
         // If we are jumping
         if control.jump_just_pressed {
             // Play jump sound
-            audio_events.play(meta.sounds.jump, meta.sounds.jump_volume);
+            audio_center.play_sound(meta.sounds.jump, meta.sounds.jump_volume);
 
             // Move up
             body.velocity.y = meta.stats.jump_speed;
diff --git a/src/core/player/state/states/midair.rs b/src/core/player/state/states/midair.rs
index d7d5e2fde4..14c0bb555b 100644
--- a/src/core/player/state/states/midair.rs
+++ b/src/core/player/state/states/midair.rs
@@ -15,7 +15,7 @@ pub fn player_state_transition(
     assets: Res<AssetServer>,
     mut player_states: CompMut<PlayerState>,
     bodies: Comp<KinematicBody>,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
 ) {
     for (_ent, (player_idx, player_state, body)) in
         entities.iter_with((&player_indexes, &mut player_states, &bodies))
@@ -28,7 +28,7 @@ pub fn player_state_transition(
 
         if body.is_on_ground {
             // Play land sound
-            audio_events.play(meta.sounds.land, meta.sounds.land_volume);
+            audio_center.play_sound(meta.sounds.land, meta.sounds.land_volume);
             // Switch to idle state
             player_state.current = *idle::ID;
         }
diff --git a/src/core/player/state/states/walk.rs b/src/core/player/state/states/walk.rs
index 3f9be72f94..45be01ceb3 100644
--- a/src/core/player/state/states/walk.rs
+++ b/src/core/player/state/states/walk.rs
@@ -43,7 +43,7 @@ pub fn handle_player_state(
     mut sprites: CompMut<AtlasSprite>,
     mut animations: CompMut<AnimationBankSprite>,
     mut bodies: CompMut<KinematicBody>,
-    mut audio_events: ResMutInit<AudioEvents>,
+    mut audio_center: ResMut<AudioCenter>,
 ) {
     let players = entities.iter_with((
         &player_states,
@@ -68,7 +68,7 @@ pub fn handle_player_state(
 
         // If we are jumping
         if control.jump_just_pressed {
-            audio_events.play(meta.sounds.jump, meta.sounds.jump_volume);
+            audio_center.play_sound(meta.sounds.jump, meta.sounds.jump_volume);
 
             // Move up
             body.velocity.y = meta.stats.jump_speed;
diff --git a/src/main.rs b/src/main.rs
index 1dd20b5a9c..14b0d264af 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -12,18 +12,18 @@
 use bones_bevy_renderer::BonesBevyRenderer;
 use bones_framework::prelude::*;
 
+pub mod audio;
 pub mod core;
 pub mod debug;
 pub mod fullscreen;
 pub mod input;
-pub mod music;
 pub mod sessions;
 pub mod settings;
 pub mod ui;
 
 mod prelude {
     pub use crate::{
-        core::prelude::*, impl_system_param, input::*, sessions::*, settings::*, GameMeta,
+        audio::*, core::prelude::*, impl_system_param, input::*, sessions::*, settings::*, GameMeta,
     };
     pub use bones_framework::prelude::*;
     pub use once_cell::sync::Lazy;
@@ -120,7 +120,7 @@ fn main() {
     game
         // Install game plugins
         .install_plugin(DefaultGamePlugin)
-        .install_plugin(music::game_plugin)
+        .install_plugin(audio::game_plugin)
         .install_plugin(settings::game_plugin)
         .install_plugin(fullscreen::game_plugin)
         .install_plugin(input::game_plugin)
diff --git a/src/music.rs b/src/music.rs
deleted file mode 100644
index 969f6e3918..0000000000
--- a/src/music.rs
+++ /dev/null
@@ -1,170 +0,0 @@
-use bones_framework::prelude::kira::{
-    sound::{
-        static_sound::{StaticSoundHandle, StaticSoundSettings},
-        PlaybackState, Region,
-    },
-    tween::Tween,
-};
-
-use crate::{prelude::*, ui::main_menu::MenuPage};
-
-pub fn game_plugin(game: &mut Game) {
-    let session = game.sessions.create(SessionNames::MUSIC_PLAYER);
-
-    // Music player doesn't do any rendering
-    session.visible = false;
-    session.stages.add_system_to_stage(First, music_system);
-}
-
-/// The music playback state.
-#[derive(HasSchema, Default)]
-#[schema(no_clone)]
-pub enum MusicState {
-    /// Music is not playing.
-    #[default]
-    None,
-    /// Playing the main menu music.
-    MainMenu(StaticSoundHandle),
-    /// Playing the character select music.
-    CharacterSelect(StaticSoundHandle),
-    /// Playing the credits music.
-    Credits(StaticSoundHandle),
-    /// Playing the fight music.
-    Fight {
-        /// The handle to the audio instance.
-        instance: StaticSoundHandle,
-        /// The index of the song in the shuffled playlist.
-        idx: usize,
-    },
-}
-
-impl MusicState {
-    /// Get the current audio instance, if one is contained.
-    fn current_instance(&mut self) -> Option<&mut StaticSoundHandle> {
-        match self {
-            MusicState::None => None,
-            MusicState::MainMenu(i) => Some(i),
-            MusicState::CharacterSelect(i) => Some(i),
-            MusicState::Credits(i) => Some(i),
-            MusicState::Fight { instance, .. } => Some(instance),
-        }
-    }
-}
-
-/// Bevy resource containing the in-game music playlist shuffled.
-#[derive(HasSchema, Deref, DerefMut, Clone, Default)]
-#[repr(C)]
-pub struct ShuffledPlaylist(pub SVec<Handle<AudioSource>>);
-
-/// The amount of time to spend fading the music in and out.
-const MUSIC_FADE_DURATION: Duration = Duration::from_millis(500);
-
-const MUSIC_VOLUME: f64 = 0.1;
-
-/// System that plays music according to the game mode.
-fn music_system(
-    meta: Root<GameMeta>,
-    mut audio: ResMut<AudioManager>,
-    mut shuffled_fight_music: ResMutInit<ShuffledPlaylist>,
-    mut music_state: ResMutInit<MusicState>,
-    ctx: Res<EguiCtx>,
-    sessions: Res<Sessions>,
-    assets: Res<AssetServer>,
-) {
-    if shuffled_fight_music.is_empty() {
-        let mut songs = meta.music.fight.clone();
-        THREAD_RNG.with(|rng| rng.shuffle(&mut songs));
-        **shuffled_fight_music = songs;
-    }
-
-    let tween = Tween {
-        start_time: kira::StartTime::Immediate,
-        duration: MUSIC_FADE_DURATION,
-        easing: kira::tween::Easing::Linear,
-    };
-    let play_settings = StaticSoundSettings::default()
-        .volume(MUSIC_VOLUME)
-        .fade_in_tween(tween);
-
-    // If we are in a game
-    if sessions.get(SessionNames::GAME).is_some() {
-        if let MusicState::Fight { instance, idx } = &mut *music_state {
-            if let PlaybackState::Stopped = instance.state() {
-                *idx += 1;
-                *idx %= shuffled_fight_music.len();
-
-                *instance = audio
-                    .play(
-                        assets
-                            .get(shuffled_fight_music[*idx])
-                            .0
-                            .with_settings(play_settings),
-                    )
-                    .unwrap();
-            }
-        } else {
-            if let Some(instance) = music_state.current_instance() {
-                instance.stop(tween).unwrap();
-            }
-
-            if let Some(song) = shuffled_fight_music.get(0) {
-                *music_state = MusicState::Fight {
-                    instance: audio
-                        .play(assets.get(*song).with_settings(play_settings))
-                        .unwrap(),
-                    idx: 0,
-                };
-            }
-        }
-
-    // If we are on a menu page
-    } else if sessions.get(SessionNames::MAIN_MENU).is_some() {
-        let menu_page = ctx.get_state::<MenuPage>();
-        match menu_page {
-            MenuPage::PlayerSelect | MenuPage::MapSelect { .. } | MenuPage::NetworkGame => {
-                if !matches!(*music_state, MusicState::CharacterSelect(..)) {
-                    if let Some(instance) = music_state.current_instance() {
-                        instance.stop(tween).unwrap();
-                    }
-                    *music_state = MusicState::CharacterSelect(
-                        audio
-                            .play(
-                                assets
-                                    .get(meta.music.character_screen)
-                                    .with_settings(play_settings.loop_region(Region::default())),
-                            )
-                            .unwrap(),
-                    );
-                }
-            }
-            MenuPage::Home | MenuPage::Settings => {
-                if !matches!(*music_state, MusicState::MainMenu(..)) {
-                    if let Some(instance) = music_state.current_instance() {
-                        instance.stop(tween).unwrap();
-                    }
-                    *music_state = MusicState::MainMenu(
-                        audio
-                            .play(
-                                assets
-                                    .get(meta.music.title_screen)
-                                    .with_settings(play_settings),
-                            )
-                            .unwrap(),
-                    );
-                }
-            }
-            MenuPage::Credits => {
-                if !matches!(*music_state, MusicState::Credits(..)) {
-                    if let Some(instance) = music_state.current_instance() {
-                        instance.stop(tween).unwrap();
-                    }
-                    *music_state = MusicState::Credits(
-                        audio
-                            .play(assets.get(meta.music.credits).with_settings(play_settings))
-                            .unwrap(),
-                    );
-                }
-            }
-        }
-    }
-}
diff --git a/src/sessions.rs b/src/sessions.rs
index e39a7a81af..6c375fb129 100644
--- a/src/sessions.rs
+++ b/src/sessions.rs
@@ -2,11 +2,11 @@ use crate::{core::JumpyDefaultMatchRunner, prelude::*};
 
 pub struct SessionNames;
 impl SessionNames {
-    pub const GAME: &'static str = "game";
+    pub const AUDIO: &'static str = "audio";
     pub const DEBUG: &'static str = "debug";
+    pub const GAME: &'static str = "game";
     pub const MAIN_MENU: &'static str = "main_menu";
     pub const PAUSE_MENU: &'static str = "pause_menu";
-    pub const MUSIC_PLAYER: &'static str = "music_player";
 }
 
 pub trait SessionExt {
diff --git a/src/settings.rs b/src/settings.rs
index b2f8a1e425..d160d66755 100644
--- a/src/settings.rs
+++ b/src/settings.rs
@@ -24,6 +24,13 @@ fn load_settings(game: &mut Game) {
 #[derive(HasSchema, Debug, Clone)]
 #[repr(C)]
 pub struct Settings {
+    /// The main scaling factor for all game audios. This is done on top of the
+    /// scaling factor specific to the audio type.
+    pub main_volume: f64,
+    /// The scaling factor for music.
+    pub music_volume: f64,
+    /// The scaling factor for sound effects.
+    pub effects_volume: f64,
     /// Whether to display the game fullscreen.
     pub fullscreen: bool,
     /// The player controller bindings
@@ -35,6 +42,9 @@ pub struct Settings {
 impl Default for Settings {
     fn default() -> Self {
         Self {
+            main_volume: 1.0,
+            music_volume: 1.0,
+            effects_volume: 1.0,
             fullscreen: true,
             player_controls: default(),
             matchmaking_server: default(),
diff --git a/src/ui/main_menu/settings.rs b/src/ui/main_menu/settings.rs
index 4fe4c5cc94..abdb1295c5 100644
--- a/src/ui/main_menu/settings.rs
+++ b/src/ui/main_menu/settings.rs
@@ -5,6 +5,7 @@ use crate::{
 
 use super::MenuPage;
 
+mod audio;
 mod controls;
 mod graphics;
 mod networking;
@@ -23,6 +24,7 @@ enum SettingsTab {
     #[default]
     Controls,
     Networking,
+    Audio,
     Graphics,
 }
 
@@ -30,6 +32,7 @@ impl SettingsTab {
     const TABS: &'static [(Self, &'static str)] = &[
         (Self::Controls, "controls"),
         (Self::Networking, "networking"),
+        (Self::Audio, "audio"),
         (Self::Graphics, "graphics"),
     ];
 }
@@ -109,7 +112,7 @@ pub fn widget(
 
                 // Add buttons to the bottom
                 ui.with_layout(egui::Layout::bottom_up(egui::Align::Center), |ui| {
-                    ui.horizontal(|ui| {
+                    let buttons_response = ui.horizontal(|ui| {
                         // Calculate button size and spacing
                         let width = ui.available_width();
                         let button_width = width / 4.0;
@@ -132,6 +135,10 @@ pub fn widget(
                             ui.ctx().set_state(MenuPage::Home);
                             // Reset the modified settings to their stored settings.
                             state.modified_settings = storage.get::<Settings>().unwrap().clone();
+                            // Run cancel callbacks
+                            if state.tab == SettingsTab::Audio {
+                                world.run_system(audio::on_cancel, &state);
+                            }
                         }
 
                         ui.add_space(button_spacing);
@@ -167,6 +174,9 @@ pub fn widget(
                         }
                     });
 
+                    let buttons_rect = buttons_response.response.rect;
+                    ui.add_space(buttons_rect.height() / 2.0);
+
                     ui.vertical(|ui| match state.tab {
                         SettingsTab::Controls => {
                             world.run_system(controls::widget, (ui, &mut state, should_reset))
@@ -174,6 +184,9 @@ pub fn widget(
                         SettingsTab::Networking => {
                             world.run_system(networking::widget, (ui, &mut state, should_reset))
                         }
+                        SettingsTab::Audio => {
+                            world.run_system(audio::widget, (ui, &mut state, should_reset))
+                        }
                         SettingsTab::Graphics => {
                             world.run_system(graphics::widget, (ui, &mut state, should_reset))
                         }
diff --git a/src/ui/main_menu/settings/audio.rs b/src/ui/main_menu/settings/audio.rs
new file mode 100644
index 0000000000..59b1304f73
--- /dev/null
+++ b/src/ui/main_menu/settings/audio.rs
@@ -0,0 +1,108 @@
+use bones_framework::render::ui::egui;
+
+use super::*;
+
+trait SettingsExts {
+    fn volume_change_event(&self) -> AudioEvent;
+}
+
+impl SettingsExts for Settings {
+    fn volume_change_event(&self) -> AudioEvent {
+        AudioEvent::VolumeChange {
+            main_volume: self.main_volume,
+            music_volume: self.music_volume,
+            effects_volume: self.effects_volume,
+        }
+    }
+}
+
+pub(super) fn on_cancel(In(state): In<&SettingsState>, mut audio_center: ResMut<AudioCenter>) {
+    audio_center.event(state.modified_settings.volume_change_event());
+}
+
+pub(super) fn widget(
+    In((ui, state, should_reset)): In<(&mut egui::Ui, &mut SettingsState, bool)>,
+    meta: Root<GameMeta>,
+    localization: Localization<GameMeta>,
+    mut audio_center: ResMut<AudioCenter>,
+) {
+    let bigger_font = meta
+        .theme
+        .font_styles
+        .bigger
+        .with_color(meta.theme.panel.font_color);
+    let normal_font = meta
+        .theme
+        .font_styles
+        .normal
+        .with_color(meta.theme.panel.font_color);
+
+    if should_reset {
+        state.modified_settings.main_volume = meta.default_settings.main_volume;
+        audio_center.event(state.modified_settings.volume_change_event());
+    }
+
+    ui.add_space(normal_font.size);
+
+    ui.scope(|ui| {
+        let style = ui.style_mut();
+        style.drag_value_text_style = egui::TextStyle::Monospace;
+        style.spacing.indent = normal_font.size / 2.5;
+        style.spacing.button_padding = egui::vec2(6.0, 3.0);
+        style.spacing.slider_width = 200.0;
+        style.visuals.indent_has_left_vline = false;
+
+        ui.indent("audio-controls", |ui| {
+            ui.label(bigger_font.rich(localization.get("volume")));
+            ui.add_space(normal_font.size / 2.0);
+
+            egui::Grid::new("volume-grid").show(ui, |ui| {
+                // Main
+                let main_changed = volume_control_widget(
+                    ui,
+                    normal_font.rich(localization.get("volume-main")),
+                    &mut state.modified_settings.main_volume,
+                )
+                .changed();
+                ui.end_row();
+
+                // Music
+                let music_changed = volume_control_widget(
+                    ui,
+                    normal_font.rich(localization.get("volume-music")),
+                    &mut state.modified_settings.music_volume,
+                )
+                .changed();
+                ui.end_row();
+
+                // Effects
+                let effects_changed = volume_control_widget(
+                    ui,
+                    normal_font.rich(localization.get("volume-effects")),
+                    &mut state.modified_settings.effects_volume,
+                )
+                .changed();
+                ui.end_row();
+
+                if main_changed || music_changed || effects_changed {
+                    audio_center.event(state.modified_settings.volume_change_event());
+                }
+            });
+        });
+    });
+}
+
+fn volume_control_widget(
+    ui: &mut egui::Ui,
+    label: impl Into<egui::WidgetText>,
+    value: &mut f64,
+) -> egui::Response {
+    ui.label(label);
+    let slider = egui::Slider::new(value, 0.0..=1.0)
+        .smallest_positive(0.0)
+        .step_by(0.01)
+        .fixed_decimals(3)
+        .custom_formatter(|x, _| format!("{:5.1}", x * 100.0))
+        .custom_parser(|s| s.parse::<f64>().ok().map(|f| f / 100.0));
+    ui.add(slider)
+}
diff --git a/src/ui/main_menu/settings/controls.rs b/src/ui/main_menu/settings/controls.rs
index 9ea6cb3c97..b16aab4493 100644
--- a/src/ui/main_menu/settings/controls.rs
+++ b/src/ui/main_menu/settings/controls.rs
@@ -187,6 +187,8 @@ pub(super) fn widget(
 
                         // Render the button
                         row.col(|ui| {
+                            ui.set_width(ui.available_width() * 0.92);
+
                             let button = BorderedButton::themed(
                                 &meta.theme.buttons.small,
                                 input.to_string(),