diff --git a/vita3k/codec/include/codec/state.h b/vita3k/codec/include/codec/state.h
index 57333a0740..ade108dcc9 100644
--- a/vita3k/codec/include/codec/state.h
+++ b/vita3k/codec/include/codec/state.h
@@ -164,7 +164,7 @@ struct Atrac9DecoderState : public DecoderState {
     uint32_t get(DecoderQuery query) override;
     uint32_t get_es_size() override;
 
-    bool send(const uint8_t *data, uint32_t size) override;
+    bool send(const uint8_t *data, uint32_t size = 0) override;
     bool receive(uint8_t *data, DecoderSize *size) override;
     void flush() override;
 
diff --git a/vita3k/config/include/config/config.h b/vita3k/config/include/config/config.h
index 4b74d07c78..f99a59a794 100644
--- a/vita3k/config/include/config/config.h
+++ b/vita3k/config/include/config/config.h
@@ -89,6 +89,7 @@ enum ScreenshotFormat {
     code(std::string, "audio-backend", "SDL", audio_backend)                                            \
     code(int, "audio-volume", 100, audio_volume)                                                        \
     code(bool, "ngs-enable", true, ngs_enable)                                                          \
+    code(int,  "bgm-volume", 100, bgm_volume) 													        \
     code(int, "sys-button", static_cast<int>(SCE_SYSTEM_PARAM_ENTER_BUTTON_CROSS), sys_button)          \
     code(int, "sys-lang", static_cast<int>(SCE_SYSTEM_PARAM_LANG_ENGLISH_US), sys_lang)                 \
     code(int, "sys-date-format", (int)SCE_SYSTEM_PARAM_DATE_FORMAT_MMDDYYYY, sys_date_format)           \
diff --git a/vita3k/gui/CMakeLists.txt b/vita3k/gui/CMakeLists.txt
index f9553f1b1c..5d30793a39 100644
--- a/vita3k/gui/CMakeLists.txt
+++ b/vita3k/gui/CMakeLists.txt
@@ -50,6 +50,6 @@ add_library(
 )
 
 target_include_directories(gui PUBLIC include ${CMAKE_SOURCE_DIR}/vita3k)
-target_link_libraries(gui PUBLIC app compat config dialog emuenv ime imgui lang regmgr np)
-target_link_libraries(gui PRIVATE audio cppcommon ctrl kernel miniz psvpfsparser pugixml::pugixml stb renderer packages sdl2 touch vkutil host::dialog concurrentqueue)
+target_link_libraries(gui PUBLIC app codec compat config dialog emuenv ime imgui lang regmgr np)
+target_link_libraries(gui PRIVATE audio cubeb cppcommon ctrl kernel miniz psvpfsparser pugixml::pugixml stb renderer packages sdl2 touch vkutil host::dialog concurrentqueue)
 target_link_libraries(gui PUBLIC tracy)
diff --git a/vita3k/gui/include/gui/functions.h b/vita3k/gui/include/gui/functions.h
index 0cb5576e80..8be06488c4 100644
--- a/vita3k/gui/include/gui/functions.h
+++ b/vita3k/gui/include/gui/functions.h
@@ -69,6 +69,7 @@ void init(GuiState &gui, EmuEnvState &emuenv);
 void init_app_background(GuiState &gui, EmuEnvState &emuenv, const std::string &app_path);
 void init_app_icon(GuiState &gui, EmuEnvState &emuenv, const std::string &app_path);
 void init_apps_icon(GuiState &gui, EmuEnvState &emuenv, const std::vector<gui::App> &app_list);
+void init_bgm(EmuEnvState &emuenv, const std::pair<std::string, std::string> path_bgm);
 void init_config(GuiState &gui, EmuEnvState &emuenv, const std::string &app_path);
 void init_content_manager(GuiState &gui, EmuEnvState &emuenv);
 vfs::FileBuffer init_default_icon(GuiState &gui, EmuEnvState &emuenv);
@@ -103,6 +104,9 @@ void save_apps_cache(GuiState &gui, EmuEnvState &emuenv);
 void save_user(GuiState &gui, EmuEnvState &emuenv, const std::string &user_id);
 void set_config(GuiState &gui, EmuEnvState &emuenv, const std::string &app_path);
 void set_shaders_compiled_display(GuiState &gui, EmuEnvState &emuenv);
+void set_volume_bgm(const float vol);
+void stop_bgm();
+void switch_state_bgm(const bool pause);
 void update_app(GuiState &gui, EmuEnvState &emuenv, const std::string &app_path);
 void update_last_time_app_used(GuiState &gui, EmuEnvState &emuenv, const std::string &app);
 void update_live_area_current_open_apps_list(GuiState &gui, EmuEnvState &emuenv, const std::string &app_path);
diff --git a/vita3k/gui/src/home_screen.cpp b/vita3k/gui/src/home_screen.cpp
index e169588ec7..5a82d50ecd 100644
--- a/vita3k/gui/src/home_screen.cpp
+++ b/vita3k/gui/src/home_screen.cpp
@@ -144,6 +144,7 @@ void pre_load_app(GuiState &gui, EmuEnvState &emuenv, bool live_area, const std:
 }
 
 void pre_run_app(GuiState &gui, EmuEnvState &emuenv, const std::string &app_path) {
+    switch_state_bgm(true);
     const auto is_sys = app_path.starts_with("NPXS") && (app_path != "NPXS10007");
     if (!is_sys) {
         if (emuenv.io.app_path != app_path) {
@@ -213,6 +214,7 @@ void close_system_app(GuiState &gui, EmuEnvState &emuenv) {
             gui.vita_area.information_bar = true;
         gui.vita_area.home_screen = true;
     }
+    switch_state_bgm(false);
 }
 
 void close_and_run_new_app(GuiState &gui, EmuEnvState &emuenv, const std::string &app_path) {
@@ -544,6 +546,7 @@ void draw_home_screen(GuiState &gui, EmuEnvState &emuenv) {
                 gui.vita_area.home_screen = false;
                 gui.vita_area.information_bar = true;
                 gui.vita_area.start_screen = true;
+                switch_state_bgm(true);
             }
         }
     }
diff --git a/vita3k/gui/src/settings.cpp b/vita3k/gui/src/settings.cpp
index 2b43be8acb..210909bb3f 100644
--- a/vita3k/gui/src/settings.cpp
+++ b/vita3k/gui/src/settings.cpp
@@ -47,12 +47,9 @@ struct Theme {
 
 static std::map<std::string, Theme> themes_info;
 static std::vector<std::pair<std::string, time_t>> themes_list;
+static time_t last_updated_themes_list = 0;
 
 static void get_themes_list(GuiState &gui, EmuEnvState &emuenv) {
-    gui.themes_preview.clear();
-    themes_info.clear();
-    themes_list.clear();
-
     const auto theme_path{ emuenv.pref_path / "ux0/theme" };
     const auto fw_theme_path{ emuenv.pref_path / "vs0/data/internal/theme" };
     if ((!fs::exists(fw_theme_path) || fs::is_empty(fw_theme_path)) && (!fs::exists(theme_path) || fs::is_empty(theme_path))) {
@@ -60,6 +57,16 @@ static void get_themes_list(GuiState &gui, EmuEnvState &emuenv) {
         return;
     }
 
+    // Check if the themes list has been updated recently to avoid unnecessary updates
+    if ((fs::last_write_time(theme_path) <= last_updated_themes_list) && (fs::last_write_time(fw_theme_path) < last_updated_themes_list))
+        return;
+    else if (last_updated_themes_list != 0)
+        LOG_INFO("Found new update of themes list, updating...");
+
+    gui.themes_preview.clear();
+    themes_info.clear();
+    themes_list.clear();
+
     std::string user_lang;
     const auto sys_lang = static_cast<SceSystemParamLang>(emuenv.cfg.sys_lang);
     switch (sys_lang) {
@@ -180,6 +187,8 @@ static void get_themes_list(GuiState &gui, EmuEnvState &emuenv) {
             }
         }
     }
+
+    last_updated_themes_list = time(0);
 }
 
 static std::string popup, menu, sub_menu, selected, title, delete_user_background, delete_theme;
@@ -467,6 +476,7 @@ void draw_settings(GuiState &gui, EmuEnvState &emuenv) {
                                 init_theme_start_background(gui, emuenv, "default");
                             }
                             fs::remove_all(emuenv.pref_path / "ux0/theme" / fs_utils::utf8_to_path(selected));
+                            last_updated_themes_list = time(0);
                             if (emuenv.app_path == "NPXS10026")
                                 init_content_manager(gui, emuenv);
                             delete_theme = selected;
diff --git a/vita3k/gui/src/settings_dialog.cpp b/vita3k/gui/src/settings_dialog.cpp
index 9c6550e3b5..16bc6e4db5 100644
--- a/vita3k/gui/src/settings_dialog.cpp
+++ b/vita3k/gui/src/settings_dialog.cpp
@@ -380,6 +380,7 @@ static void save_config(GuiState &gui, EmuEnvState &emuenv) {
         app::update_viewport(emuenv);
     }
 
+    set_volume_bgm(emuenv.cfg.bgm_volume);
     config::serialize_config(emuenv.cfg, emuenv.cfg.config_path);
 }
 
@@ -813,6 +814,8 @@ void draw_settings_dialog(GuiState &gui, EmuEnvState &emuenv) {
         ImGui::Checkbox(lang.audio["enable_ngs_support"].c_str(), &config.ngs_enable);
         SetTooltipEx(lang.audio["ngs_description"].c_str());
         ImGui::Spacing();
+        ImGui::SliderInt("Bgm Volume", &emuenv.cfg.bgm_volume, 0, 100, "%d %%", ImGuiSliderFlags_AlwaysClamp);
+        SetTooltipEx("Adjusts the background music volume percentage of the theme");
         ImGui::Separator();
         ImGui::Spacing();
         ImGui::EndTabItem();
@@ -1065,7 +1068,7 @@ void draw_settings_dialog(GuiState &gui, EmuEnvState &emuenv) {
             SetTooltipEx(lang.gui["select_delay_background"].c_str());
         }
         ImGui::Spacing();
-        ImGui::SliderInt(lang.gui["delay_start"].c_str(), &emuenv.cfg.delay_start, 10, 60);
+        ImGui::SliderInt(lang.gui["delay_start"].c_str(), &emuenv.cfg.delay_start, 30, 300);
         SetTooltipEx(lang.gui["select_delay_start"].c_str());
         ImGui::EndTabItem();
     } else
diff --git a/vita3k/gui/src/themes.cpp b/vita3k/gui/src/themes.cpp
index 34f0d05a11..5d4ed7ea99 100644
--- a/vita3k/gui/src/themes.cpp
+++ b/vita3k/gui/src/themes.cpp
@@ -17,7 +17,10 @@
 
 #include "private.h"
 
+#include <audio/state.h>
+#include <codec/state.h>
 #include <config/state.h>
+#include <cubeb/cubeb.h>
 #include <gui/functions.h>
 #include <io/VitaIoDevice.h>
 #include <io/state.h>
@@ -211,8 +214,303 @@ bool init_user_start_background(GuiState &gui, const std::string &image_path) {
     return gui.start_background;
 }
 
+// Structure to store PCM data
+struct PcmData {
+    std::vector<uint8_t> data;
+    uint32_t position;
+    std::mutex mutex;
+};
+
+static long data_callback(cubeb_stream *stream, void *user_ptr, const void *input_buffer, void *output_buffer, long nframes) {
+    PcmData *pcm = static_cast<PcmData *>(user_ptr);
+    // Lock the mutex to access pcm->position and pcm->data
+    std::lock_guard<std::mutex> lock(pcm->mutex);
+
+    // Calculate the number of bytes to copy (2 bytes per sample, 2 channels) and the length of the PCM data
+    const uint32_t bytes_to_copy = nframes * 2 * sizeof(uint16_t);
+    const uint32_t length = pcm->data.size();
+
+    // If we reach the end of the buffer, return to zero (loop)
+    if (pcm->position >= length) {
+        pcm->position = 0;
+    }
+
+    // Calculate how much data is left to copy
+    const size_t bytes_to_copy_now = std::min(bytes_to_copy, length - pcm->position);
+
+    // Copy the PCM data into the output buffer
+    std::memcpy(output_buffer, pcm->data.data() + pcm->position, bytes_to_copy_now);
+
+    // Update the position
+    pcm->position += bytes_to_copy_now;
+
+    // If we copied less data than the buffer, fill the rest with silence
+    if (bytes_to_copy_now < bytes_to_copy)
+        std::memset((uint8_t *)output_buffer + bytes_to_copy_now, 0, bytes_to_copy - bytes_to_copy_now);
+
+    // Return the number of frames copied
+    return nframes;
+}
+
+// Callback called when the stream state changes
+void state_callback(cubeb_stream *stream, void *user_ptr, cubeb_state state) {
+    switch (state) {
+    case CUBEB_STATE_DRAINED:
+        LOG_INFO("Playback drained.");
+        break;
+    case CUBEB_STATE_ERROR:
+        LOG_ERROR("Playback error.");
+        break;
+    default:
+        break;
+    }
+}
+
+std::thread playback_handle_thread;
+cubeb_stream *stream = nullptr;
+bool stop_requested;
+std::condition_variable stop_condition;
+cubeb *ctx = nullptr;
+PcmData pcm_data;
+
+void stop_bgm() {
+    if (!stream) {
+        return;
+    }
+
+    {
+        // We lock the mutex to protect access to stop_requested
+        std::lock_guard<std::mutex> lock(pcm_data.mutex);
+        stop_requested = true;
+    }
+
+    // Notify the condition to wake up the thread
+    stop_condition.notify_one();
+
+    // Wait for the playback handle thread to finish
+    if (playback_handle_thread.joinable())
+        playback_handle_thread.join();
+
+    // Stop and destroy the stream
+    cubeb_stream_stop(stream);
+    cubeb_stream_destroy(stream);
+    stream = nullptr;
+
+    // Reset the stop indicator
+    stop_requested = false;
+}
+
+void switch_state_bgm(const bool pause) {
+    if (!stream) {
+        LOG_ERROR("The background music stream is not initialized!");
+        return;
+    }
+
+    if (pause)
+        cubeb_stream_stop(stream);
+    else
+        cubeb_stream_start(stream);
+}
+
+void set_volume_bgm(const float volume) {
+    if (!stream) {
+        LOG_ERROR("The background music stream is not initialized!");
+        return;
+    }
+
+    cubeb_stream_set_volume(stream, volume / 100.f);
+}
+
+static void pcm_playback_handle_thread() {
+    std::unique_lock<std::mutex> lock(pcm_data.mutex);
+
+    // Wait until stop is requested
+    stop_condition.wait(lock, [] { return stop_requested; });
+
+    // Destroy the context
+    cubeb_destroy(ctx);
+}
+
+static void init_player_bgm(const float vol) {
+    if (cubeb_init(&ctx, "Player BGM", nullptr) != CUBEB_OK) {
+        LOG_ERROR("Failed to initialize Cubeb context");
+        return;
+    }
+
+    // Configure the audio output parameters
+    cubeb_stream_params output_params;
+    output_params.format = CUBEB_SAMPLE_S16LE; // Format PCM 16-bit, little-endian
+    output_params.rate = 48000; // Sample rate 48 kHz
+    output_params.channels = 2; // Stereo
+    output_params.layout = CUBEB_LAYOUT_STEREO;
+
+    uint32_t latency;
+    cubeb_get_min_latency(ctx, &output_params, &latency);
+
+    if (cubeb_stream_init(ctx, &stream, "Stream BGM", nullptr, nullptr,
+            nullptr, &output_params, latency, data_callback, state_callback, &pcm_data)
+        != CUBEB_OK) {
+        LOG_ERROR("Failed to initialize Cubeb stream");
+        return;
+    }
+
+    set_volume_bgm(vol);
+
+    // Start playback in a new thread
+    playback_handle_thread = std::thread(pcm_playback_handle_thread);
+}
+
+struct RiffHeader {
+    unsigned char chunk_id[4]; // Identifier for the "RIFF" chunk
+    uint32_t chunk_size; // Size of the chunk
+    unsigned char format[4]; // Format of the file
+};
+
+struct FmtChunk {
+    unsigned char chunk_id[4]; // Identifier for the "fmt" chunk
+    uint32_t chunk_data_size; // Size of the chunk
+    uint16_t format_tag; // Format of the audio data
+    uint16_t num_channels; // Number of channels
+    uint32_t sample_rate; // Sample rate
+    uint32_t byte_rate; // Byte rate
+    uint16_t block_align; // Block alignment
+    uint16_t bits_per_sample; // Bits per sample
+    uint16_t extension_size; // Size of the extension
+    uint16_t samples_per_block; // Samples per block
+    uint32_t channel_mask; // Channel mask
+    char codec_id[16]; // Codec ID
+    uint32_t version; // Version
+    uint32_t config_data; // Configuration data
+    uint32_t reserved; // Reserved
+};
+
+struct FactChunk {
+    unsigned char chunk_id[4]; // Identifier for the "fact" chunk
+    uint32_t chunk_data_size; // Size of the chunk
+    uint32_t total_samples; // Total number of samples in the file
+    uint32_t input_overlap_delay; // Input overlap delay
+    uint32_t input_overlap_encoder_delay; // Input overlap encoder delay
+};
+
+struct SmplChunk {
+    unsigned char chunk_id[4]; // Identifier for the "smpl" chunk
+    uint32_t chunk_size; // Size of the chunk
+    uint32_t manufacturer; // Manufacturer code (MMA Manufacturer code)
+    uint32_t product; // Product code
+    uint32_t sample_period; // Period of one sample in nanoseconds
+    uint32_t midi_unity_note; // MIDI note to play the sample at its original pitch
+    uint32_t midi_pitch_fraction; // Fraction of the MIDI note
+    uint32_t smpte_format; // SMPTE format for synchronization
+    uint32_t smpte_offset; // SMPTE offset
+    uint32_t num_sample_loops; // Number of sample loops
+    uint32_t sampler_data; // Size of sampler-specific data (in bytes)
+    uint32_t identifier; // Unique identifier for the loop
+    uint32_t type; // Loop type (e.g., 0 for forward)
+    uint32_t start; // Loop start point (in samples)
+    uint32_t end; // Loop end point (in samples)
+    uint32_t fraction; // Fraction of a sample length for fine-tuning
+    uint32_t play_count; // Number of times to repeat the loop (0 for infinite)
+};
+
+struct DataChunk {
+    unsigned char chunk_id[4]; // Identifier for the "data" chunk
+    uint32_t size; // Size of the audio data
+};
+
+struct At9Header {
+    RiffHeader riff;
+    FmtChunk fmt;
+    FactChunk fact;
+    SmplChunk smpl;
+    DataChunk data;
+};
+
+static void load_bgm(std::vector<uint8_t> at9_data) {
+    // Get the header of the AT9 file
+    At9Header header;
+    memcpy(&header, at9_data.data(), sizeof(At9Header));
+
+    // Set offset of data start after the header
+    const uint32_t data_start = sizeof(At9Header);
+
+    // Set data size
+    const uint32_t data_size = header.data.size;
+
+    // Set the pointer to the ES data after the header
+    uint8_t *es_data = at9_data.data() + data_start;
+
+    // Create a new decoder with the configuration data from the AT9 header
+    Atrac9DecoderState decoder(header.fmt.config_data);
+
+    const uint32_t super_frame_size = decoder.get(DecoderQuery::AT9_SUPERFRAME_SIZE);
+    const auto es_size_max = std::min(super_frame_size, 1024u);
+
+    uint32_t total_bytes_read = 0;
+
+    // Get the maximum size of the PCM buffer for a single super frame
+    const uint64_t max_pcm_size = static_cast<uint64_t>(decoder.get(DecoderQuery::AT9_SAMPLE_PER_FRAME) * decoder.get(DecoderQuery::CHANNELS)) * sizeof(int16_t);
+    std::vector<uint8_t> data_bgm{};
+
+    // Decode the AT9 data
+    while (total_bytes_read < data_size) {
+        DecoderSize size;
+        std::vector<uint8_t> pcm_buffer(max_pcm_size);
+
+        // Send the data to the decoder and receive the decoded PCM data
+        if (!decoder.send(es_data)
+            || !decoder.receive(pcm_buffer.data(), &size)) {
+            LOG_ERROR("Error at offset {} while sending or decoding AT9.", total_bytes_read);
+            return;
+        }
+
+        // Get es size used, update the total bytes read and the es data to the next super frame
+        const uint32_t es_size_used = std::min(decoder.get_es_size(), es_size_max);
+        total_bytes_read += es_size_used;
+        es_data += es_size_used;
+
+        // Get the size of the PCM data given by the decoder and insert it into the PCM  data buffer
+        const uint64_t pcm_size_given = static_cast<uint64_t>(size.samples * decoder.get(DecoderQuery::CHANNELS)) * sizeof(int16_t);
+        data_bgm.insert(data_bgm.end(), pcm_buffer.begin(), pcm_buffer.begin() + pcm_size_given);
+    }
+
+    // Check if PCM data is valid
+    if (data_bgm.empty()) {
+        LOG_ERROR("Error: PCM data is empty!");
+        return;
+    }
+
+    // Change the BGM theme with the new PCM data
+    std::lock_guard<std::mutex> lock(pcm_data.mutex);
+    pcm_data.data = data_bgm;
+}
+
+void init_bgm(EmuEnvState &emuenv, const std::pair<std::string, std::string> path_bgm) {
+    vfs::FileBuffer buffer_bgm;
+    const auto device = VitaIoDevice::_from_string(path_bgm.first.c_str());
+    const auto path = path_bgm.second;
+    if (!vfs::read_file(device, buffer_bgm, emuenv.pref_path, path)) {
+        LOG_ERROR_IF(device == VitaIoDevice::ux0, "Failed to read theme BGM file: {}:{}", path_bgm.first, path);
+        return;
+    }
+
+    {
+        // Initialize the player if it's not already initialized
+        const std::lock_guard<std::mutex> lock(pcm_data.mutex);
+        if (!stream)
+            init_player_bgm(emuenv.cfg.bgm_volume);
+    }
+
+    // Load the BGM data from the buffer
+    load_bgm(buffer_bgm);
+}
+
 bool init_theme(GuiState &gui, EmuEnvState &emuenv, const std::string &content_id) {
     std::vector<std::string> theme_bg_name;
+
+    // Set default values of bgm theme
+    std::pair<std::string, std::string> path_bgm = { "pd0", "data/systembgm/home.at9" };
+
+    // Create a map to associate specific system app title IDs with their corresponding theme icon names.
     std::map<std::string, std::string> theme_icon_name = {
         { "NPXS10003", {} },
         { "NPXS10008", {} },
@@ -220,12 +518,15 @@ bool init_theme(GuiState &gui, EmuEnvState &emuenv, const std::string &content_i
         { "NPXS10026", {} }
     };
 
+    // Clear the current theme
     gui.app_selector.sys_apps_icon.clear();
     gui.current_theme_bg = 0;
     gui.information_bar_color = {};
     gui.theme_backgrounds.clear();
     gui.theme_backgrounds_font_color.clear();
     gui.theme_information_bar_notice.clear();
+    pcm_data.data.clear();
+    pcm_data.position = 0;
 
     const auto content_id_path = fs_utils::utf8_to_path(content_id);
 
@@ -249,6 +550,10 @@ bool init_theme(GuiState &gui, EmuEnvState &emuenv, const std::string &content_i
                 if (!home_property.child("m_hostCollabo").child("m_iconFilePath").text().empty())
                     theme_icon_name["NPXS10026"] = home_property.child("m_hostCollabo").child("m_iconFilePath").text().as_string();
 
+                // Bgm theme
+                if (!home_property.child("m_bgmFilePath").text().empty())
+                    path_bgm = { "ux0", (fs::path("theme") / content_id / home_property.child("m_bgmFilePath").text().as_string()).string() };
+
                 // Home
                 for (const auto &param : home_property.child("m_bgParam")) {
                     // Theme Background
@@ -308,6 +613,7 @@ bool init_theme(GuiState &gui, EmuEnvState &emuenv, const std::string &content_i
         } else
             LOG_ERROR("theme.xml not found for Content ID: {}, in path: {}", content_id, THEME_XML_PATH);
     } else {
+        // Default theme background
         constexpr std::array<const char *, 5> app_id_bg_list = {
             "NPXS10002",
             "NPXS10006",
@@ -321,6 +627,9 @@ bool init_theme(GuiState &gui, EmuEnvState &emuenv, const std::string &content_i
         }
     }
 
+    // Initialize the theme BGM with the path
+    init_bgm(emuenv, path_bgm);
+
     for (const auto &icon : theme_icon_name) {
         int32_t width = 0;
         int32_t height = 0;
@@ -504,6 +813,7 @@ void draw_start_screen(GuiState &gui, EmuEnvState &emuenv) {
 
     if ((ImGui::IsWindowHovered(ImGuiFocusedFlags_RootWindow) && ImGui::IsMouseClicked(0))) {
         gui.vita_area.start_screen = false;
+        switch_state_bgm(false);
         gui.vita_area.home_screen = true;
         if (emuenv.cfg.show_info_bar)
             gui.vita_area.information_bar = true;
diff --git a/vita3k/interface.cpp b/vita3k/interface.cpp
index 6cb83c9ee5..3cc5919703 100644
--- a/vita3k/interface.cpp
+++ b/vita3k/interface.cpp
@@ -639,6 +639,7 @@ bool handle_events(EmuEnvState &emuenv, GuiState &gui) {
                 }
 
                 app::switch_state(emuenv, !emuenv.kernel.is_threads_paused());
+                gui::switch_state_bgm(!emuenv.kernel.is_threads_paused());
 
             } else if (!gui::get_sys_apps_state(gui))
                 gui::close_system_app(gui, emuenv);
@@ -652,6 +653,7 @@ bool handle_events(EmuEnvState &emuenv, GuiState &gui) {
         ImGui_ImplSdl_ProcessEvent(gui.imgui_state.get(), &event);
         switch (event.type) {
         case SDL_QUIT:
+            gui::stop_bgm();
             if (!emuenv.io.app_path.empty())
                 gui::update_time_app_used(gui, emuenv, emuenv.io.app_path);
             emuenv.kernel.exit_delete_all_threads();
diff --git a/vita3k/main.cpp b/vita3k/main.cpp
index 98bd93ab1a..a73ba6581b 100644
--- a/vita3k/main.cpp
+++ b/vita3k/main.cpp
@@ -215,6 +215,8 @@ int main(int argc, char *argv[]) {
     if (!cfg.console) {
         gui::pre_init(gui, emuenv);
         if (!emuenv.cfg.initial_setup) {
+            gui::init_bgm(emuenv, { "pd0", "data/systembgm/initialsetup.at9" });
+            gui::switch_state_bgm(false);
             while (!emuenv.cfg.initial_setup) {
                 if (handle_events(emuenv, gui)) {
                     gui::draw_begin(gui, emuenv);
@@ -354,6 +356,7 @@ int main(int argc, char *argv[]) {
         gui.imgui_state->do_clear_screen = false;
     }
 
+    gui::switch_state_bgm(true);
     gui::init_app_background(gui, emuenv, emuenv.io.app_path);
     gui::update_last_time_app_used(gui, emuenv, emuenv.io.app_path);