diff --git a/include/Cubed/audio/audio_engine.hpp b/include/Cubed/audio/audio_engine.hpp
index 56a2b97..c800800 100644
--- a/include/Cubed/audio/audio_engine.hpp
+++ b/include/Cubed/audio/audio_engine.hpp
@@ -27,6 +27,7 @@ public:
 
     void init();
     void play_bgm();
+    void stop_bgm();
     void change_bgm(const std::string& sound);
     void play_3d(const std::string& sound, const glm::vec3& pos,
                  bool check = false);
diff --git a/include/Cubed/config.hpp b/include/Cubed/config.hpp
index 9acb689..0abf0dc 100644
--- a/include/Cubed/config.hpp
+++ b/include/Cubed/config.hpp
@@ -25,7 +25,6 @@ public:
         }
 
         set(key, default_value);
-        save_to_file();
 
         return default_value;
     }
diff --git a/include/Cubed/gameplay/client_player.hpp b/include/Cubed/gameplay/client_player.hpp
index 46d2cdc..fd6323a 100644
--- a/include/Cubed/gameplay/client_player.hpp
+++ b/include/Cubed/gameplay/client_player.hpp
@@ -45,7 +45,7 @@ public:
     const MoveState& get_move_state() const;
 
     void change_mode(GameMode mode);
-    void hot_reload();
+    void reload_config();
     void set_player_pos(const glm::vec3& pos);
     void set_place_block(unsigned id);
     void update(float delta_time);
diff --git a/include/Cubed/gameplay/client_world.hpp b/include/Cubed/gameplay/client_world.hpp
index 5bf58a5..7f45227 100644
--- a/include/Cubed/gameplay/client_world.hpp
+++ b/include/Cubed/gameplay/client_world.hpp
@@ -83,7 +83,7 @@ public:
     void start_thread_pool();
     void stop_thread_pool();
     void change_pool_threads(int threads);
-    void hot_reload();
+    void reload_config(bool chunk_build = true);
     void request_chunk();
     std::vector<glm::vec4>& planes();
     const std::vector<const ChunkRenderSnapshot*>& render_snapshots() const;
diff --git a/include/Cubed/render/renderer.hpp b/include/Cubed/render/renderer.hpp
index 0a3aa56..9043070 100644
--- a/include/Cubed/render/renderer.hpp
+++ b/include/Cubed/render/renderer.hpp
@@ -26,7 +26,7 @@ public:
 
     Renderer(TextureManager& texture_manager, Config& config);
     ~Renderer();
-    void hot_reload();
+    void reload_config();
     void init(bool debug_on);
     const Shader& get_shader(const std::string& name) const;
     void begin_frame();
diff --git a/include/Cubed/scene/credits_scene.hpp b/include/Cubed/scene/credits_scene.hpp
index 084d8f5..c5ffaec 100644
--- a/include/Cubed/scene/credits_scene.hpp
+++ b/include/Cubed/scene/credits_scene.hpp
@@ -11,6 +11,7 @@ public:
     void render(Renderer& renderer) override;
     bool handle_event(const Event& e) override;
     void on_enter() override;
+    void on_re_enter() override;
     SceneManager& scene_manager();
 
 private:
diff --git a/include/Cubed/scene/main_menu_scene.hpp b/include/Cubed/scene/main_menu_scene.hpp
index 5abb913..af84472 100644
--- a/include/Cubed/scene/main_menu_scene.hpp
+++ b/include/Cubed/scene/main_menu_scene.hpp
@@ -18,7 +18,7 @@ public:
     bool handle_event(const Event& e) override;
     void on_enter() override;
     void on_leave() override;
-
+    void on_re_enter() override;
     SceneManager& scene_manager();
 
 private:
diff --git a/include/Cubed/scene/scene.hpp b/include/Cubed/scene/scene.hpp
index 9f0b79c..0f774e4 100644
--- a/include/Cubed/scene/scene.hpp
+++ b/include/Cubed/scene/scene.hpp
@@ -3,7 +3,7 @@
 namespace Cubed {
 class Renderer;
 
-enum class SceneType { MAIN_MENU, WORLD, CREDITS };
+enum class SceneType { MAIN_MENU, WORLD, CREDITS, SETTINGS };
 
 class Scene {
 public:
@@ -20,6 +20,7 @@ public:
     virtual bool handle_event(const Event& e) = 0;
     virtual void on_enter() {};
     virtual void on_leave() {};
+    virtual void on_re_enter() {};
 
 protected:
     virtual bool handle_mouse_move_event(const MouseMoveEvent&) {
diff --git a/include/Cubed/scene/scene_manager.hpp b/include/Cubed/scene/scene_manager.hpp
index 09dbbda..cb216fc 100644
--- a/include/Cubed/scene/scene_manager.hpp
+++ b/include/Cubed/scene/scene_manager.hpp
@@ -40,7 +40,7 @@ private:
     void process_operation();
     void change(SceneType type);
     void push(SceneType type);
-    void pop();
+    void pop(bool re_enter = true);
 
     std::unique_ptr<Scene> create_scene(SceneType);
 };
diff --git a/include/Cubed/scene/settings_scene.hpp b/include/Cubed/scene/settings_scene.hpp
new file mode 100644
index 0000000..57f322e
--- /dev/null
+++ b/include/Cubed/scene/settings_scene.hpp
@@ -0,0 +1,39 @@
+#pragma once
+#include "Cubed/scene/scene.hpp"
+#include "Cubed/ui/settings_ui.hpp"
+namespace Cubed {
+
+struct SliderVariable {
+    float fov = 70.0f;
+    float mouse_sensitivity = 0.15f;
+    float sfx = 1.0f;
+    float music = 0.5f;
+    int rendering_distance = 24;
+};
+
+class SceneManager;
+class SettingsScene : public Scene {
+public:
+    SettingsScene(const SettingsScene&) = delete;
+    SettingsScene(SettingsScene&&) = delete;
+    SettingsScene& operator=(const SettingsScene&) = delete;
+    SettingsScene& operator=(SettingsScene&&) = delete;
+    SettingsScene(SceneManager& scene_manager);
+    ~SettingsScene();
+
+    void update(float dt) override;
+    void render(Renderer& renderer) override;
+    bool handle_event(const Event& e) override;
+    void on_enter() override;
+    void on_leave() override;
+    void on_re_enter() override;
+    SceneManager& scene_manager();
+    SliderVariable& slider_variable();
+
+private:
+    void save_and_apply();
+    SceneManager& m_scene_manager;
+    SliderVariable m_slider_variable;
+    SettingsUI m_settings_ui;
+};
+} // namespace Cubed
\ No newline at end of file
diff --git a/include/Cubed/scene/world_scene.hpp b/include/Cubed/scene/world_scene.hpp
index 7cd9e90..2a7521f 100644
--- a/include/Cubed/scene/world_scene.hpp
+++ b/include/Cubed/scene/world_scene.hpp
@@ -24,7 +24,7 @@ public:
     bool handle_event(const Event& e) override;
     void on_enter() override;
     void on_leave() override;
-
+    void on_re_enter() override;
     Camera& camera();
     SceneManager& scene_manager();
     ClientWorld& client_world();
diff --git a/include/Cubed/ui/button.hpp b/include/Cubed/ui/button.hpp
index 324ea29..ff81136 100644
--- a/include/Cubed/ui/button.hpp
+++ b/include/Cubed/ui/button.hpp
@@ -27,6 +27,7 @@ public:
     Button& set_height(float height);
     Button& set_background_image(const std::string& path,
                                  TextureManager& texture_manager);
+    Button& set_default_image(TextureManager& texture_manager);
     Button& set_text(const std::string& text);
 
     float scale() const;
@@ -38,6 +39,8 @@ public:
 private:
     static constexpr float PADDING = 5.0f;
     static constexpr float DEFAULT_SCALE = 3.0f;
+    static constexpr const char* DEFAULT_BUTTON_IMAGE =
+        "texture/ui/button001.png";
     std::function<void()> m_clicked;
     std::unique_ptr<Image> m_background;
     std::unique_ptr<Label> m_foreground;
diff --git a/include/Cubed/ui/settings_ui.hpp b/include/Cubed/ui/settings_ui.hpp
new file mode 100644
index 0000000..022af30
--- /dev/null
+++ b/include/Cubed/ui/settings_ui.hpp
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "Cubed/ui/ui_manager.hpp"
+namespace Cubed {
+class SettingsScene;
+class SettingsUI : public UIManager {
+public:
+    SettingsUI(SettingsScene& scene);
+    void init() override;
+
+private:
+    bool handle_key_event(const KeyEvent& e) override;
+    SettingsScene& m_scene;
+};
+
+} // namespace Cubed
\ No newline at end of file
diff --git a/include/Cubed/ui/slider.hpp b/include/Cubed/ui/slider.hpp
index 3cccfb6..0abd4f0 100644
--- a/include/Cubed/ui/slider.hpp
+++ b/include/Cubed/ui/slider.hpp
@@ -29,13 +29,18 @@ public:
     Slider& set_thumb_image(const std::string& path,
                             TextureManager& texture_manager);
 
+    Slider& set_default_image(TextureManager& texture_manager);
+
     bool handle_mouse_move_event(const MouseMoveEvent& e) override;
     bool handle_mouse_button_event(const MouseButtonEvent& e) override;
 
 private:
     static constexpr float PADDING = 5.0f;
     static constexpr float DEFAULT_SCALE = 3.0f;
-
+    static constexpr const char* DEFAULT_TRACK_IMAGE =
+        "texture/ui/slider_track001.png";
+    static constexpr const char* DEFAULT_THUMB_IMAGE =
+        "texture/ui/slider_thumb001.png";
     std::unique_ptr<Image> m_track;
     std::unique_ptr<Image> m_thumb;
     std::unique_ptr<Label> m_label;
diff --git a/include/Cubed/window.hpp b/include/Cubed/window.hpp
index 6772f27..30606dd 100644
--- a/include/Cubed/window.hpp
+++ b/include/Cubed/window.hpp
@@ -22,7 +22,7 @@ public:
     // end of frame to reload!
     bool handle_event(const Event& e);
 
-    void hot_reload();
+    void reload_config();
 
     void toggle_fullscreen();
 
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index b44b734..68219e6 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -74,4 +74,6 @@ target_sources(${PROJECT_NAME}
         scene/credits_scene.cpp
         ui/credits_ui.cpp
         ui/slider.cpp
+        ui/settings_ui.cpp
+        scene/settings_scene.cpp
 )
\ No newline at end of file
diff --git a/src/audio/audio_engine.cpp b/src/audio/audio_engine.cpp
index 26f17ee..b5c3994 100644
--- a/src/audio/audio_engine.cpp
+++ b/src/audio/audio_engine.cpp
@@ -93,7 +93,7 @@ void AudioEngine::init() {
 }
 
 void AudioEngine::play_bgm() { m_bgm->play(); }
-
+void AudioEngine::stop_bgm() { m_bgm->stop(); }
 void AudioEngine::change_bgm(const std::string& sound) {
     Logger::info("change bgm {}", sound);
     m_bgm->stop();
diff --git a/src/audio/audio_source.cpp b/src/audio/audio_source.cpp
index 22a4163..30b9562 100644
--- a/src/audio/audio_source.cpp
+++ b/src/audio/audio_source.cpp
@@ -79,7 +79,13 @@ void AudioSource::set_pitch(float pitch) {
     alSourcef(m_source, AL_PITCH, pitch);
 }
 
-void AudioSource::play() { alSourcePlay(m_source); }
+void AudioSource::play() {
+
+    if (state() != AudioState::INITIAL) {
+        stop();
+    }
+    alSourcePlay(m_source);
+}
 
 void AudioSource::play_2d(const AudioBuffer& buffer) {
     set_buffer_2d(buffer);
diff --git a/src/dev_panel.cpp b/src/dev_panel.cpp
index 0e51534..f14ed92 100644
--- a/src/dev_panel.cpp
+++ b/src/dev_panel.cpp
@@ -325,42 +325,42 @@ void DevPanel::show_settings_tab_item() {
     if (ImGui::BeginTabItem("settings")) {
         if (ImGui::SliderFloat("FOV", &m_config_view.fov, 1.0f, 140.0f)) {
             m_config.set("player.fov", static_cast<double>(m_config_view.fov));
-            m_app.renderer().hot_reload();
+            m_app.renderer().reload_config();
         }
         ImGui::SameLine();
         if (ImGui::Button("default##1")) {
             m_config_view.fov = DEFAULT_FOV;
             m_config.set("player.fov", static_cast<double>(m_config_view.fov));
-            m_app.renderer().hot_reload();
+            m_app.renderer().reload_config();
         }
         if (ImGui::SliderFloat("Sensitivity", &m_config_view.mouse_sensitivity,
                                0.01f, 1.0f)) {
             m_config.set("player.mouse_sensitivity",
                          static_cast<double>(m_config_view.mouse_sensitivity));
-            m_player->hot_reload();
+            m_player->reload_config();
         }
         ImGui::SameLine();
         if (ImGui::Button("default##2")) {
             m_config_view.mouse_sensitivity = 0.15f;
             m_config.set("player.mouse_sensitivity",
                          static_cast<double>(m_config_view.mouse_sensitivity));
-            m_player->hot_reload();
+            m_player->reload_config();
         }
 
         if (ImGui::SliderInt("Distance", &m_config_view.rendering_distance, 2,
                              128)) {
             m_config.set("world.rendering_distance",
                          m_config_view.rendering_distance);
-            m_world_scene.client_world().hot_reload();
+            m_world_scene.client_world().reload_config();
         }
         if (ImGui::Checkbox("Fullscreen", &m_config_view.fullscreen)) {
             m_config.set("window.fullscreen", m_config_view.fullscreen);
-            m_app.window().hot_reload();
+            m_app.window().reload_config();
         }
         ImGui::SameLine();
         if (ImGui::Checkbox("V-Sync", &m_config_view.v_sync)) {
             m_config.set("window.V-Sync", m_config_view.v_sync);
-            m_app.window().hot_reload();
+            m_app.window().reload_config();
         }
         if (ImGui::Checkbox("Aniso", &m_config_view.is_enable_aniso)) {
             m_config_view.is_reload = false;
diff --git a/src/gameplay/client_player.cpp b/src/gameplay/client_player.cpp
index 821d6e1..cbc4393 100644
--- a/src/gameplay/client_player.cpp
+++ b/src/gameplay/client_player.cpp
@@ -120,7 +120,7 @@ void ClientPlayer::change_mode(GameMode mode) {
         m_max_speed = m_max_run_speed;
     }
 }
-void ClientPlayer::hot_reload() {
+void ClientPlayer::reload_config() {
     auto& config = m_world.get_config();
     m_sensitivity = config.get("player.mouse_sensitivity", 0.15f);
 }
diff --git a/src/gameplay/client_world.cpp b/src/gameplay/client_world.cpp
index d17f625..bb50659 100644
--- a/src/gameplay/client_world.cpp
+++ b/src/gameplay/client_world.cpp
@@ -398,6 +398,9 @@ void ClientWorld::init(std::string_view player_name,
                        std::shared_ptr<NetworkClient> client) {
     m_player.init(player_name);
     m_client = client;
+
+    reload_config(false);
+
     m_random.init(ChunkGenerator::seed());
 
     // timer
@@ -522,11 +525,15 @@ void ClientWorld::change_pool_threads(int threads) {
     m_thread_pool.store(std::make_shared<PriorityThreadPool>(used_thread));
 }
 
-void ClientWorld::hot_reload() {
+void ClientWorld::reload_config(bool chunk_build) {
     int dist = m_config.get<int>("world.rendering_distance", PRE_LOAD_DISTANCE);
     Logger::info("Get Config Randering dist {}", dist);
     m_rendering_distance = dist <= MAX_DISTANCE ? dist : MAX_DISTANCE;
-    request_chunk();
+    if (chunk_build) {
+        request_chunk();
+    }
+
+    m_player.reload_config();
 }
 
 void ClientWorld::client_run(std::stop_token stoken) {
diff --git a/src/render/renderer.cpp b/src/render/renderer.cpp
index 290ac92..0e2fb51 100644
--- a/src/render/renderer.cpp
+++ b/src/render/renderer.cpp
@@ -33,7 +33,9 @@ Renderer::~Renderer() {
     }
 }
 
-void Renderer::hot_reload() { update_fov(m_config.get("player.fov", 70.0f)); }
+void Renderer::reload_config() {
+    update_fov(m_config.get("player.fov", 70.0f));
+}
 
 void Renderer::init(bool debug_on) {
     if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
@@ -108,7 +110,7 @@ void Renderer::init(bool debug_on) {
 
     init_quad();
     init_text();
-    hot_reload();
+    reload_config();
 
     m_world_renderer.init();
 
diff --git a/src/scene/credits_scene.cpp b/src/scene/credits_scene.cpp
index e791125..6c143c1 100644
--- a/src/scene/credits_scene.cpp
+++ b/src/scene/credits_scene.cpp
@@ -1,5 +1,8 @@
 #include "Cubed/scene/credits_scene.hpp"
 
+#include "Cubed/app.hpp"
+#include "Cubed/scene/scene_manager.hpp"
+
 namespace Cubed {
 CreditsScene::CreditsScene(SceneManager& scene_manager)
     : m_scene_manager(scene_manager), m_ui(*this) {}
@@ -13,6 +16,13 @@ bool CreditsScene::handle_event(const Event& e) {
     return false;
 }
 void CreditsScene::on_enter() { m_ui.init(); }
+void CreditsScene::on_re_enter() {
+    auto width = m_scene_manager.app().renderer().window_width();
+    auto height = m_scene_manager.app().renderer().window_height();
+
+    handle_event(
+        WindowResizeEvent{static_cast<int>(width), static_cast<int>(height)});
+};
 SceneManager& CreditsScene::scene_manager() { return m_scene_manager; }
 
 } // namespace Cubed
\ No newline at end of file
diff --git a/src/scene/main_menu_scene.cpp b/src/scene/main_menu_scene.cpp
index df08ee5..56f11e2 100644
--- a/src/scene/main_menu_scene.cpp
+++ b/src/scene/main_menu_scene.cpp
@@ -1,5 +1,8 @@
 #include "Cubed/scene/main_menu_scene.hpp"
 
+#include "Cubed/app.hpp"
+#include "Cubed/scene/scene_manager.hpp"
+
 namespace Cubed {
 MainMenuScene::MainMenuScene(SceneManager& scene_manager)
     : m_scene_manager(scene_manager), m_ui_manager(*this) {}
@@ -17,5 +20,12 @@ bool MainMenuScene::handle_event(const Event& e) {
 }
 void MainMenuScene::on_enter() { m_ui_manager.init(); }
 void MainMenuScene::on_leave() {}
+void MainMenuScene::on_re_enter() {
+    auto width = m_scene_manager.app().renderer().window_width();
+    auto height = m_scene_manager.app().renderer().window_height();
+
+    handle_event(
+        WindowResizeEvent{static_cast<int>(width), static_cast<int>(height)});
+}
 SceneManager& MainMenuScene::scene_manager() { return m_scene_manager; }
 } // namespace Cubed
\ No newline at end of file
diff --git a/src/scene/scene_manager.cpp b/src/scene/scene_manager.cpp
index 9ce86f1..79859ac 100644
--- a/src/scene/scene_manager.cpp
+++ b/src/scene/scene_manager.cpp
@@ -2,6 +2,7 @@
 
 #include "Cubed/scene/credits_scene.hpp"
 #include "Cubed/scene/main_menu_scene.hpp"
+#include "Cubed/scene/settings_scene.hpp"
 #include "Cubed/scene/world_scene.hpp"
 
 namespace Cubed {
@@ -63,7 +64,7 @@ void SceneManager::process_operation() {
 
 void SceneManager::change(SceneType type) {
     if (!m_scenes.empty()) {
-        pop();
+        pop(false);
     }
 
     push(type);
@@ -73,7 +74,7 @@ void SceneManager::push(SceneType type) {
     scene->on_enter();
     m_scenes.push(std::move(scene));
 }
-void SceneManager::pop() {
+void SceneManager::pop(bool re_enter) {
     if (m_scenes.empty()) {
         return;
     }
@@ -81,6 +82,9 @@ void SceneManager::pop() {
     m_scenes.pop();
     scene->on_leave();
     m_pending_delete_scene.push_back(std::move(scene));
+    if (!m_scenes.empty() && re_enter) {
+        m_scenes.top()->on_re_enter();
+    }
 }
 
 std::unique_ptr<Scene> SceneManager::create_scene(SceneType type) {
@@ -91,6 +95,8 @@ std::unique_ptr<Scene> SceneManager::create_scene(SceneType type) {
         return std::make_unique<MainMenuScene>(*this);
     case SceneType::CREDITS:
         return std::make_unique<CreditsScene>(*this);
+    case SceneType::SETTINGS:
+        return std::make_unique<SettingsScene>(*this);
     }
 
     std::string err = std::format("Unknown Scene");
diff --git a/src/scene/settings_scene.cpp b/src/scene/settings_scene.cpp
new file mode 100644
index 0000000..d318fbe
--- /dev/null
+++ b/src/scene/settings_scene.cpp
@@ -0,0 +1,59 @@
+#include "Cubed/scene/settings_scene.hpp"
+
+#include "Cubed/app.hpp"
+#include "Cubed/config.hpp"
+#include "Cubed/scene/scene_manager.hpp"
+namespace Cubed {
+SettingsScene::SettingsScene(SceneManager& scene_manager)
+    : m_scene_manager(scene_manager), m_settings_ui(*this) {}
+SettingsScene::~SettingsScene() {}
+
+void SettingsScene::update(float dt) { m_settings_ui.update(dt); }
+void SettingsScene::render(Renderer& renderer) {
+    m_settings_ui.render(renderer);
+}
+bool SettingsScene::handle_event(const Event& e) {
+    if (m_settings_ui.handle_event(e)) {
+        return true;
+    }
+    return false;
+}
+void SettingsScene::on_enter() {
+    m_settings_ui.init();
+    auto& config = m_scene_manager.app().config();
+    m_slider_variable.fov = config.get("player.fov", m_slider_variable.fov);
+    m_slider_variable.mouse_sensitivity = config.get(
+        "player.mouse_sensitivity", m_slider_variable.mouse_sensitivity);
+    m_slider_variable.music =
+        config.get("volume.music", m_slider_variable.music);
+    m_slider_variable.sfx = config.get("volume.SFX", m_slider_variable.sfx);
+    m_slider_variable.rendering_distance = config.get(
+        "world.rendering_distance", m_slider_variable.rendering_distance);
+}
+void SettingsScene::on_leave() { save_and_apply(); }
+
+void SettingsScene::on_re_enter() {
+    auto width = m_scene_manager.app().renderer().window_width();
+    auto height = m_scene_manager.app().renderer().window_height();
+
+    handle_event(
+        WindowResizeEvent{static_cast<int>(width), static_cast<int>(height)});
+}
+
+void SettingsScene::save_and_apply() {
+    auto& config = m_scene_manager.app().config();
+    config.set("player.fov", m_slider_variable.fov);
+    config.set("player.mouse_sensitivity", m_slider_variable.mouse_sensitivity);
+    config.set("world.rendering_distance",
+               m_slider_variable.rendering_distance);
+    config.set("volume.SFX", m_slider_variable.sfx);
+    config.set("volume.music", m_slider_variable.music);
+    config.save_to_file();
+    auto& app = m_scene_manager.app();
+    app.audio().reload_config();
+    app.renderer().reload_config();
+}
+
+SceneManager& SettingsScene::scene_manager() { return m_scene_manager; }
+SliderVariable& SettingsScene::slider_variable() { return m_slider_variable; }
+} // namespace Cubed
\ No newline at end of file
diff --git a/src/scene/world_scene.cpp b/src/scene/world_scene.cpp
index d1072e4..8bc0a80 100644
--- a/src/scene/world_scene.cpp
+++ b/src/scene/world_scene.cpp
@@ -127,6 +127,16 @@ void WorldScene::on_leave() {
     if (!m_argument.is_client) {
         m_server.server_world().stop();
     }
+    m_scene_manager.app().audio().stop_bgm();
+}
+
+void WorldScene::on_re_enter() {
+    m_client_world.reload_config();
+    auto width = m_scene_manager.app().renderer().window_width();
+    auto height = m_scene_manager.app().renderer().window_height();
+
+    handle_event(
+        WindowResizeEvent{static_cast<int>(width), static_cast<int>(height)});
 }
 
 bool WorldScene::handle_mouse_move_event(const MouseMoveEvent& e) {
diff --git a/src/ui/button.cpp b/src/ui/button.cpp
index d295224..7d35f36 100644
--- a/src/ui/button.cpp
+++ b/src/ui/button.cpp
@@ -76,6 +76,11 @@ Button& Button::set_background_image(const std::string& path,
     m_background->set_image(path, texture_manager);
     return *this;
 }
+
+Button& Button::set_default_image(TextureManager& texture_manager) {
+    return set_background_image(DEFAULT_BUTTON_IMAGE, texture_manager);
+}
+
 Button& Button::set_text(const std::string& text) {
     m_foreground->set_text(text);
     update_text_scale();
diff --git a/src/ui/main_menu_ui_manager.cpp b/src/ui/main_menu_ui_manager.cpp
index 23bfae7..cb67019 100644
--- a/src/ui/main_menu_ui_manager.cpp
+++ b/src/ui/main_menu_ui_manager.cpp
@@ -16,11 +16,10 @@ MainMenuUIManager::~MainMenuUIManager() {}
 void MainMenuUIManager::init() {
 
     auto image = std::make_unique<Image>(nullptr);
-
+    auto& texture_manager = m_scene.scene_manager().app().texture_manager();
     image->set_fill(true);
     image->set_anchor(Anchor::TOP_LEFT);
-    image->set_image("texture/ui/background.png",
-                     m_scene.scene_manager().app().texture_manager());
+    image->set_image("texture/ui/background.png", texture_manager);
     auto& renderer = m_scene.scene_manager().app().renderer();
     image->set_window_size(renderer.window_width(), renderer.window_height());
 
@@ -31,20 +30,28 @@ void MainMenuUIManager::init() {
     {
         auto& start_game_button = layout.add_child<Button>();
 
-        start_game_button.set_background_image(
-            "texture/ui/button001.png",
-            m_scene.scene_manager().app().texture_manager());
+        start_game_button.set_background_image("texture/ui/button001.png",
+                                               texture_manager);
         start_game_button.set_text("Start Game");
         start_game_button.set_clicked([this]() {
             m_scene.scene_manager().request_push(SceneType::WORLD);
         });
     }
+
+    {
+        auto& button = layout.add_child<Button>();
+        button.set_default_image(texture_manager);
+        button.set_text("Settings");
+        button.set_clicked([this]() {
+            m_scene.scene_manager().request_push(SceneType::SETTINGS);
+        });
+    }
+
     {
         auto& button = layout.add_child<Button>();
 
-        button.set_background_image(
-            "texture/ui/button001.png",
-            m_scene.scene_manager().app().texture_manager());
+        button.set_background_image("texture/ui/button001.png",
+                                    texture_manager);
         button.set_text("Credits");
         button.set_clicked([this]() {
             m_scene.scene_manager().request_push(SceneType::CREDITS);
@@ -52,9 +59,8 @@ void MainMenuUIManager::init() {
     }
     {
         auto& exit_game = layout.add_child<Button>();
-        exit_game.set_background_image(
-            "texture/ui/button001.png",
-            m_scene.scene_manager().app().texture_manager());
+        exit_game.set_background_image("texture/ui/button001.png",
+                                       texture_manager);
         exit_game.set_text("Exit");
 
         exit_game.set_clicked([this]() {
diff --git a/src/ui/pause_menu_ui_manager.cpp b/src/ui/pause_menu_ui_manager.cpp
index f78e506..f9c7ee5 100644
--- a/src/ui/pause_menu_ui_manager.cpp
+++ b/src/ui/pause_menu_ui_manager.cpp
@@ -3,6 +3,7 @@
 #include "Cubed/scene/scene_manager.hpp"
 #include "Cubed/scene/world_scene.hpp"
 #include "Cubed/ui/button.hpp"
+#include "Cubed/ui/column_layout.hpp"
 #include "Cubed/ui/pasue_menu_ui_manager.hpp"
 #include "Cubed/ui/rect.hpp"
 namespace Cubed {
@@ -16,14 +17,36 @@ void PauseMenuUIManager::init() {
     rect->set_anchor(Anchor::TOP_LEFT);
     auto& renderer = m_scene.scene_manager().app().renderer();
     rect->set_window_size(renderer.window_width(), renderer.window_height());
-    auto& back_main = rect->add_child<Button>();
+    auto& texture_manager = m_scene.scene_manager().app().texture_manager();
+    auto& layout = rect->add_child<ColumnLayout>();
+    layout.set_anchor(Anchor::CENTER);
+    layout.set_spacing(20);
+    {
+        auto& button = layout.add_child<Button>();
+        button.set_default_image(texture_manager);
+        button.set_text("Back to Game");
+        button.set_clicked([this]() { m_scene.set_pause(false); });
+    }
+
+    {
+        auto& button = layout.add_child<Button>();
+        button.set_default_image(texture_manager);
+        button.set_text("Settings");
+        button.set_clicked([this]() {
+            m_scene.scene_manager().request_push(SceneType::SETTINGS);
+        });
+    }
+
+    {
+        auto& back_main = layout.add_child<Button>();
+
+        back_main.set_background_image("texture/ui/button001.png",
+                                       texture_manager);
+        back_main.set_text("Return to Menu");
+        back_main.set_clicked(
+            [this]() { m_scene.scene_manager().request_pop(); });
+    }
 
-    back_main.set_background_image(
-        "texture/ui/button001.png",
-        m_scene.scene_manager().app().texture_manager());
-    back_main.set_text("return to main menu");
-    back_main.set_anchor(Anchor::CENTER);
-    back_main.set_clicked([this]() { m_scene.scene_manager().request_pop(); });
     m_root_widget = std::move(rect);
 }
 
diff --git a/src/ui/settings_ui.cpp b/src/ui/settings_ui.cpp
new file mode 100644
index 0000000..7cda4ea
--- /dev/null
+++ b/src/ui/settings_ui.cpp
@@ -0,0 +1,86 @@
+#include "Cubed/ui/settings_ui.hpp"
+
+#include "Cubed/app.hpp"
+#include "Cubed/render/renderer.hpp"
+#include "Cubed/scene/scene_manager.hpp"
+#include "Cubed/scene/settings_scene.hpp"
+#include "Cubed/ui/button.hpp"
+#include "Cubed/ui/column_layout.hpp"
+#include "Cubed/ui/image.hpp"
+#include "Cubed/ui/slider.hpp"
+namespace Cubed {
+SettingsUI::SettingsUI(SettingsScene& scene) : m_scene(scene) {}
+void SettingsUI::init() {
+    auto bi = std::make_unique<Image>(nullptr);
+    auto& renderer = m_scene.scene_manager().app().renderer();
+    auto& texture_manager = m_scene.scene_manager().app().texture_manager();
+
+    bi->set_window_size(renderer.window_width(), renderer.window_height());
+    bi->set_anchor(Anchor::TOP_LEFT);
+    bi->set_image("texture/ui/background.png", texture_manager);
+    bi->set_fill(true);
+
+    auto& rect = bi->add_child<Rect>();
+    rect.set_fill(true);
+    rect.set_alpha(0.7f);
+    rect.set_color(Color::BLACK);
+
+    auto& layout = rect.add_child<ColumnLayout>();
+    layout.set_anchor(Anchor::TOP_CENTER);
+    layout.set_offset({0, 20});
+    layout.set_spacing(20.0f);
+    auto& v = m_scene.slider_variable();
+    auto set_default_slider_image = [&](Slider& slider) {
+        slider.set_thumb_image("texture/ui/slider_thumb001.png",
+                               texture_manager);
+        slider.set_track_image("texture/ui/slider_track001.png",
+                               texture_manager);
+    };
+
+    {
+        auto& fov = layout.add_child<Slider>();
+        fov.set_slider(&v.fov, 20.0f, 120.0f);
+        set_default_slider_image(fov);
+        fov.set_text("Fov");
+
+        auto& sensitivity = layout.add_child<Slider>();
+        sensitivity.set_slider(&v.mouse_sensitivity, 0.01f, 1.0f);
+        set_default_slider_image(sensitivity);
+        sensitivity.set_text("Sensitivity");
+
+        auto& distance = layout.add_child<Slider>();
+        distance.set_slider(&v.rendering_distance, 2, 64);
+        set_default_slider_image(distance);
+        distance.set_text("Distance");
+
+        auto& music = layout.add_child<Slider>();
+        music.set_slider(&v.music, 0.0f, 1.0f);
+        set_default_slider_image(music);
+        music.set_text("Music");
+
+        auto& sfx = layout.add_child<Slider>();
+        sfx.set_slider(&v.sfx, 0.0f, 1.0f);
+        set_default_slider_image(sfx);
+        sfx.set_text("SFX");
+    }
+
+    auto& return_button = layout.add_child<Button>();
+    return_button.set_background_image("texture/ui/button001.png",
+                                       texture_manager);
+
+    return_button.set_text("Save and Return");
+    return_button.set_clicked(
+        [this]() { m_scene.scene_manager().request_pop(); });
+
+    m_root_widget = std::move(bi);
+}
+
+bool SettingsUI::handle_key_event(const KeyEvent& e) {
+    if (e.key == Key::ESCAPE && e.action == KeyAction::PRESS) {
+        m_scene.scene_manager().request_pop();
+        return true;
+    }
+    return UIManager::handle_key_event(e);
+}
+
+} // namespace Cubed
\ No newline at end of file
diff --git a/src/ui/slider.cpp b/src/ui/slider.cpp
index a743947..0b2588c 100644
--- a/src/ui/slider.cpp
+++ b/src/ui/slider.cpp
@@ -99,6 +99,11 @@ Slider& Slider::set_thumb_image(const std::string& path,
     return *this;
 }
 
+Slider& Slider::set_default_image(TextureManager& texture_manager) {
+    set_thumb_image(DEFAULT_THUMB_IMAGE, texture_manager);
+    return set_track_image(DEFAULT_TRACK_IMAGE, texture_manager);
+}
+
 bool Slider::handle_mouse_move_event(const MouseMoveEvent& e) {
     auto p = pos();
     m_xpos = e.xpos;
@@ -156,7 +161,7 @@ void Slider::on_update(float dt) {
     }
     float range = m_max - m_min;
     if (range <= 0.0f) {
-        Logger::error("Range {} is <= 0.0f", range);
+        Logger::error("Slider {} Range {} is <= 0.0f", m_text, range);
         ASSERT(false);
         return;
     }
diff --git a/src/window.cpp b/src/window.cpp
index 8faf7ab..92d382f 100644
--- a/src/window.cpp
+++ b/src/window.cpp
@@ -154,7 +154,7 @@ void Window::init() {
                      static_cast<int>(mode->height / 2.0f) - 300);
 }
 
-void Window::hot_reload() {
+void Window::reload_config() {
     // V-Sync
     if (m_config.get("window.V-Sync", true)) {
         glfwSwapInterval(1);