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..e094c9965e 100644
--- a/vita3k/gui/include/gui/functions.h
+++ b/vita3k/gui/include/gui/functions.h
@@ -69,6 +69,8 @@ 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_player_bgm(const float vol);
+void init_theme_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 +105,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_bgm_volume(const float volume);
+void stop_bgm_theme();
+void switch_bgm_state(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/gui.cpp b/vita3k/gui/src/gui.cpp
index 0045137355..f9c30d7558 100644
--- a/vita3k/gui/src/gui.cpp
+++ b/vita3k/gui/src/gui.cpp
@@ -712,6 +712,9 @@ void pre_init(GuiState &gui, EmuEnvState &emuenv) {
     init_font(gui, emuenv);
     lang::init_lang(gui.lang, emuenv);
 
+    get_users_list(gui, emuenv);
+    init_player_bgm(emuenv.cfg.bgm_volume / 100.f);
+
     bool result = ImGui_ImplSdl_CreateDeviceObjects(gui.imgui_state.get());
     assert(result);
 }
@@ -719,7 +722,6 @@ void pre_init(GuiState &gui, EmuEnvState &emuenv) {
 void init(GuiState &gui, EmuEnvState &emuenv) {
     get_modules_list(gui, emuenv);
     get_notice_list(emuenv);
-    get_users_list(gui, emuenv);
     get_time_apps(gui, emuenv);
 
     if (emuenv.cfg.show_welcome)
diff --git a/vita3k/gui/src/home_screen.cpp b/vita3k/gui/src/home_screen.cpp
index e169588ec7..0bbef43561 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_bgm_state(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_bgm_state(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_bgm_state(true);
             }
         }
     }
diff --git a/vita3k/gui/src/settings.cpp b/vita3k/gui/src/settings.cpp
index 2b43be8acb..3e5d59d1ba 100644
--- a/vita3k/gui/src/settings.cpp
+++ b/vita3k/gui/src/settings.cpp
@@ -47,12 +47,8 @@ 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_update_themes = 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 +56,17 @@ static void get_themes_list(GuiState &gui, EmuEnvState &emuenv) {
         return;
     }
 
+    // Check if the theme has been updated recently to avoid unnecessary updates
+    if ((fs::last_write_time(theme_path) < last_update_themes) && (fs::last_write_time(fw_theme_path) < last_update_themes))
+        return;
+    else if (last_update_themes != 0)
+        LOG_INFO("Found new update of themes, updating themes list...");
+
+
+    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_update_themes = time(0);
 }
 
 static std::string popup, menu, sub_menu, selected, title, delete_user_background, delete_theme;
diff --git a/vita3k/gui/src/settings_dialog.cpp b/vita3k/gui/src/settings_dialog.cpp
index 9c6550e3b5..22b33dab7a 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_bgm_volume(emuenv.cfg.bgm_volume / 100.f);
     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, 10, 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..b11cdba1bc 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,254 @@ 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_thread;
+cubeb_stream *stream = nullptr;
+bool stop_requested;
+std::condition_variable stop_condition;
+cubeb *ctx = nullptr;
+PcmData pcm_data;
+
+void stop_bgm_theme() {
+    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 thread to finish
+    if (playback_thread.joinable()) {
+        playback_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_bgm_state(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_bgm_volume(const float volume) {
+    if (!stream) {
+        LOG_ERROR("The background music stream is not initialized!");
+        return;
+    }
+
+    cubeb_stream_set_volume(stream, volume);
+}
+
+static void pcm_playback_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);
+}
+
+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;
+
+    if (cubeb_stream_init(ctx, &stream, "Stream BGM", nullptr, nullptr,
+            nullptr, &output_params, 4096, data_callback, state_callback, &pcm_data)
+        != CUBEB_OK) {
+        LOG_ERROR("Failed to initialize Cubeb stream");
+        return;
+    }
+
+    set_bgm_volume(vol);
+
+    // Start playback in a new thread
+    playback_thread = std::thread(pcm_playback_thread);
+}
+
+struct At9Header {
+    char magic[4];
+    uint32_t file_size;
+    char id[4];
+    char fmt[4];
+    uint32_t fmt_size;
+    uint16_t format_tag;
+    uint16_t num_channels;
+    uint32_t sample_rate;
+    uint32_t byte_rate;
+    uint16_t block_align;
+    uint16_t bits_per_sample;
+    uint16_t extension_size;
+    uint16_t samples_per_block;
+    uint32_t channel_mask;
+    char codec_id[16];
+    uint32_t version;
+    uint32_t config_data;
+};
+
+static void load_bgm(std::vector<uint8_t> at9_data) {
+    uint8_t *es_data = at9_data.data();
+
+    // Get the header of the AT9 file
+    At9Header header;
+    memcpy(&header, es_data, sizeof(At9Header));
+
+    const uint32_t es_size = at9_data.size();
+
+    // Create a new decoder with the configuration data from the AT9 header
+    Atrac9DecoderState decoder(header.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;
+
+    // Set offset of data start
+    const auto data_start = 168;
+
+    // Set data size
+    const auto data_size = es_size - data_start;
+
+    // Set data start pointer
+    es_data += data_start;
+
+    // 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) {
+        // Set the number of bytes to send to the decoder
+        const size_t bytes_to_send = std::min(es_size_max, data_size - total_bytes_read);
+        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, bytes_to_send)
+            || !decoder.receive(pcm_buffer.data(), &size)) {
+            LOG_ERROR("Error at offset {} while sending or decoding AT9 after sending {} bytes.", total_bytes_read, bytes_to_send);
+            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_theme_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; 
+    }
+
+    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 +469,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 +501,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 +564,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 +578,9 @@ bool init_theme(GuiState &gui, EmuEnvState &emuenv, const std::string &content_i
         }
     }
 
+    // Init theme BGM
+    init_theme_bgm(emuenv, path_bgm);
+
     for (const auto &icon : theme_icon_name) {
         int32_t width = 0;
         int32_t height = 0;
@@ -504,6 +764,7 @@ void draw_start_screen(GuiState &gui, EmuEnvState &emuenv) {
 
     if ((ImGui::IsWindowHovered(ImGuiFocusedFlags_RootWindow) && ImGui::IsMouseClicked(0))) {
         gui.vita_area.start_screen = false;
+        switch_bgm_state(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..05c365a26f 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_bgm_state(!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_theme();
             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..73b206900b 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_theme_bgm(emuenv, { "pd0", "data/systembgm/initialsetup.at9" });
+            gui::switch_bgm_state(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_bgm_state(true);
     gui::init_app_background(gui, emuenv, emuenv.io.app_path);
     gui::update_last_time_app_used(gui, emuenv, emuenv.io.app_path);