14 files changed, 131 insertions, 118 deletions

diff --git a/src/input_common/mouse/mouse_input.cpp b/src/input_common/mouse/mouse_input.cpp
index 67a584d53..b864d26f2 100644
--- a/src/input_common/mouse/mouse_input.cpp
+++ b/src/input_common/mouse/mouse_input.cpp
@@ -33,11 +33,16 @@ void Mouse::UpdateThread() {
             info.motion.UpdateOrientation(update_time * 1000);
             info.tilt_speed = 0;
             info.data.motion = info.motion.GetMotion();
+            if (Settings::values.mouse_panning) {
+                info.last_mouse_change *= 0.96f;
+                info.data.axis = {static_cast<int>(16 * info.last_mouse_change.x),
+                                  static_cast<int>(16 * -info.last_mouse_change.y)};
+            }
         }
         if (configuring) {
             UpdateYuzuSettings();
         }
-        if (mouse_panning_timout++ > 8) {
+        if (mouse_panning_timout++ > 20) {
             StopPanning();
         }
         std::this_thread::sleep_for(std::chrono::milliseconds(update_time));
@@ -82,16 +87,27 @@ void Mouse::StopPanning() {
 void Mouse::MouseMove(int x, int y, int center_x, int center_y) {
     for (MouseInfo& info : mouse_info) {
         if (Settings::values.mouse_panning) {
-            const auto mouse_change = Common::MakeVec(x, y) - Common::MakeVec(center_x, center_y);
+            auto mouse_change =
+                (Common::MakeVec(x, y) - Common::MakeVec(center_x, center_y)).Cast<float>();
             mouse_panning_timout = 0;
 
             if (mouse_change.y == 0 && mouse_change.x == 0) {
                 continue;
             }
+            const auto mouse_change_length = mouse_change.Length();
+            if (mouse_change_length < 3.0f) {
+                mouse_change /= mouse_change_length / 3.0f;
+            }
+
+            info.last_mouse_change = (info.last_mouse_change * 0.91f) + (mouse_change * 0.09f);
+
+            const auto last_mouse_change_length = info.last_mouse_change.Length();
+            if (last_mouse_change_length > 8.0f) {
+                info.last_mouse_change /= last_mouse_change_length / 8.0f;
+            } else if (last_mouse_change_length < 1.0f) {
+                info.last_mouse_change = mouse_change / mouse_change.Length();
+            }
 
-            info.last_mouse_change = (info.last_mouse_change * 0.8f) + (mouse_change * 0.2f);
-            info.data.axis = {static_cast<int>(16 * info.last_mouse_change.x),
-                              static_cast<int>(16 * -info.last_mouse_change.y)};
             info.tilt_direction = info.last_mouse_change;
             info.tilt_speed = info.tilt_direction.Normalize() * info.sensitivity;
             continue;
diff --git a/src/input_common/sdl/sdl_impl.cpp b/src/input_common/sdl/sdl_impl.cpp
index f67de37e3..a88ae452f 100644
--- a/src/input_common/sdl/sdl_impl.cpp
+++ b/src/input_common/sdl/sdl_impl.cpp
@@ -717,6 +717,13 @@ SDLState::SDLState() {
     if (SDL_SetHint(SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS, "1") == SDL_FALSE) {
         LOG_ERROR(Input, "Failed to set hint for background events with: {}", SDL_GetError());
     }
+// these hints are only defined on sdl2.0.9 or higher
+#if SDL_VERSION_ATLEAST(2, 0, 9)
+#if !SDL_VERSION_ATLEAST(2, 0, 12)
+    // There are also hints to toggle the individual drivers if needed.
+    SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI, "0");
+#endif
+#endif
 
     SDL_AddEventWatch(&SDLEventWatcher, this);
 
diff --git a/src/video_core/renderer_vulkan/fixed_pipeline_state.cpp b/src/video_core/renderer_vulkan/fixed_pipeline_state.cpp
index 5be6dabd9..362278f01 100644
--- a/src/video_core/renderer_vulkan/fixed_pipeline_state.cpp
+++ b/src/video_core/renderer_vulkan/fixed_pipeline_state.cpp
@@ -12,14 +12,15 @@
 #include "common/cityhash.h"
 #include "common/common_types.h"
 #include "video_core/renderer_vulkan/fixed_pipeline_state.h"
+#include "video_core/renderer_vulkan/vk_state_tracker.h"
 
 namespace Vulkan {
 
 namespace {
 
-constexpr std::size_t POINT = 0;
-constexpr std::size_t LINE = 1;
-constexpr std::size_t POLYGON = 2;
+constexpr size_t POINT = 0;
+constexpr size_t LINE = 1;
+constexpr size_t POLYGON = 2;
 constexpr std::array POLYGON_OFFSET_ENABLE_LUT = {
     POINT,   // Points
     LINE,    // Lines
@@ -40,10 +41,14 @@ constexpr std::array POLYGON_OFFSET_ENABLE_LUT = {
 
 } // Anonymous namespace
 
-void FixedPipelineState::Fill(const Maxwell& regs, bool has_extended_dynamic_state) {
-    const std::array enabled_lut = {regs.polygon_offset_point_enable,
-                                    regs.polygon_offset_line_enable,
-                                    regs.polygon_offset_fill_enable};
+void FixedPipelineState::Refresh(Tegra::Engines::Maxwell3D& maxwell3d,
+                                 bool has_extended_dynamic_state) {
+    const Maxwell& regs = maxwell3d.regs;
+    const std::array enabled_lut{
+        regs.polygon_offset_point_enable,
+        regs.polygon_offset_line_enable,
+        regs.polygon_offset_fill_enable,
+    };
     const u32 topology_index = static_cast<u32>(regs.draw.topology.Value());
 
     raw1 = 0;
@@ -64,45 +69,53 @@ void FixedPipelineState::Fill(const Maxwell& regs, bool has_extended_dynamic_sta
 
     raw2 = 0;
     const auto test_func =
-        regs.alpha_test_enabled == 1 ? regs.alpha_test_func : Maxwell::ComparisonOp::Always;
+        regs.alpha_test_enabled != 0 ? regs.alpha_test_func : Maxwell::ComparisonOp::Always;
     alpha_test_func.Assign(PackComparisonOp(test_func));
     early_z.Assign(regs.force_early_fragment_tests != 0 ? 1 : 0);
 
     alpha_test_ref = Common::BitCast<u32>(regs.alpha_test_ref);
     point_size = Common::BitCast<u32>(regs.point_size);
 
-    for (std::size_t index = 0; index < Maxwell::NumVertexArrays; ++index) {
-        binding_divisors[index] =
-            regs.instanced_arrays.IsInstancingEnabled(index) ? regs.vertex_array[index].divisor : 0;
+    if (maxwell3d.dirty.flags[Dirty::InstanceDivisors]) {
+        maxwell3d.dirty.flags[Dirty::InstanceDivisors] = false;
+        for (size_t index = 0; index < Maxwell::NumVertexArrays; ++index) {
+            const bool is_enabled = regs.instanced_arrays.IsInstancingEnabled(index);
+            binding_divisors[index] = is_enabled ? regs.vertex_array[index].divisor : 0;
+        }
     }
-
-    for (size_t index = 0; index < Maxwell::NumVertexAttributes; ++index) {
-        const auto& input = regs.vertex_attrib_format[index];
-        auto& attribute = attributes[index];
-        attribute.raw = 0;
-        attribute.enabled.Assign(input.IsConstant() ? 0 : 1);
-        attribute.buffer.Assign(input.buffer);
-        attribute.offset.Assign(input.offset);
-        attribute.type.Assign(static_cast<u32>(input.type.Value()));
-        attribute.size.Assign(static_cast<u32>(input.size.Value()));
-        attribute.binding_index_enabled.Assign(regs.vertex_array[index].IsEnabled() ? 1 : 0);
+    if (maxwell3d.dirty.flags[Dirty::VertexAttributes]) {
+        maxwell3d.dirty.flags[Dirty::VertexAttributes] = false;
+        for (size_t index = 0; index < Maxwell::NumVertexAttributes; ++index) {
+            const auto& input = regs.vertex_attrib_format[index];
+            auto& attribute = attributes[index];
+            attribute.raw = 0;
+            attribute.enabled.Assign(input.IsConstant() ? 0 : 1);
+            attribute.buffer.Assign(input.buffer);
+            attribute.offset.Assign(input.offset);
+            attribute.type.Assign(static_cast<u32>(input.type.Value()));
+            attribute.size.Assign(static_cast<u32>(input.size.Value()));
+        }
     }
-
-    for (std::size_t index = 0; index < std::size(attachments); ++index) {
-        attachments[index].Fill(regs, index);
+    if (maxwell3d.dirty.flags[Dirty::Blending]) {
+        maxwell3d.dirty.flags[Dirty::Blending] = false;
+        for (size_t index = 0; index < attachments.size(); ++index) {
+            attachments[index].Refresh(regs, index);
+        }
+    }
+    if (maxwell3d.dirty.flags[Dirty::ViewportSwizzles]) {
+        maxwell3d.dirty.flags[Dirty::ViewportSwizzles] = false;
+        const auto& transform = regs.viewport_transform;
+        std::ranges::transform(transform, viewport_swizzles.begin(), [](const auto& viewport) {
+            return static_cast<u16>(viewport.swizzle.raw);
+        });
     }
-
-    const auto& transform = regs.viewport_transform;
-    std::transform(transform.begin(), transform.end(), viewport_swizzles.begin(),
-                   [](const auto& viewport) { return static_cast<u16>(viewport.swizzle.raw); });
-
     if (!has_extended_dynamic_state) {
         no_extended_dynamic_state.Assign(1);
-        dynamic_state.Fill(regs);
+        dynamic_state.Refresh(regs);
     }
 }
 
-void FixedPipelineState::BlendingAttachment::Fill(const Maxwell& regs, std::size_t index) {
+void FixedPipelineState::BlendingAttachment::Refresh(const Maxwell& regs, size_t index) {
     const auto& mask = regs.color_mask[regs.color_mask_common ? 0 : index];
 
     raw = 0;
@@ -141,7 +154,7 @@ void FixedPipelineState::BlendingAttachment::Fill(const Maxwell& regs, std::size
     enable.Assign(1);
 }
 
-void FixedPipelineState::DynamicState::Fill(const Maxwell& regs) {
+void FixedPipelineState::DynamicState::Refresh(const Maxwell& regs) {
     u32 packed_front_face = PackFrontFace(regs.front_face);
     if (regs.screen_y_control.triangle_rast_flip != 0) {
         // Flip front face
@@ -178,9 +191,9 @@ void FixedPipelineState::DynamicState::Fill(const Maxwell& regs) {
     });
 }
 
-std::size_t FixedPipelineState::Hash() const noexcept {
+size_t FixedPipelineState::Hash() const noexcept {
     const u64 hash = Common::CityHash64(reinterpret_cast<const char*>(this), Size());
-    return static_cast<std::size_t>(hash);
+    return static_cast<size_t>(hash);
 }
 
 bool FixedPipelineState::operator==(const FixedPipelineState& rhs) const noexcept {
diff --git a/src/video_core/renderer_vulkan/fixed_pipeline_state.h b/src/video_core/renderer_vulkan/fixed_pipeline_state.h
index 465a55fdb..a0eb83a68 100644
--- a/src/video_core/renderer_vulkan/fixed_pipeline_state.h
+++ b/src/video_core/renderer_vulkan/fixed_pipeline_state.h
@@ -58,7 +58,7 @@ struct FixedPipelineState {
             BitField<30, 1, u32> enable;
         };
 
-        void Fill(const Maxwell& regs, std::size_t index);
+        void Refresh(const Maxwell& regs, size_t index);
 
         constexpr std::array<bool, 4> Mask() const noexcept {
             return {mask_r != 0, mask_g != 0, mask_b != 0, mask_a != 0};
@@ -96,8 +96,6 @@ struct FixedPipelineState {
         BitField<6, 14, u32> offset;
         BitField<20, 3, u32> type;
         BitField<23, 6, u32> size;
-        // Not really an element of a vertex attribute, but it can be packed here
-        BitField<29, 1, u32> binding_index_enabled;
 
         constexpr Maxwell::VertexAttribute::Type Type() const noexcept {
             return static_cast<Maxwell::VertexAttribute::Type>(type.Value());
@@ -108,7 +106,7 @@ struct FixedPipelineState {
         }
     };
 
-    template <std::size_t Position>
+    template <size_t Position>
     union StencilFace {
         BitField<Position + 0, 3, u32> action_stencil_fail;
         BitField<Position + 3, 3, u32> action_depth_fail;
@@ -152,7 +150,7 @@ struct FixedPipelineState {
         // Vertex stride is a 12 bits value, we have 4 bits to spare per element
         std::array<u16, Maxwell::NumVertexArrays> vertex_strides;
 
-        void Fill(const Maxwell& regs);
+        void Refresh(const Maxwell& regs);
 
         Maxwell::ComparisonOp DepthTestFunc() const noexcept {
             return UnpackComparisonOp(depth_test_func);
@@ -199,9 +197,9 @@ struct FixedPipelineState {
     std::array<u16, Maxwell::NumViewports> viewport_swizzles;
     DynamicState dynamic_state;
 
-    void Fill(const Maxwell& regs, bool has_extended_dynamic_state);
+    void Refresh(Tegra::Engines::Maxwell3D& maxwell3d, bool has_extended_dynamic_state);
 
-    std::size_t Hash() const noexcept;
+    size_t Hash() const noexcept;
 
     bool operator==(const FixedPipelineState& rhs) const noexcept;
 
@@ -209,8 +207,8 @@ struct FixedPipelineState {
         return !operator==(rhs);
     }
 
-    std::size_t Size() const noexcept {
-        const std::size_t total_size = sizeof *this;
+    size_t Size() const noexcept {
+        const size_t total_size = sizeof *this;
         return total_size - (no_extended_dynamic_state != 0 ? 0 : sizeof(DynamicState));
     }
 };
@@ -224,7 +222,7 @@ namespace std {
 
 template <>
 struct hash<Vulkan::FixedPipelineState> {
-    std::size_t operator()(const Vulkan::FixedPipelineState& k) const noexcept {
+    size_t operator()(const Vulkan::FixedPipelineState& k) const noexcept {
         return k.Hash();
     }
 };
diff --git a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp b/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
index d50dca604..fc6dd83eb 100644
--- a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
+++ b/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
@@ -221,9 +221,6 @@ vk::Pipeline VKGraphicsPipeline::CreatePipeline(const SPIRVProgram& program,
     std::vector<VkVertexInputBindingDescription> vertex_bindings;
     std::vector<VkVertexInputBindingDivisorDescriptionEXT> vertex_binding_divisors;
     for (std::size_t index = 0; index < Maxwell::NumVertexArrays; ++index) {
-        if (state.attributes[index].binding_index_enabled == 0) {
-            continue;
-        }
         const bool instanced = state.binding_divisors[index] != 0;
         const auto rate = instanced ? VK_VERTEX_INPUT_RATE_INSTANCE : VK_VERTEX_INPUT_RATE_VERTEX;
         vertex_bindings.push_back({
diff --git a/src/video_core/renderer_vulkan/vk_rasterizer.cpp b/src/video_core/renderer_vulkan/vk_rasterizer.cpp
index 684d4e3a6..dfd38f575 100644
--- a/src/video_core/renderer_vulkan/vk_rasterizer.cpp
+++ b/src/video_core/renderer_vulkan/vk_rasterizer.cpp
@@ -267,8 +267,7 @@ void RasterizerVulkan::Draw(bool is_indexed, bool is_instanced) {
 
     query_cache.UpdateCounters();
 
-    GraphicsPipelineCacheKey key;
-    key.fixed_state.Fill(maxwell3d.regs, device.IsExtExtendedDynamicStateSupported());
+    graphics_key.fixed_state.Refresh(maxwell3d, device.IsExtExtendedDynamicStateSupported());
 
     std::scoped_lock lock{buffer_cache.mutex, texture_cache.mutex};
 
@@ -276,14 +275,15 @@ void RasterizerVulkan::Draw(bool is_indexed, bool is_instanced) {
     texture_cache.UpdateRenderTargets(false);
 
     const auto shaders = pipeline_cache.GetShaders();
-    key.shaders = GetShaderAddresses(shaders);
+    graphics_key.shaders = GetShaderAddresses(shaders);
+
     SetupShaderDescriptors(shaders, is_indexed);
 
     const Framebuffer* const framebuffer = texture_cache.GetFramebuffer();
-    key.renderpass = framebuffer->RenderPass();
+    graphics_key.renderpass = framebuffer->RenderPass();
 
-    auto* const pipeline =
-        pipeline_cache.GetGraphicsPipeline(key, framebuffer->NumColorBuffers(), async_shaders);
+    VKGraphicsPipeline* const pipeline = pipeline_cache.GetGraphicsPipeline(
+        graphics_key, framebuffer->NumColorBuffers(), async_shaders);
     if (pipeline == nullptr || pipeline->GetHandle() == VK_NULL_HANDLE) {
         // Async graphics pipeline was not ready.
         return;
diff --git a/src/video_core/renderer_vulkan/vk_rasterizer.h b/src/video_core/renderer_vulkan/vk_rasterizer.h
index 7fc6741da..acea1ba2d 100644
--- a/src/video_core/renderer_vulkan/vk_rasterizer.h
+++ b/src/video_core/renderer_vulkan/vk_rasterizer.h
@@ -20,6 +20,7 @@
 #include "video_core/renderer_vulkan/vk_buffer_cache.h"
 #include "video_core/renderer_vulkan/vk_descriptor_pool.h"
 #include "video_core/renderer_vulkan/vk_fence_manager.h"
+#include "video_core/renderer_vulkan/vk_graphics_pipeline.h"
 #include "video_core/renderer_vulkan/vk_pipeline_cache.h"
 #include "video_core/renderer_vulkan/vk_query_cache.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
@@ -173,6 +174,8 @@ private:
     VKUpdateDescriptorQueue update_descriptor_queue;
     BlitImageHelper blit_image;
 
+    GraphicsPipelineCacheKey graphics_key;
+
     TextureCacheRuntime texture_cache_runtime;
     TextureCache texture_cache;
     BufferCacheRuntime buffer_cache_runtime;
diff --git a/src/video_core/renderer_vulkan/vk_state_tracker.cpp b/src/video_core/renderer_vulkan/vk_state_tracker.cpp
index e81fad007..956f86845 100644
--- a/src/video_core/renderer_vulkan/vk_state_tracker.cpp
+++ b/src/video_core/renderer_vulkan/vk_state_tracker.cpp
@@ -18,9 +18,7 @@
 #define NUM(field_name) (sizeof(Maxwell3D::Regs::field_name) / (sizeof(u32)))
 
 namespace Vulkan {
-
 namespace {
-
 using namespace Dirty;
 using namespace VideoCommon::Dirty;
 using Tegra::Engines::Maxwell3D;
@@ -128,6 +126,34 @@ void SetupDirtyStencilTestEnable(Tables& tables) {
     tables[0][OFF(stencil_enable)] = StencilTestEnable;
 }
 
+void SetupDirtyBlending(Tables& tables) {
+    tables[0][OFF(color_mask_common)] = Blending;
+    tables[0][OFF(independent_blend_enable)] = Blending;
+    FillBlock(tables[0], OFF(color_mask), NUM(color_mask), Blending);
+    FillBlock(tables[0], OFF(blend), NUM(blend), Blending);
+    FillBlock(tables[0], OFF(independent_blend), NUM(independent_blend), Blending);
+}
+
+void SetupDirtyInstanceDivisors(Tables& tables) {
+    static constexpr size_t divisor_offset = 3;
+    for (size_t index = 0; index < Regs::NumVertexArrays; ++index) {
+        tables[0][OFF(instanced_arrays) + index] = InstanceDivisors;
+        tables[0][OFF(vertex_array) + index * NUM(vertex_array[0]) + divisor_offset] =
+            InstanceDivisors;
+    }
+}
+
+void SetupDirtyVertexAttributes(Tables& tables) {
+    FillBlock(tables[0], OFF(vertex_attrib_format), NUM(vertex_attrib_format), VertexAttributes);
+}
+
+void SetupDirtyViewportSwizzles(Tables& tables) {
+    static constexpr size_t swizzle_offset = 6;
+    for (size_t index = 0; index < Regs::NumViewports; ++index) {
+        tables[0][OFF(viewport_transform) + index * NUM(viewport_transform[0]) + swizzle_offset] =
+            ViewportSwizzles;
+    }
+}
 } // Anonymous namespace
 
 StateTracker::StateTracker(Tegra::GPU& gpu)
@@ -148,6 +174,10 @@ StateTracker::StateTracker(Tegra::GPU& gpu)
     SetupDirtyFrontFace(tables);
     SetupDirtyStencilOp(tables);
     SetupDirtyStencilTestEnable(tables);
+    SetupDirtyBlending(tables);
+    SetupDirtyInstanceDivisors(tables);
+    SetupDirtyVertexAttributes(tables);
+    SetupDirtyViewportSwizzles(tables);
 }
 
 } // namespace Vulkan
diff --git a/src/video_core/renderer_vulkan/vk_state_tracker.h b/src/video_core/renderer_vulkan/vk_state_tracker.h
index c335d2bdf..84e918a71 100644
--- a/src/video_core/renderer_vulkan/vk_state_tracker.h
+++ b/src/video_core/renderer_vulkan/vk_state_tracker.h
@@ -35,6 +35,11 @@ enum : u8 {
     StencilOp,
     StencilTestEnable,
 
+    Blending,
+    InstanceDivisors,
+    VertexAttributes,
+    ViewportSwizzles,
+
     Last
 };
 static_assert(Last <= std::numeric_limits<u8>::max());
diff --git a/src/yuzu/configuration/config.cpp b/src/yuzu/configuration/config.cpp
index 0635d13d0..3d6f64300 100644
--- a/src/yuzu/configuration/config.cpp
+++ b/src/yuzu/configuration/config.cpp
@@ -614,12 +614,6 @@ void Config::ReadDataStorageValues() {
                                 QString::fromStdString(FS::GetUserPath(FS::UserPath::DumpDir)))
                         .toString()
                         .toStdString());
-    FS::GetUserPath(FS::UserPath::CacheDir,
-                    qt_config
-                        ->value(QStringLiteral("cache_directory"),
-                                QString::fromStdString(FS::GetUserPath(FS::UserPath::CacheDir)))
-                        .toString()
-                        .toStdString());
     Settings::values.gamecard_inserted =
         ReadSetting(QStringLiteral("gamecard_inserted"), false).toBool();
     Settings::values.gamecard_current_game =
@@ -1218,9 +1212,6 @@ void Config::SaveDataStorageValues() {
     WriteSetting(QStringLiteral("dump_directory"),
                  QString::fromStdString(FS::GetUserPath(FS::UserPath::DumpDir)),
                  QString::fromStdString(FS::GetUserPath(FS::UserPath::DumpDir)));
-    WriteSetting(QStringLiteral("cache_directory"),
-                 QString::fromStdString(FS::GetUserPath(FS::UserPath::CacheDir)),
-                 QString::fromStdString(FS::GetUserPath(FS::UserPath::CacheDir)));
     WriteSetting(QStringLiteral("gamecard_inserted"), Settings::values.gamecard_inserted, false);
     WriteSetting(QStringLiteral("gamecard_current_game"), Settings::values.gamecard_current_game,
                  false);
diff --git a/src/yuzu/configuration/configure_filesystem.cpp b/src/yuzu/configuration/configure_filesystem.cpp
index 7ab4a80f7..bde2d4620 100644
--- a/src/yuzu/configuration/configure_filesystem.cpp
+++ b/src/yuzu/configuration/configure_filesystem.cpp
@@ -26,8 +26,6 @@ ConfigureFilesystem::ConfigureFilesystem(QWidget* parent)
             [this] { SetDirectory(DirectoryTarget::Dump, ui->dump_path_edit); });
     connect(ui->load_path_button, &QToolButton::pressed, this,
             [this] { SetDirectory(DirectoryTarget::Load, ui->load_path_edit); });
-    connect(ui->cache_directory_button, &QToolButton::pressed, this,
-            [this] { SetDirectory(DirectoryTarget::Cache, ui->cache_directory_edit); });
 
     connect(ui->reset_game_list_cache, &QPushButton::pressed, this,
             &ConfigureFilesystem::ResetMetadata);
@@ -50,8 +48,6 @@ void ConfigureFilesystem::setConfiguration() {
         QString::fromStdString(Common::FS::GetUserPath(Common::FS::UserPath::DumpDir)));
     ui->load_path_edit->setText(
         QString::fromStdString(Common::FS::GetUserPath(Common::FS::UserPath::LoadDir)));
-    ui->cache_directory_edit->setText(
-        QString::fromStdString(Common::FS::GetUserPath(Common::FS::UserPath::CacheDir)));
 
     ui->gamecard_inserted->setChecked(Settings::values.gamecard_inserted);
     ui->gamecard_current_game->setChecked(Settings::values.gamecard_current_game);
@@ -72,9 +68,6 @@ void ConfigureFilesystem::applyConfiguration() {
                             ui->dump_path_edit->text().toStdString());
     Common::FS::GetUserPath(Common::FS::UserPath::LoadDir,
                             ui->load_path_edit->text().toStdString());
-    Common::FS::GetUserPath(Common::FS::UserPath::CacheDir,
-                            ui->cache_directory_edit->text().toStdString());
-    Settings::values.gamecard_path = ui->gamecard_path_edit->text().toStdString();
 
     Settings::values.gamecard_inserted = ui->gamecard_inserted->isChecked();
     Settings::values.gamecard_current_game = ui->gamecard_current_game->isChecked();
@@ -103,9 +96,6 @@ void ConfigureFilesystem::SetDirectory(DirectoryTarget target, QLineEdit* edit)
     case DirectoryTarget::Load:
         caption = tr("Select Mod Load Directory...");
         break;
-    case DirectoryTarget::Cache:
-        caption = tr("Select Cache Directory...");
-        break;
     }
 
     QString str;
diff --git a/src/yuzu/configuration/configure_filesystem.h b/src/yuzu/configuration/configure_filesystem.h
index a79303760..2147cd405 100644
--- a/src/yuzu/configuration/configure_filesystem.h
+++ b/src/yuzu/configuration/configure_filesystem.h
@@ -32,7 +32,6 @@ private:
         Gamecard,
         Dump,
         Load,
-        Cache,
     };
 
     void SetDirectory(DirectoryTarget target, QLineEdit* edit);
diff --git a/src/yuzu/configuration/configure_filesystem.ui b/src/yuzu/configuration/configure_filesystem.ui
index 84bea0600..62b9abc7a 100644
--- a/src/yuzu/configuration/configure_filesystem.ui
+++ b/src/yuzu/configuration/configure_filesystem.ui
@@ -198,40 +198,7 @@
         <string>Caching</string>
        </property>
        <layout class="QGridLayout" name="gridLayout_5">
-        <item row="0" column="0">
-         <widget class="QLabel" name="label_10">
-          <property name="text">
-           <string>Cache Directory</string>
-          </property>
-         </widget>
-        </item>
-        <item row="0" column="1">
-         <spacer name="horizontalSpacer_3">
-          <property name="orientation">
-           <enum>Qt::Horizontal</enum>
-          </property>
-          <property name="sizeType">
-           <enum>QSizePolicy::Fixed</enum>
-          </property>
-          <property name="sizeHint" stdset="0">
-           <size>
-            <width>40</width>
-            <height>20</height>
-           </size>
-          </property>
-         </spacer>
-        </item>
-        <item row="0" column="2">
-         <widget class="QLineEdit" name="cache_directory_edit"/>
-        </item>
-        <item row="0" column="3">
-         <widget class="QToolButton" name="cache_directory_button">
-          <property name="text">
-           <string>...</string>
-          </property>
-         </widget>
-        </item>
-        <item row="1" column="0" colspan="4">
+        <item row="0" column="0" colspan="2">
          <layout class="QHBoxLayout" name="horizontalLayout_2">
           <item>
            <widget class="QCheckBox" name="cache_game_list">
diff --git a/src/yuzu_cmd/config.cpp b/src/yuzu_cmd/config.cpp
index aa0a9f288..6d8bc5509 100644
--- a/src/yuzu_cmd/config.cpp
+++ b/src/yuzu_cmd/config.cpp
@@ -329,9 +329,6 @@ void Config::ReadValues() {
     FS::GetUserPath(
         FS::UserPath::DumpDir,
         sdl2_config->Get("Data Storage", "dump_directory", FS::GetUserPath(FS::UserPath::DumpDir)));
-    FS::GetUserPath(FS::UserPath::CacheDir,
-                    sdl2_config->Get("Data Storage", "cache_directory",
-                                     FS::GetUserPath(FS::UserPath::CacheDir)));
     Settings::values.gamecard_inserted =
         sdl2_config->GetBoolean("Data Storage", "gamecard_inserted", false);
     Settings::values.gamecard_current_game =